pglobal.c

   1 /*
   2  * SPDX-License-Identifier: GPL-2.0-only
   3  *
   4  * Copyright (C) 2007 Davi E. M. Arnaut <davi@haxent.com.br>
   5  */
   6
   7 #include <argp.h>
   8 #include <malloc.h>
   9 #include <search.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <unistd.h>
  14
  15 #include "dwarves.h"
  16 #include "dutil.h"
  17
  18 static int verbose;
  19
  20 static struct conf_fprintf conf = {
  21         .emit_stats = 1,
  22 };
  23
  24 static struct conf_load conf_load = {
  25         .conf_fprintf = &conf,
  26 };
  27
  28 struct extvar {
  29         struct extvar           *next;
  30         const char              *name;
  31         const struct variable   *var;
  32         const struct cu         *cu;
  33 };
  34
  35 struct extfun {
  36         struct extfun           *next;
  37         const char              *name;
  38         const struct function   *fun;
  39         const struct cu         *cu;
  40 };
  41
  42 static void *tree;
  43
  44 static void oom(const char *msg)
  45 {
  46         fprintf(stderr, "pglobal: out of memory (%s)\n", msg);
  47         exit(EXIT_FAILURE);
  48 }
  49
  50 static struct extvar *extvar__new(const struct variable *var,
  51                                   const struct cu *cu)
  52 {
  53         struct extvar *gvar = malloc(sizeof(*gvar));
  54
  55         if (gvar != NULL) {
  56                 gvar->next = NULL;
  57                 gvar->var  = var;
  58                 gvar->cu   = cu;
  59                 gvar->name = variable__name(var);
  60         }
  61
  62         return gvar;
  63 }
  64
  65 static struct extfun *extfun__new(struct function *fun,
  66                                   const struct cu *cu)
  67 {
  68         struct extfun *gfun = malloc(sizeof(*gfun));
  69
  70         if (gfun != NULL) {
  71                 gfun->next = NULL;
  72                 gfun->fun  = fun;
  73                 gfun->cu   = cu;
  74                 gfun->name = function__name(fun);
  75         }
  76
  77         return gfun;
  78 }
  79
  80 static int extvar__compare(const void *a, const void *b)
  81 {
  82         const struct extvar *ga = a, *gb = b;
  83         return strcmp(ga->name, gb->name);
  84 }
  85
  86 static int extfun__compare(const void *a, const void *b)
  87 {
  88         const struct extfun *ga = a, *gb = b;
  89         return strcmp(ga->name, gb->name);
  90 }
  91
  92 static void extvar__add(const struct variable *var, const struct cu *cu)
  93 {
  94         struct extvar **nodep, *gvar = extvar__new(var, cu);
  95
  96         if (gvar != NULL) {
  97                 nodep = tsearch(gvar, &tree, extvar__compare);
  98                 if (nodep == NULL)
  99                         oom("tsearch");
 100                 else if (*nodep != gvar) {
 101                         if (gvar->var->declaration) {
 102                                 gvar->next = (*nodep)->next;
 103                                 (*nodep)->next = gvar;
 104                         } else {
 105                                 gvar->next = *nodep;
 106                                 *nodep = gvar;
 107                         }
 108                 }
 109         }
 110 }
 111
 112 static void extfun__add(struct function *fun, const struct cu *cu)
 113 {
 114         struct extfun **nodep, *gfun = extfun__new(fun, cu);
 115
 116         if (gfun != NULL) {
 117                 nodep = tsearch(gfun, &tree, extfun__compare);
 118                 if (nodep == NULL)
 119                         oom("tsearch");
 120                 else if (*nodep != gfun) {
 121                         gfun->next = (*nodep)->next;
 122                         (*nodep)->next = gfun;
 123                 }
 124         }
 125 }
 126
 127 static int cu_extvar_iterator(struct cu *cu, void *cookie __maybe_unused)
 128 {
 129         struct tag *pos;
 130         uint32_t id;
 131
 132         cu__for_each_variable(cu, id, pos) {
 133                 struct variable *var = tag__variable(pos);
 134                 if (var->external)
 135                         extvar__add(var, cu);
 136         }
 137         return 0;
 138 }
 139
 140 static int cu_extfun_iterator(struct cu *cu, void *cookie __maybe_unused)
 141 {
 142         struct function *pos;
 143         uint32_t id;
 144
 145         cu__for_each_function(cu, id, pos)
 146                 if (pos->external)
 147                         extfun__add(pos, cu);
 148         return 0;
 149 }
 150
 151 static inline const struct extvar *node__variable(const void *nodep)
 152 {
 153         return *((const struct extvar **)nodep);
 154 }
 155
 156 static inline const struct extfun *node__function(const void *nodep)
 157 {
 158         return *((const struct extfun **)nodep);
 159 }
 160
 161 static inline struct tag *extvar__tag(const struct extvar *gvar)
 162 {
 163         return (struct tag *)gvar->var;
 164 }
 165
 166 static inline struct tag *extfun__tag(const struct extfun *gfun)
 167 {
 168         return (struct tag *)gfun->fun;
 169 }
 170
 171 static void declaration_action__walk(const void *nodep, const VISIT which,
 172                                      const int depth __maybe_unused)
 173 {
 174         uint32_t count = 0;
 175         struct tag *tag;
 176         const struct extvar *pos, *gvar = NULL;
 177
 178         switch(which) {
 179         case preorder:
 180                 break;
 181         case postorder:
 182                 gvar = node__variable(nodep);
 183                 break;
 184         case endorder:
 185                 break;
 186         case leaf:
 187                 gvar = node__variable(nodep);
 188                 break;
 189         }
 190
 191         if (gvar == NULL)
 192                 return;
 193
 194         tag = extvar__tag(gvar);
 195
 196         tag__fprintf(tag, gvar->cu, NULL, stdout);
 197
 198         for (pos = gvar->next; pos; pos = pos->next)
 199                 count++;
 200
 201         printf("; /* %u */\n\n", count);
 202 }
 203
 204 static void function_action__walk(const void *nodep, const VISIT which,
 205                                   const int depth __maybe_unused)
 206 {
 207         struct tag *tag;
 208         const struct extfun *gfun = NULL;
 209
 210         switch(which) {
 211         case preorder:
 212                 break;
 213         case postorder:
 214                 gfun = node__function(nodep);
 215                 break;
 216         case endorder:
 217                 break;
 218         case leaf:
 219                 gfun = node__function(nodep);
 220                 break;
 221         }
 222
 223         if (gfun == NULL)
 224                 return;
 225
 226         tag = extfun__tag(gfun);
 227
 228         tag__fprintf(tag, gfun->cu, NULL, stdout);
 229
 230         fputs("\n\n", stdout);
 231 }
 232
 233 static void free_node(void *nodep)
 234 {
 235         void **node = nodep;
 236         free(*node);
 237 }
 238
 239 /* Name and version of program.  */
 240 ARGP_PROGRAM_VERSION_HOOK_DEF = dwarves_print_version;
 241
 242 static const struct argp_option pglobal__options[] = {
 243         {
 244                 .key  = 'v',
 245                 .name = "variables",
 246                 .doc  = "show global variables",
 247         },
 248         {
 249                 .key  = 'f',
 250                 .name = "functions",
 251                 .doc  = "show global functions",
 252         },
 253         {
 254                 .name = "format_path",
 255                 .key  = 'F',
 256                 .arg  = "FORMAT_LIST",
 257                 .doc  = "List of debugging formats to try"
 258         },
 259         {
 260                 .key  = 'V',
 261                 .name = "verbose",
 262                 .doc  = "be verbose",
 263         },
 264         {
 265                 .name = NULL,
 266         }
 267 };
 268
 269 static int walk_var, walk_fun;
 270
 271 static error_t pglobal__options_parser(int key, char *arg __maybe_unused,
 272                                       struct argp_state *state)
 273 {
 274         switch (key) {
 275         case ARGP_KEY_INIT:
 276                 if (state->child_inputs != NULL)
 277                         state->child_inputs[0] = state->input;
 278                 break;
 279         case 'v': walk_var = 1;         break;
 280         case 'f': walk_fun = 1;         break;
 281         case 'V': verbose = 1;          break;
 282         case 'F': conf_load.format_path = arg;          break;
 283         default:  return ARGP_ERR_UNKNOWN;
 284         }
 285         return 0;
 286 }
 287
 288 static const char pglobal__args_doc[] = "FILE";
 289
 290 static struct argp pglobal__argp = {
 291         .options  = pglobal__options,
 292         .parser   = pglobal__options_parser,
 293         .args_doc = pglobal__args_doc,
 294 };
 295
 296 int main(int argc, char *argv[])
 297 {
 298         int err, remaining, rc = EXIT_FAILURE;
 299
 300         if (argp_parse(&pglobal__argp, argc, argv, 0, &remaining, NULL) ||
 301             remaining == argc) {
 302                 argp_help(&pglobal__argp, stderr, ARGP_HELP_SEE, argv[0]);
 303                 goto out;
 304         }
 305
 306         if (dwarves__init()) {
 307                 fputs("pglobal: insufficient memory\n", stderr);
 308                 goto out;
 309         }
 310
 311         dwarves__resolve_cacheline_size(&conf_load, 0);
 312
 313         struct cus *cus = cus__new();
 314         if (cus == NULL) {
 315                 fputs("pglobal: insufficient memory\n", stderr);
 316                 goto out_dwarves_exit;
 317         }
 318
 319         err = cus__load_files(cus, &conf_load, argv + remaining);
 320         if (err != 0) {
 321                 cus__fprintf_load_files_err(cus, "pglobal", argv + remaining, err, stderr);
 322                 goto out_cus_delete;
 323         }
 324
 325         if (walk_var) {
 326                 cus__for_each_cu(cus, cu_extvar_iterator, NULL, NULL);
 327                 twalk(tree, declaration_action__walk);
 328         } else if (walk_fun) {
 329                 cus__for_each_cu(cus, cu_extfun_iterator, NULL, NULL);
 330                 twalk(tree, function_action__walk);
 331         }
 332
 333         tdestroy(tree, free_node);
 334         rc = EXIT_SUCCESS;
 335 out_cus_delete:
 336         cus__delete(cus);
 337 out_dwarves_exit:
 338         dwarves__exit();
 339 out:
 340         return rc;
 341 }