gdb/macrocmd.c

   1 /* C preprocessor macro expansion commands for GDB.
   2    Copyright (C) 2002-2017 Free Software Foundation, Inc.
   3    Contributed by Red Hat, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20
  21 #include "defs.h"
  22 #include "macrotab.h"
  23 #include "macroexp.h"
  24 #include "macroscope.h"
  25 #include "cli/cli-utils.h"
  26 #include "command.h"
  27 #include "gdbcmd.h"
  28 #include "linespec.h"
  29
  30 \f
  31 /* The `macro' prefix command.  */
  32
  33 static struct cmd_list_element *macrolist;
  34
  35 static void
  36 macro_command (char *arg, int from_tty)
  37 {
  38   printf_unfiltered
  39     ("\"macro\" must be followed by the name of a macro command.\n");
  40   help_list (macrolist, "macro ", all_commands, gdb_stdout);
  41 }
  42
  43
  44 \f
  45 /* Macro expansion commands.  */
  46
  47
  48 /* Prints an informational message regarding the lack of macro information.  */
  49 static void
  50 macro_inform_no_debuginfo (void)
  51 {
  52   puts_filtered ("GDB has no preprocessor macro information for that code.\n");
  53 }
  54
  55 static void
  56 macro_expand_command (char *exp, int from_tty)
  57 {
  58   struct macro_scope *ms = NULL;
  59   char *expanded = NULL;
  60   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
  61
  62   make_cleanup (free_current_contents, &expanded);
  63
  64   /* You know, when the user doesn't specify any expression, it would be
  65      really cool if this defaulted to the last expression evaluated.
  66      Then it would be easy to ask, "Hey, what did I just evaluate?"  But
  67      at the moment, the `print' commands don't save the last expression
  68      evaluated, just its value.  */
  69   if (! exp || ! *exp)
  70     error (_("You must follow the `macro expand' command with the"
  71            " expression you\n"
  72            "want to expand."));
  73
  74   ms = default_macro_scope ();
  75   if (ms)
  76     {
  77       expanded = macro_expand (exp, standard_macro_lookup, ms);
  78       fputs_filtered ("expands to: ", gdb_stdout);
  79       fputs_filtered (expanded, gdb_stdout);
  80       fputs_filtered ("\n", gdb_stdout);
  81     }
  82   else
  83     macro_inform_no_debuginfo ();
  84
  85   do_cleanups (cleanup_chain);
  86   return;
  87 }
  88
  89
  90 static void
  91 macro_expand_once_command (char *exp, int from_tty)
  92 {
  93   struct macro_scope *ms = NULL;
  94   char *expanded = NULL;
  95   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
  96   make_cleanup (free_current_contents, &expanded);
  97
  98   /* You know, when the user doesn't specify any expression, it would be
  99      really cool if this defaulted to the last expression evaluated.
 100      And it should set the once-expanded text as the new `last
 101      expression'.  That way, you could just hit return over and over and
 102      see the expression expanded one level at a time.  */
 103   if (! exp || ! *exp)
 104     error (_("You must follow the `macro expand-once' command with"
 105            " the expression\n"
 106            "you want to expand."));
 107
 108   ms = default_macro_scope ();
 109   if (ms)
 110     {
 111       expanded = macro_expand_once (exp, standard_macro_lookup, ms);
 112       fputs_filtered ("expands to: ", gdb_stdout);
 113       fputs_filtered (expanded, gdb_stdout);
 114       fputs_filtered ("\n", gdb_stdout);
 115     }
 116   else
 117     macro_inform_no_debuginfo ();
 118
 119   do_cleanups (cleanup_chain);
 120   return;
 121 }
 122
 123 /*  Outputs the include path of a macro starting at FILE and LINE to STREAM.
 124
 125     Care should be taken that this function does not cause any lookups into
 126     the splay tree so that it can be safely used while iterating.  */
 127 static void
 128 show_pp_source_pos (struct ui_file *stream,
 129                     struct macro_source_file *file,
 130                     int line)
 131 {
 132   char *fullname;
 133
 134   fullname = macro_source_fullname (file);
 135   fprintf_filtered (stream, "%s:%d\n", fullname, line);
 136   xfree (fullname);
 137
 138   while (file->included_by)
 139     {
 140       fullname = macro_source_fullname (file->included_by);
 141       fprintf_filtered (gdb_stdout, "  included at %s:%d\n", fullname,
 142                         file->included_at_line);
 143       xfree (fullname);
 144       file = file->included_by;
 145     }
 146 }
 147
 148 /* Outputs a macro for human consumption, detailing the include path
 149    and macro definition.  NAME is the name of the macro.
 150    D the definition.  FILE the start of the include path, and LINE the
 151    line number in FILE.
 152
 153    Care should be taken that this function does not cause any lookups into
 154    the splay tree so that it can be safely used while iterating.  */
 155 static void
 156 print_macro_definition (const char *name,
 157                         const struct macro_definition *d,
 158                         struct macro_source_file *file,
 159                         int line)
 160 {
 161   fprintf_filtered (gdb_stdout, "Defined at ");
 162   show_pp_source_pos (gdb_stdout, file, line);
 163
 164   if (line != 0)
 165     fprintf_filtered (gdb_stdout, "#define %s", name);
 166   else
 167     fprintf_filtered (gdb_stdout, "-D%s", name);
 168
 169   if (d->kind == macro_function_like)
 170     {
 171       int i;
 172
 173       fputs_filtered ("(", gdb_stdout);
 174       for (i = 0; i < d->argc; i++)
 175         {
 176           fputs_filtered (d->argv[i], gdb_stdout);
 177           if (i + 1 < d->argc)
 178             fputs_filtered (", ", gdb_stdout);
 179         }
 180       fputs_filtered (")", gdb_stdout);
 181     }
 182
 183   if (line != 0)
 184     fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
 185   else
 186     fprintf_filtered (gdb_stdout, "=%s\n", d->replacement);
 187 }
 188
 189 /* The implementation of the `info macro' command.  */
 190 static void
 191 info_macro_command (char *args, int from_tty)
 192 {
 193   struct macro_scope *ms = NULL;
 194   struct cleanup *cleanup_chain;
 195   char *name;
 196   int show_all_macros_named = 0;
 197   char *arg_start = args;
 198   int processing_args = 1;
 199
 200   while (processing_args
 201          && arg_start && *arg_start == '-' && *arg_start != '\0')
 202     {
 203       char *p = skip_to_space (arg_start);
 204
 205       if (strncmp (arg_start, "-a", p - arg_start) == 0
 206           || strncmp (arg_start, "-all", p - arg_start) == 0)
 207         show_all_macros_named = 1;
 208       else if (strncmp (arg_start, "--", p - arg_start) == 0)
 209           /* Our macro support seems rather C specific but this would
 210              seem necessary for languages allowing - in macro names.
 211              e.g. Scheme's (defmacro ->foo () "bar\n")  */
 212         processing_args = 0;
 213       else
 214         {
 215           /* Relies on modified 'args' not making it in to history */
 216           *p = '\0';
 217           error (_("Unrecognized option '%s' to info macro command.  "
 218                    "Try \"help info macro\"."), arg_start);
 219         }
 220
 221         arg_start = skip_spaces (p);
 222     }
 223
 224   name = arg_start;
 225
 226   if (! name || ! *name)
 227     error (_("You must follow the `info macro' command with the name"
 228              " of the macro\n"
 229              "whose definition you want to see."));
 230
 231   ms = default_macro_scope ();
 232   cleanup_chain = make_cleanup (free_current_contents, &ms);
 233
 234   if (! ms)
 235     macro_inform_no_debuginfo ();
 236   else if (show_all_macros_named)
 237     macro_for_each (ms->file->table, [&] (const char *macro_name,
 238                                           const macro_definition *macro,
 239                                           macro_source_file *source,
 240                                           int line)
 241       {
 242         if (strcmp (name, macro_name) == 0)
 243           print_macro_definition (name, macro, source, line);
 244       });
 245   else
 246     {
 247       struct macro_definition *d;
 248
 249       d = macro_lookup_definition (ms->file, ms->line, name);
 250       if (d)
 251         {
 252           int line;
 253           struct macro_source_file *file
 254             = macro_definition_location (ms->file, ms->line, name, &line);
 255
 256           print_macro_definition (name, d, file, line);
 257         }
 258       else
 259         {
 260           fprintf_filtered (gdb_stdout,
 261                             "The symbol `%s' has no definition as a C/C++"
 262                             " preprocessor macro\n"
 263                             "at ", name);
 264           show_pp_source_pos (gdb_stdout, ms->file, ms->line);
 265         }
 266     }
 267
 268   do_cleanups (cleanup_chain);
 269 }
 270
 271 /* Implementation of the "info macros" command. */
 272 static void
 273 info_macros_command (char *args, int from_tty)
 274 {
 275   struct macro_scope *ms = NULL;
 276   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
 277
 278   if (args == NULL)
 279     ms = default_macro_scope ();
 280   else
 281     {
 282       std::vector<symtab_and_line> sals
 283         = decode_line_with_current_source (args, 0);
 284
 285       if (!sals.empty ())
 286         ms = sal_macro_scope (sals[0]);
 287     }
 288
 289   if (! ms || ! ms->file || ! ms->file->table)
 290     macro_inform_no_debuginfo ();
 291   else
 292     macro_for_each_in_scope (ms->file, ms->line, print_macro_definition);
 293
 294   do_cleanups (cleanup_chain);
 295 }
 296
 297 \f
 298 /* User-defined macros.  */
 299
 300 static void
 301 skip_ws (char **expp)
 302 {
 303   while (macro_is_whitespace (**expp))
 304     ++*expp;
 305 }
 306
 307 /* Try to find the bounds of an identifier.  If an identifier is
 308    found, returns a newly allocated string; otherwise returns NULL.
 309    EXPP is a pointer to an input string; it is updated to point to the
 310    text following the identifier.  If IS_PARAMETER is true, this
 311    function will also allow "..." forms as used in varargs macro
 312    parameters.  */
 313
 314 static char *
 315 extract_identifier (char **expp, int is_parameter)
 316 {
 317   char *result;
 318   char *p = *expp;
 319   unsigned int len;
 320
 321   if (is_parameter && startswith (p, "..."))
 322     {
 323       /* Ok.  */
 324     }
 325   else
 326     {
 327       if (! *p || ! macro_is_identifier_nondigit (*p))
 328         return NULL;
 329       for (++p;
 330            *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
 331            ++p)
 332         ;
 333     }
 334
 335   if (is_parameter && startswith (p, "..."))
 336     p += 3;
 337
 338   len = p - *expp;
 339   result = (char *) xmalloc (len + 1);
 340   memcpy (result, *expp, len);
 341   result[len] = '\0';
 342   *expp += len;
 343   return result;
 344 }
 345
 346 /* Helper function to clean up a temporarily-constructed macro object.
 347    This assumes that the contents were all allocated with xmalloc.  */
 348 static void
 349 free_macro_definition_ptr (void *ptr)
 350 {
 351   int i;
 352   struct macro_definition *loc = (struct macro_definition *) ptr;
 353
 354   for (i = 0; i < loc->argc; ++i)
 355     xfree ((char *) loc->argv[i]);
 356   xfree ((char *) loc->argv);
 357   /* Note that the 'replacement' field is not allocated.  */
 358 }
 359
 360 static void
 361 macro_define_command (char *exp, int from_tty)
 362 {
 363   struct macro_definition new_macro;
 364   char *name = NULL;
 365   struct cleanup *cleanup_chain;
 366
 367   if (!exp)
 368     error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
 369
 370   cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro);
 371   make_cleanup (free_current_contents, &name);
 372
 373   memset (&new_macro, 0, sizeof (struct macro_definition));
 374
 375   skip_ws (&exp);
 376   name = extract_identifier (&exp, 0);
 377   if (! name)
 378     error (_("Invalid macro name."));
 379   if (*exp == '(')
 380     {
 381       /* Function-like macro.  */
 382       int alloced = 5;
 383       char **argv = XNEWVEC (char *, alloced);
 384
 385       new_macro.kind = macro_function_like;
 386       new_macro.argc = 0;
 387       new_macro.argv = (const char * const *) argv;
 388
 389       /* Skip the '(' and whitespace.  */
 390       ++exp;
 391       skip_ws (&exp);
 392
 393       while (*exp != ')')
 394         {
 395           int i;
 396
 397           if (new_macro.argc == alloced)
 398             {
 399               alloced *= 2;
 400               argv = (char **) xrealloc (argv, alloced * sizeof (char *));
 401               /* Must update new_macro as well...  */
 402               new_macro.argv = (const char * const *) argv;
 403             }
 404           argv[new_macro.argc] = extract_identifier (&exp, 1);
 405           if (! argv[new_macro.argc])
 406             error (_("Macro is missing an argument."));
 407           ++new_macro.argc;
 408
 409           for (i = new_macro.argc - 2; i >= 0; --i)
 410             {
 411               if (! strcmp (argv[i], argv[new_macro.argc - 1]))
 412                 error (_("Two macro arguments with identical names."));
 413             }
 414
 415           skip_ws (&exp);
 416           if (*exp == ',')
 417             {
 418               ++exp;
 419               skip_ws (&exp);
 420             }
 421           else if (*exp != ')')
 422             error (_("',' or ')' expected at end of macro arguments."));
 423         }
 424       /* Skip the closing paren.  */
 425       ++exp;
 426       skip_ws (&exp);
 427
 428       macro_define_function (macro_main (macro_user_macros), -1, name,
 429                              new_macro.argc, (const char **) new_macro.argv,
 430                              exp);
 431     }
 432   else
 433     {
 434       skip_ws (&exp);
 435       macro_define_object (macro_main (macro_user_macros), -1, name, exp);
 436     }
 437
 438   do_cleanups (cleanup_chain);
 439 }
 440
 441
 442 static void
 443 macro_undef_command (char *exp, int from_tty)
 444 {
 445   char *name;
 446
 447   if (!exp)
 448     error (_("usage: macro undef NAME"));
 449
 450   skip_ws (&exp);
 451   name = extract_identifier (&exp, 0);
 452   if (! name)
 453     error (_("Invalid macro name."));
 454   macro_undef (macro_main (macro_user_macros), -1, name);
 455   xfree (name);
 456 }
 457
 458
 459 static void
 460 print_one_macro (const char *name, const struct macro_definition *macro,
 461                  struct macro_source_file *source, int line)
 462 {
 463   fprintf_filtered (gdb_stdout, "macro define %s", name);
 464   if (macro->kind == macro_function_like)
 465     {
 466       int i;
 467
 468       fprintf_filtered (gdb_stdout, "(");
 469       for (i = 0; i < macro->argc; ++i)
 470         fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
 471                           macro->argv[i]);
 472       fprintf_filtered (gdb_stdout, ")");
 473     }
 474   fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
 475 }
 476
 477
 478 static void
 479 macro_list_command (char *exp, int from_tty)
 480 {
 481   macro_for_each (macro_user_macros, print_one_macro);
 482 }
 483
 484 \f
 485 /* Initializing the `macrocmd' module.  */
 486
 487 extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
 488
 489 void
 490 _initialize_macrocmd (void)
 491 {
 492   /* We introduce a new command prefix, `macro', under which we'll put
 493      the various commands for working with preprocessor macros.  */
 494   add_prefix_cmd ("macro", class_info, macro_command,
 495                   _("Prefix for commands dealing with C preprocessor macros."),
 496                   &macrolist, "macro ", 0, &cmdlist);
 497
 498   add_cmd ("expand", no_class, macro_expand_command, _("\
 499 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
 500 Show the expanded expression."),
 501            &macrolist);
 502   add_alias_cmd ("exp", "expand", no_class, 1, &macrolist);
 503   add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
 504 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
 505 Show the expanded expression.\n\
 506 \n\
 507 This command differs from `macro expand' in that it only expands macro\n\
 508 invocations that appear directly in EXPRESSION; if expanding a macro\n\
 509 introduces further macro invocations, those are left unexpanded.\n\
 510 \n\
 511 `macro expand-once' helps you see how a particular macro expands,\n\
 512 whereas `macro expand' shows you how all the macros involved in an\n\
 513 expression work together to yield a pre-processed expression."),
 514            &macrolist);
 515   add_alias_cmd ("exp1", "expand-once", no_class, 1, &macrolist);
 516
 517   add_info ("macro", info_macro_command,
 518             _("Show the definition of MACRO, and it's source location.\n\
 519 Usage: info macro [-a|-all] [--] MACRO\n\
 520 Options: \n\
 521   -a, --all    Output all definitions of MACRO in the current compilation\
 522  unit.\n\
 523   --           Specify the end of arguments and the beginning of the MACRO."));
 524
 525   add_info ("macros", info_macros_command,
 526             _("Show the definitions of all macros at LINESPEC, or the current \
 527 source location.\n\
 528 Usage: info macros [LINESPEC]"));
 529
 530   add_cmd ("define", no_class, macro_define_command, _("\
 531 Define a new C/C++ preprocessor macro.\n\
 532 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
 533 preprocessor directive of the form `#define DEFINITION' such that the\n\
 534 definition is visible in all the inferior's source files.\n\
 535 For example:\n\
 536   (gdb) macro define PI (3.1415926)\n\
 537   (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
 538            &macrolist);
 539
 540   add_cmd ("undef", no_class, macro_undef_command, _("\
 541 Remove the definition of the C/C++ preprocessor macro with the given name."),
 542            &macrolist);
 543
 544   add_cmd ("list", no_class, macro_list_command,
 545            _("List all the macros defined using the `macro define' command."),
 546            &macrolist);
 547 }