syscse.c

   1 /*
   2   SPDX-License-Identifier: GPL-2.0-only
   3
   4   Copyright (C) 2007-2016 Arnaldo Carvalho de Melo <acme@kernel.org>
   5
   6   System call sign extender
   7 */
   8
   9 #include <argp.h>
  10 #include <assert.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 #include "dwarves.h"
  16 #include "dutil.h"
  17
  18 static const char *prefix = "sys_";
  19 static size_t prefix_len = 4;
  20
  21 static struct conf_fprintf conf;
  22
  23 static struct conf_load conf_load = {
  24         .conf_fprintf = &conf,
  25 };
  26
  27 static bool filter(struct function *f)
  28 {
  29         if (f->proto.nr_parms != 0) {
  30                 const char *name = function__name(f);
  31
  32                 if (strlen(name) > prefix_len &&
  33                     memcmp(name, prefix, prefix_len) == 0)
  34                         return false;
  35         }
  36         return true;
  37 }
  38
  39 static void zero_extend(const int regparm, const struct base_type *bt, const char *parm)
  40 {
  41         const char *instr = "INVALID";
  42
  43         switch (bt->bit_size) {
  44         case 32:
  45                 instr = "sll";
  46                 break;
  47         case 16:
  48                 instr = "slw";
  49                 break;
  50         case 8:
  51                 instr = "slb";
  52                 break;
  53         }
  54
  55         char bf[64];
  56         printf("\t%s\t$a%d, $a%d, 0"
  57                "\t/* zero extend $a%d(%s %s) from %d to 64-bit */\n",
  58                instr, regparm, regparm, regparm,
  59                base_type__name(bt, bf, sizeof(bf)),
  60                parm, bt->bit_size);
  61 }
  62
  63 static void emit_wrapper(struct function *f, struct cu *cu)
  64 {
  65         struct parameter *parm;
  66         const char *name = function__name(f);
  67         int regparm = 0, needs_wrapper = 0;
  68
  69         function__for_each_parameter(f, cu, parm) {
  70                 const type_id_t type_id = parm->tag.type;
  71                 struct tag *type = cu__type(cu, type_id);
  72
  73                 tag__assert_search_result(type, parm->tag.tag, parameter__name(parm));
  74                 if (type->tag == DW_TAG_base_type) {
  75                         struct base_type *bt = tag__base_type(type);
  76                         char bf[64];
  77
  78                         if (bt->bit_size < 64 &&
  79                             strncmp(base_type__name(bt, bf, sizeof(bf)), "unsigned", 8) == 0) {
  80                                 if (!needs_wrapper) {
  81                                         printf("wrap_%s:\n", name);
  82                                         needs_wrapper = 1;
  83                                 }
  84                                 zero_extend(regparm, bt, parameter__name(parm));
  85                         }
  86                 }
  87                 ++regparm;
  88         }
  89
  90         if (needs_wrapper)
  91                 printf("\tj\t%s\n\n", name);
  92 }
  93
  94 static int cu__emit_wrapper(struct cu *cu, void *cookie __maybe_unused)
  95 {
  96         struct function *pos;
  97         uint32_t id;
  98
  99         cu__for_each_function(cu, id, pos)
 100                 if (!filter(pos))
 101                         emit_wrapper(pos, cu);
 102         return 0;
 103 }
 104
 105 static void cus__emit_wrapper(struct cus *cu)
 106 {
 107         cus__for_each_cu(cu, cu__emit_wrapper, NULL, NULL);
 108 }
 109
 110 /* Name and version of program.  */
 111 ARGP_PROGRAM_VERSION_HOOK_DEF = dwarves_print_version;
 112
 113 static const struct argp_option options[] = {
 114         {
 115                 .key  = 'p',
 116                 .name = "prefix",
 117                 .arg  = "PREFIX",
 118                 .doc  = "function prefix",
 119         },
 120         {
 121                 .name = NULL,
 122         }
 123 };
 124
 125 static error_t options_parser(int key, char *arg, struct argp_state *state)
 126 {
 127         switch (key) {
 128         case ARGP_KEY_INIT:
 129                 if (state->child_inputs != NULL)
 130                         state->child_inputs[0] = state->input;
 131                 break;
 132         case 'p':
 133                 prefix = arg;
 134                 prefix_len = strlen(prefix);
 135                 break;
 136         default:
 137                 return ARGP_ERR_UNKNOWN;
 138         }
 139         return 0;
 140 }
 141
 142 static const char args_doc[] = "FILE";
 143
 144 static struct argp argp = {
 145         .options  = options,
 146         .parser   = options_parser,
 147         .args_doc = args_doc,
 148 };
 149
 150 int main(int argc, char *argv[])
 151 {
 152         int err, remaining;
 153         struct cus *cus = cus__new();
 154
 155         if (cus == NULL) {
 156                 fprintf(stderr, "%s: insufficient memory\n", argv[0]);
 157                 return EXIT_FAILURE;
 158         }
 159
 160         if (argp_parse(&argp, argc, argv, 0, &remaining, NULL) ||
 161             remaining == argc) {
 162                 argp_help(&argp, stderr, ARGP_HELP_SEE, argv[0]);
 163                 return EXIT_FAILURE;
 164         }
 165         err = cus__load_files(cus, &conf_load, argv + remaining);
 166         if (err != 0) {
 167                 cus__fprintf_load_files_err(cus, "syscse", argv + remaining, err, stderr);
 168                 return EXIT_FAILURE;
 169         }
 170
 171         cus__emit_wrapper(cus);
 172         return EXIT_SUCCESS;
 173 }