X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmacrocmd.c;h=42915db904423932cedbdceeb9412dabecb54537;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=d1ac7fae32548bff3f89db86377ab5af334de97c;hpb=9b158ba08eb1ad14dc2324b8391263b228fa928a;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/macrocmd.c b/gdb/macrocmd.c index d1ac7fae32..42915db904 100644 --- a/gdb/macrocmd.c +++ b/gdb/macrocmd.c @@ -1,6 +1,5 @@ /* C preprocessor macro expansion commands for GDB. - Copyright (C) 2002, 2007, 2008, 2009, 2010, 2011 - Free Software Foundation, Inc. + Copyright (C) 2002-2020 Free Software Foundation, Inc. Contributed by Red Hat, Inc. This file is part of GDB. @@ -23,36 +22,33 @@ #include "macrotab.h" #include "macroexp.h" #include "macroscope.h" +#include "cli/cli-style.h" +#include "cli/cli-utils.h" #include "command.h" #include "gdbcmd.h" -#include "gdb_string.h" +#include "linespec.h" /* The `macro' prefix command. */ static struct cmd_list_element *macrolist; -static void -macro_command (char *arg, int from_tty) -{ - printf_unfiltered - ("\"macro\" must be followed by the name of a macro command.\n"); - help_list (macrolist, "macro ", -1, gdb_stdout); -} - - /* Macro expansion commands. */ +/* Prints an informational message regarding the lack of macro information. */ static void -macro_expand_command (char *exp, int from_tty) +macro_inform_no_debuginfo (void) { - struct macro_scope *ms = NULL; - char *expanded = NULL; - struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms); + puts_filtered ("GDB has no preprocessor macro information for that code.\n"); +} - make_cleanup (free_current_contents, &expanded); +static void +macro_expand_command (const char *exp, int from_tty) +{ + gdb::unique_xmalloc_ptr ms; + gdb::unique_xmalloc_ptr expanded; /* You know, when the user doesn't specify any expression, it would be really cool if this defaulted to the last expression evaluated. @@ -67,28 +63,21 @@ macro_expand_command (char *exp, int from_tty) ms = default_macro_scope (); if (ms) { - expanded = macro_expand (exp, standard_macro_lookup, ms); + expanded = macro_expand (exp, standard_macro_lookup, ms.get ()); fputs_filtered ("expands to: ", gdb_stdout); - fputs_filtered (expanded, gdb_stdout); + fputs_filtered (expanded.get (), gdb_stdout); fputs_filtered ("\n", gdb_stdout); } else - fputs_filtered ("GDB has no preprocessor macro information for " - "that code.\n", - gdb_stdout); - - do_cleanups (cleanup_chain); - return; + macro_inform_no_debuginfo (); } static void -macro_expand_once_command (char *exp, int from_tty) +macro_expand_once_command (const char *exp, int from_tty) { - struct macro_scope *ms = NULL; - char *expanded = NULL; - struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms); - make_cleanup (free_current_contents, &expanded); + gdb::unique_xmalloc_ptr ms; + gdb::unique_xmalloc_ptr expanded; /* You know, when the user doesn't specify any expression, it would be really cool if this defaulted to the last expression evaluated. @@ -103,18 +92,13 @@ macro_expand_once_command (char *exp, int from_tty) ms = default_macro_scope (); if (ms) { - expanded = macro_expand_once (exp, standard_macro_lookup, ms); + expanded = macro_expand_once (exp, standard_macro_lookup, ms.get ()); fputs_filtered ("expands to: ", gdb_stdout); - fputs_filtered (expanded, gdb_stdout); + fputs_filtered (expanded.get (), gdb_stdout); fputs_filtered ("\n", gdb_stdout); } else - fputs_filtered ("GDB has no preprocessor macro information for " - "that code.\n", - gdb_stdout); - - do_cleanups (cleanup_chain); - return; + macro_inform_no_debuginfo (); } /* Outputs the include path of a macro starting at FILE and LINE to STREAM. @@ -126,13 +110,18 @@ show_pp_source_pos (struct ui_file *stream, struct macro_source_file *file, int line) { - fprintf_filtered (stream, "%s:%d\n", file->filename, line); + std::string fullname = macro_source_fullname (file); + fprintf_filtered (stream, "%ps:%d\n", + styled_string (file_name_style.style (), + fullname.c_str ()), + line); while (file->included_by) { - fprintf_filtered (gdb_stdout, " included at %s:%d\n", - file->included_by->filename, - file->included_at_line); + fullname = macro_source_fullname (file->included_by); + fputs_filtered (_(" included at "), stream); + fputs_styled (fullname.c_str (), file_name_style.style (), stream); + fprintf_filtered (stream, ":%d\n", file->included_at_line); file = file->included_by; } } @@ -150,134 +139,135 @@ print_macro_definition (const char *name, struct macro_source_file *file, int line) { - fprintf_filtered (gdb_stdout, "Defined at "); - show_pp_source_pos (gdb_stdout, file, line); - - if (line != 0) - fprintf_filtered (gdb_stdout, "#define %s", name); - else - fprintf_filtered (gdb_stdout, "-D%s", name); - - if (d->kind == macro_function_like) - { - int i; - - fputs_filtered ("(", gdb_stdout); - for (i = 0; i < d->argc; i++) - { - fputs_filtered (d->argv[i], gdb_stdout); - if (i + 1 < d->argc) - fputs_filtered (", ", gdb_stdout); - } - fputs_filtered (")", gdb_stdout); - } - - if (line != 0) - fprintf_filtered (gdb_stdout, " %s\n", d->replacement); - else - fprintf_filtered (gdb_stdout, "=%s\n", d->replacement); -} - -static void -info_macro_command (char *name, int from_tty) -{ - struct macro_scope *ms = NULL; - struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms); - struct macro_definition *d; - - if (! name || ! *name) - error (_("You must follow the `info macro' command with the name" - " of the macro\n" - "whose definition you want to see.")); + fprintf_filtered (gdb_stdout, "Defined at "); + show_pp_source_pos (gdb_stdout, file, line); - ms = default_macro_scope (); - if (! ms) - error (_("GDB has no preprocessor macro information for that code.")); + if (line != 0) + fprintf_filtered (gdb_stdout, "#define %s", name); + else + fprintf_filtered (gdb_stdout, "-D%s", name); - d = macro_lookup_definition (ms->file, ms->line, name); - if (d) + if (d->kind == macro_function_like) { - int line; - struct macro_source_file *file - = macro_definition_location (ms->file, ms->line, name, &line); + int i; - print_macro_definition (name, d, file, line); - } - else - { - fprintf_filtered (gdb_stdout, - "The symbol `%s' has no definition as a C/C++" - " preprocessor macro\n" - "at ", name); - show_pp_source_pos (gdb_stdout, ms->file, ms->line); + fputs_filtered ("(", gdb_stdout); + for (i = 0; i < d->argc; i++) + { + fputs_filtered (d->argv[i], gdb_stdout); + if (i + 1 < d->argc) + fputs_filtered (", ", gdb_stdout); + } + fputs_filtered (")", gdb_stdout); } - do_cleanups (cleanup_chain); + if (line != 0) + fprintf_filtered (gdb_stdout, " %s\n", d->replacement); + else + fprintf_filtered (gdb_stdout, "=%s\n", d->replacement); } -/* A callback function for usage with macro_for_each and friends. - If USER_DATA is null all macros will be printed. - Otherwise USER_DATA is considered to be a string, printing - only macros who's NAME matches USER_DATA. Other arguments are - routed to print_macro_definition. */ +/* The implementation of the `info macro' command. */ static void -print_macro_callback (const char *name, const struct macro_definition *macro, - struct macro_source_file *source, int line, - void *user_data) +info_macro_command (const char *args, int from_tty) { - if (! user_data || strcmp (user_data, name) == 0) - print_macro_definition (name, macro, source, line); -} + gdb::unique_xmalloc_ptr ms; + const char *name; + int show_all_macros_named = 0; + const char *arg_start = args; + int processing_args = 1; + + while (processing_args + && arg_start && *arg_start == '-' && *arg_start != '\0') + { + const char *p = skip_to_space (arg_start); + + if (strncmp (arg_start, "-a", p - arg_start) == 0 + || strncmp (arg_start, "-all", p - arg_start) == 0) + show_all_macros_named = 1; + else if (strncmp (arg_start, "--", p - arg_start) == 0) + /* Our macro support seems rather C specific but this would + seem necessary for languages allowing - in macro names. + e.g. Scheme's (defmacro ->foo () "bar\n") */ + processing_args = 0; + else + report_unrecognized_option_error ("info macro", arg_start); -/* Implementation of the "info definitions" command. */ -static void -info_definitions_command (char *name, int from_tty) -{ - struct macro_scope *ms = NULL; - struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms); + arg_start = skip_spaces (p); + } + + name = arg_start; if (! name || ! *name) - error (_("The `info definitions' command requires a macro name as an \ -argument.")); + error (_("You must follow the `info macro' command with the name" + " of the macro\n" + "whose definition you want to see.")); ms = default_macro_scope (); - if (! ms || ! ms->file || ! ms->file->table) - error (_("GDB has no preprocessor macro information for that code.")); + if (! ms) + macro_inform_no_debuginfo (); + else if (show_all_macros_named) + macro_for_each (ms->file->table, [&] (const char *macro_name, + const macro_definition *macro, + macro_source_file *source, + int line) + { + if (strcmp (name, macro_name) == 0) + print_macro_definition (name, macro, source, line); + }); + else + { + struct macro_definition *d; - macro_for_each (ms->file->table, print_macro_callback, name); - do_cleanups (cleanup_chain); + d = macro_lookup_definition (ms->file, ms->line, name); + if (d) + { + int line; + struct macro_source_file *file + = macro_definition_location (ms->file, ms->line, name, &line); + + print_macro_definition (name, d, file, line); + } + else + { + fprintf_filtered (gdb_stdout, + "The symbol `%s' has no definition as a C/C++" + " preprocessor macro\n" + "at ", name); + show_pp_source_pos (gdb_stdout, ms->file, ms->line); + } + } } /* Implementation of the "info macros" command. */ static void -info_macros_command (char *args, int from_tty) +info_macros_command (const char *args, int from_tty) { - struct macro_scope *ms = NULL; - struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms); + gdb::unique_xmalloc_ptr ms; if (args == NULL) ms = default_macro_scope (); else { - struct symtabs_and_lines sals = decode_line_spec (args, 0); + std::vector sals + = decode_line_with_current_source (args, 0); - if (sals.nelts) - ms = sal_macro_scope (sals.sals[0]); + if (!sals.empty ()) + ms = sal_macro_scope (sals[0]); } if (! ms || ! ms->file || ! ms->file->table) - error (_("GDB has no preprocessor macro information for that code.")); - - macro_for_each_in_scope (ms->file, ms->line, print_macro_callback, NULL); - do_cleanups (cleanup_chain); + macro_inform_no_debuginfo (); + else + macro_for_each_in_scope (ms->file, ms->line, print_macro_definition); } /* User-defined macros. */ static void -skip_ws (char **expp) +skip_ws (const char **expp) { while (macro_is_whitespace (**expp)) ++*expp; @@ -290,14 +280,14 @@ skip_ws (char **expp) function will also allow "..." forms as used in varargs macro parameters. */ -static char * -extract_identifier (char **expp, int is_parameter) +static gdb::unique_xmalloc_ptr +extract_identifier (const char **expp, int is_parameter) { char *result; - char *p = *expp; + const char *p = *expp; unsigned int len; - if (is_parameter && !strncmp (p, "...", 3)) + if (is_parameter && startswith (p, "...")) { /* Ok. */ } @@ -311,7 +301,7 @@ extract_identifier (char **expp, int is_parameter) ; } - if (is_parameter && !strncmp (p, "...", 3)) + if (is_parameter && startswith (p, "...")) p += 3; len = p - *expp; @@ -319,47 +309,48 @@ extract_identifier (char **expp, int is_parameter) memcpy (result, *expp, len); result[len] = '\0'; *expp += len; - return result; + return gdb::unique_xmalloc_ptr (result); } -/* Helper function to clean up a temporarily-constructed macro object. - This assumes that the contents were all allocated with xmalloc. */ -static void -free_macro_definition_ptr (void *ptr) +struct temporary_macro_definition : public macro_definition { - int i; - struct macro_definition *loc = (struct macro_definition *) ptr; - - for (i = 0; i < loc->argc; ++i) - xfree ((char *) loc->argv[i]); - xfree ((char *) loc->argv); - /* Note that the 'replacement' field is not allocated. */ -} + temporary_macro_definition () + { + table = nullptr; + kind = macro_object_like; + argc = 0; + argv = nullptr; + replacement = nullptr; + } + + ~temporary_macro_definition () + { + int i; + + for (i = 0; i < argc; ++i) + xfree ((char *) argv[i]); + xfree ((char *) argv); + /* Note that the 'replacement' field is not allocated. */ + } +}; static void -macro_define_command (char *exp, int from_tty) +macro_define_command (const char *exp, int from_tty) { - struct macro_definition new_macro; - char *name = NULL; - struct cleanup *cleanup_chain; + temporary_macro_definition new_macro; if (!exp) error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]")); - cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro); - make_cleanup (free_current_contents, &name); - - memset (&new_macro, 0, sizeof (struct macro_definition)); - skip_ws (&exp); - name = extract_identifier (&exp, 0); - if (! name) + gdb::unique_xmalloc_ptr name = extract_identifier (&exp, 0); + if (name == NULL) error (_("Invalid macro name.")); if (*exp == '(') { /* Function-like macro. */ int alloced = 5; - char **argv = (char **) xmalloc (alloced * sizeof (char *)); + char **argv = XNEWVEC (char *, alloced); new_macro.kind = macro_function_like; new_macro.argc = 0; @@ -380,7 +371,7 @@ macro_define_command (char *exp, int from_tty) /* Must update new_macro as well... */ new_macro.argv = (const char * const *) argv; } - argv[new_macro.argc] = extract_identifier (&exp, 1); + argv[new_macro.argc] = extract_identifier (&exp, 1).release (); if (! argv[new_macro.argc]) error (_("Macro is missing an argument.")); ++new_macro.argc; @@ -404,41 +395,36 @@ macro_define_command (char *exp, int from_tty) ++exp; skip_ws (&exp); - macro_define_function (macro_main (macro_user_macros), -1, name, + macro_define_function (macro_main (macro_user_macros), -1, name.get (), new_macro.argc, (const char **) new_macro.argv, exp); } else { skip_ws (&exp); - macro_define_object (macro_main (macro_user_macros), -1, name, exp); + macro_define_object (macro_main (macro_user_macros), -1, name.get (), + exp); } - - do_cleanups (cleanup_chain); } static void -macro_undef_command (char *exp, int from_tty) +macro_undef_command (const char *exp, int from_tty) { - char *name; - if (!exp) error (_("usage: macro undef NAME")); skip_ws (&exp); - name = extract_identifier (&exp, 0); - if (! name) + gdb::unique_xmalloc_ptr name = extract_identifier (&exp, 0); + if (name == nullptr) error (_("Invalid macro name.")); - macro_undef (macro_main (macro_user_macros), -1, name); - xfree (name); + macro_undef (macro_main (macro_user_macros), -1, name.get ()); } static void print_one_macro (const char *name, const struct macro_definition *macro, - struct macro_source_file *source, int line, - void *ignore) + struct macro_source_file *source, int line) { fprintf_filtered (gdb_stdout, "macro define %s", name); if (macro->kind == macro_function_like) @@ -456,24 +442,22 @@ print_one_macro (const char *name, const struct macro_definition *macro, static void -macro_list_command (char *exp, int from_tty) +macro_list_command (const char *exp, int from_tty) { - macro_for_each (macro_user_macros, print_one_macro, NULL); + macro_for_each (macro_user_macros, print_one_macro); } - /* Initializing the `macrocmd' module. */ -extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */ - +void _initialize_macrocmd (); void -_initialize_macrocmd (void) +_initialize_macrocmd () { /* We introduce a new command prefix, `macro', under which we'll put the various commands for working with preprocessor macros. */ - add_prefix_cmd ("macro", class_info, macro_command, - _("Prefix for commands dealing with C preprocessor macros."), - ¯olist, "macro ", 0, &cmdlist); + add_basic_prefix_cmd ("macro", class_info, + _("Prefix for commands dealing with C preprocessor macros."), + ¯olist, "macro ", 0, &cmdlist); add_cmd ("expand", no_class, macro_expand_command, _("\ Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\ @@ -494,20 +478,18 @@ expression work together to yield a pre-processed expression."), ¯olist); add_alias_cmd ("exp1", "expand-once", no_class, 1, ¯olist); - add_cmd ("macro", no_class, info_macro_command, - _("Show the definition of MACRO, and its source location."), - &infolist); + add_info ("macro", info_macro_command, + _("Show the definition of MACRO, and it's source location.\n\ +Usage: info macro [-a|-all] [--] MACRO\n\ +Options: \n\ + -a, --all Output all definitions of MACRO in the current compilation\ + unit.\n\ + -- Specify the end of arguments and the beginning of the MACRO.")); - add_cmd ("macros", no_class, info_macros_command, - _("Show the definitions of all macros at LINESPEC, or the current \ + add_info ("macros", info_macros_command, + _("Show the definitions of all macros at LINESPEC, or the current \ source location.\n\ -Usage: info macros [LINESPEC]"), - &infolist); - - add_cmd ("definitions", no_class, info_definitions_command, - _("Show all definitions of MACRO in the current compilation unit.\n\ -Usage: info definitions MACRO"), - &infolist); +Usage: info macros [LINESPEC]")); add_cmd ("define", no_class, macro_define_command, _("\ Define a new C/C++ preprocessor macro.\n\