/* C preprocessor macro tables for GDB.
- Copyright 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002-2020 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "obstack.h"
+#include "gdb_obstack.h"
#include "splay-tree.h"
+#include "filenames.h"
#include "symtab.h"
#include "symfile.h"
#include "objfiles.h"
#include "macrotab.h"
-#include "gdb_assert.h"
#include "bcache.h"
#include "complaints.h"
+#include "macroexp.h"
\f
/* The macro table structure. */
/* The bcache we should use to hold macro names, argument names, and
definitions, or zero if we should use xmalloc. */
- struct bcache *bcache;
+ gdb::bcache *bcache;
/* The main source file for this compilation unit --- the one whose
name was given to the compiler. This is the root of the
#inclusion tree; everything else is #included from here. */
struct macro_source_file *main_source;
+ /* Backlink to containing compilation unit, or NULL if there isn't one. */
+ struct compunit_symtab *compunit_symtab;
+
+ /* True if macros in this table can be redefined without issuing an
+ error. */
+ int redef_ok;
+
/* The table of macro definitions. This is a splay tree (an ordered
binary tree that stays balanced, effectively), sorted by macro
name. Where a macro gets defined more than once (presumably with
static void
macro_free (void *object, struct macro_table *t)
{
- gdb_assert (! t->obstack);
- xfree (object);
+ if (t->obstack)
+ /* There are cases where we need to remove entries from a macro
+ table, even when reading debugging information. This should be
+ rare, and there's no easy way to free arbitrary data from an
+ obstack, so we just leak it. */
+ ;
+ else
+ xfree (object);
}
macro_bcache (struct macro_table *t, const void *addr, int len)
{
if (t->bcache)
- return bcache (addr, len, t->bcache);
+ return t->bcache->insert (addr, len);
else
{
void *copy = xmalloc (len);
+
memcpy (copy, addr, len);
return copy;
}
static const char *
macro_bcache_str (struct macro_table *t, const char *s)
{
- return (char *) macro_bcache (t, s, strlen (s) + 1);
+ return (const char *) macro_bcache (t, s, strlen (s) + 1);
}
/* Free a possibly bcached object OBJ. That is, if the macro table T
- has a bcache, it's an error; otherwise, xfree OBJ. */
-void
+ has a bcache, do nothing; otherwise, xfree OBJ. */
+static void
macro_bcache_free (struct macro_table *t, void *obj)
{
- gdb_assert (! t->bcache);
- xfree (obj);
+ if (t->bcache)
+ /* There are cases where we need to remove entries from a macro
+ table, even when reading debugging information. This should be
+ rare, and there's no easy way to free data from a bcache, so we
+ just leak it. */
+ ;
+ else
+ xfree (obj);
}
struct macro_table *table;
/* The name of the macro. This is in the table's bcache, if it has
- one. */
+ one. */
const char *name;
/* The source file and line number where the definition's scope
const char *name, struct macro_source_file *file, int line)
{
int names = strcmp (key->name, name);
+
if (names)
return names;
struct macro_source_file *file,
int line)
{
- struct macro_key *k = macro_alloc (sizeof (*k), t);
+ struct macro_key *k = (struct macro_key *) macro_alloc (sizeof (*k), t);
memset (k, 0, sizeof (*k));
k->table = t;
const char *filename)
{
/* Get space for the source file structure itself. */
- struct macro_source_file *f = macro_alloc (sizeof (*f), t);
+ struct macro_source_file *f
+ = (struct macro_source_file *) macro_alloc (sizeof (*f), t);
memset (f, 0, sizeof (*f));
f->table = t;
}
+void
+macro_allow_redefinitions (struct macro_table *t)
+{
+ gdb_assert (! t->obstack);
+ t->redef_ok = 1;
+}
+
+
struct macro_source_file *
macro_include (struct macro_source_file *source,
int line,
const char *included)
{
- struct macro_source_file *new;
+ struct macro_source_file *newobj;
struct macro_source_file **link;
/* Find the right position in SOURCE's `includes' list for the new
- file. Scan until we find the first file we shouldn't follow ---
- which is therefore the file we should directly precede --- or
- reach the end of the list. */
+ file. Skip inclusions at earlier lines, until we find one at the
+ same line or later --- or until the end of the list. */
for (link = &source->includes;
- *link && line < (*link)->included_at_line;
+ *link && (*link)->included_at_line < line;
link = &(*link)->next_included)
;
should tolerate bad debug info. So:
First, squawk. */
- static struct complaint bogus_inclusion_line = {
- "both `%s' and `%s' allegedly #included at %s:%d", 0, 0
- };
- complain (&bogus_inclusion_line,
- included, (*link)->filename, source->filename, line);
+ std::string link_fullname = macro_source_fullname (*link);
+ std::string source_fullname = macro_source_fullname (source);
+ complaint (_("both `%s' and `%s' allegedly #included at %s:%d"),
+ included, link_fullname.c_str (), source_fullname.c_str (),
+ line);
/* Now, choose a new, unoccupied line number for this
#inclusion, after the alleged #inclusion line. */
/* At this point, we know that LINE is an unused line number, and
*LINK points to the entry an #inclusion at that line should
precede. */
- new = new_source_file (source->table, included);
- new->included_by = source;
- new->included_at_line = line;
- new->next_included = *link;
- *link = new;
+ newobj = new_source_file (source->table, included);
+ newobj->included_by = source;
+ newobj->included_at_line = line;
+ newobj->next_included = *link;
+ *link = newobj;
- return new;
+ return newobj;
}
macro_lookup_inclusion (struct macro_source_file *source, const char *name)
{
/* Is SOURCE itself named NAME? */
- if (! strcmp (name, source->filename))
+ if (filename_cmp (name, source->filename) == 0)
return source;
- /* The filename in the source structure is probably a full path, but
- NAME could be just the final component of the name. */
- {
- int name_len = strlen (name);
- int src_name_len = strlen (source->filename);
-
- /* We do mean < here, and not <=; if the lengths are the same,
- then the strcmp above should have triggered, and we need to
- check for a slash here. */
- if (name_len < src_name_len
- && source->filename[src_name_len - name_len - 1] == '/'
- && ! strcmp (name, source->filename + src_name_len - name_len))
- return source;
- }
-
/* It's not us. Try all our children, and return the lowest. */
{
struct macro_source_file *child;
- struct macro_source_file *best = 0;
- int best_depth;
+ struct macro_source_file *best = NULL;
+ int best_depth = 0;
for (child = source->includes; child; child = child->next_included)
{
int argc, const char **argv,
const char *replacement)
{
- struct macro_definition *d = macro_alloc (sizeof (*d), t);
+ struct macro_definition *d
+ = (struct macro_definition *) macro_alloc (sizeof (*d), t);
memset (d, 0, sizeof (*d));
d->table = t;
d->kind = kind;
d->replacement = macro_bcache_str (t, replacement);
+ d->argc = argc;
if (kind == macro_function_like)
{
int cached_argv_size = argc * sizeof (*cached_argv);
/* Bcache all the arguments. */
- cached_argv = alloca (cached_argv_size);
+ cached_argv = (const char **) alloca (cached_argv_size);
for (i = 0; i < argc; i++)
cached_argv[i] = macro_bcache_str (t, argv[i]);
/* Now bcache the array of argument pointers itself. */
- d->argv = macro_bcache (t, cached_argv, cached_argv_size);
- d->argc = argc;
+ d->argv = ((const char * const *)
+ macro_bcache (t, cached_argv, cached_argv_size));
}
/* We don't bcache the entire definition structure because it's got
query.name = name;
query.start_file = file;
query.start_line = line;
- query.end_file = 0;
+ query.end_file = NULL;
n = splay_tree_lookup (t->definitions, (splay_tree_key) &query);
if (! n)
We just want to search within a given name's definitions. */
struct macro_key *found = (struct macro_key *) pred->key;
- if (! strcmp (found->name, name))
+ if (strcmp (found->name, name) == 0)
n = pred;
}
}
}
-/* If NAME already has a definition in scope at LINE in FILE, and
- return the key. Otherwise, return zero. */
+/* If NAME already has a definition in scope at LINE in SOURCE, return
+ the key. If the old definition is different from the definition
+ given by KIND, ARGC, ARGV, and REPLACEMENT, complain, too.
+ Otherwise, return zero. (ARGC and ARGV are meaningless unless KIND
+ is `macro_function_like'.) */
static struct macro_key *
check_for_redefinition (struct macro_source_file *source, int line,
- const char *name)
+ const char *name, enum macro_kind kind,
+ int argc, const char **argv,
+ const char *replacement)
{
splay_tree_node n = find_definition (name, source, line);
- /* This isn't really right. There's nothing wrong with redefining a
- macro if the new replacement list is the same as the old one. */
if (n)
{
struct macro_key *found_key = (struct macro_key *) n->key;
- static struct complaint macro_redefined = {
- "macro `%s' redefined at %s:%d;"
- "original definition at %s:%d", 0, 0
- };
- complain (¯o_redefined, name,
- source->filename, line,
- found_key->start_file->filename,
- found_key->start_line);
+ struct macro_definition *found_def
+ = (struct macro_definition *) n->value;
+ int same = 1;
+
+ /* Is this definition the same as the existing one?
+ According to the standard, this comparison needs to be done
+ on lists of tokens, not byte-by-byte, as we do here. But
+ that's too hard for us at the moment, and comparing
+ byte-by-byte will only yield false negatives (i.e., extra
+ warning messages), not false positives (i.e., unnoticed
+ definition changes). */
+ if (kind != found_def->kind)
+ same = 0;
+ else if (strcmp (replacement, found_def->replacement))
+ same = 0;
+ else if (kind == macro_function_like)
+ {
+ if (argc != found_def->argc)
+ same = 0;
+ else
+ {
+ int i;
+
+ for (i = 0; i < argc; i++)
+ if (strcmp (argv[i], found_def->argv[i]))
+ same = 0;
+ }
+ }
+
+ if (! same)
+ {
+ std::string source_fullname = macro_source_fullname (source);
+ std::string found_key_fullname
+ = macro_source_fullname (found_key->start_file);
+ complaint (_("macro `%s' redefined at %s:%d; "
+ "original definition at %s:%d"),
+ name, source_fullname.c_str (), line,
+ found_key_fullname.c_str (),
+ found_key->start_line);
+ }
+
return found_key;
}
else
return 0;
}
+/* A helper function to define a new object-like or function-like macro
+ according to KIND. When KIND is macro_object_like,
+ the macro_special_kind must be provided as ARGC, and ARGV must be NULL.
+ When KIND is macro_function_like, ARGC and ARGV are giving the function
+ arguments. */
-void
-macro_define_object (struct macro_source_file *source, int line,
- const char *name, const char *replacement)
+static void
+macro_define_internal (struct macro_source_file *source, int line,
+ const char *name, enum macro_kind kind,
+ int argc, const char **argv,
+ const char *replacement)
{
struct macro_table *t = source->table;
- struct macro_key *k;
+ struct macro_key *k = NULL;
struct macro_definition *d;
- k = check_for_redefinition (source, line, name);
+ if (! t->redef_ok)
+ k = check_for_redefinition (source, line,
+ name, kind,
+ argc, argv,
+ replacement);
/* If we're redefining a symbol, and the existing key would be
identical to our new key, then the splay_tree_insert function
return;
k = new_macro_key (t, name, source, line);
- d = new_macro_definition (t, macro_object_like, 0, 0, replacement);
+ d = new_macro_definition (t, kind, argc, argv, replacement);
splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
}
+/* A helper function to define a new object-like macro. */
-void
-macro_define_function (struct macro_source_file *source, int line,
- const char *name, int argc, const char **argv,
- const char *replacement)
+static void
+macro_define_object_internal (struct macro_source_file *source, int line,
+ const char *name, const char *replacement,
+ enum macro_special_kind special_kind)
{
- struct macro_table *t = source->table;
- struct macro_key *k;
- struct macro_definition *d;
-
- k = check_for_redefinition (source, line, name);
+ macro_define_internal (source, line,
+ name, macro_object_like,
+ special_kind, NULL,
+ replacement);
+}
- /* See comments about duplicate keys in macro_define_object. */
- if (k && ! key_compare (k, name, source, line))
- return;
+void
+macro_define_object (struct macro_source_file *source, int line,
+ const char *name, const char *replacement)
+{
+ macro_define_object_internal (source, line, name, replacement,
+ macro_ordinary);
+}
- /* We should also check here that all the argument names in ARGV are
- distinct. */
+/* See macrotab.h. */
- k = new_macro_key (t, name, source, line);
- d = new_macro_definition (t, macro_function_like, argc, argv, replacement);
- splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
+void
+macro_define_special (struct macro_table *table)
+{
+ macro_define_object_internal (table->main_source, -1, "__FILE__", "",
+ macro_FILE);
+ macro_define_object_internal (table->main_source, -1, "__LINE__", "",
+ macro_LINE);
}
+void
+macro_define_function (struct macro_source_file *source, int line,
+ const char *name, int argc, const char **argv,
+ const char *replacement)
+{
+ macro_define_internal (source, line,
+ name, macro_function_like,
+ argc, argv,
+ replacement);
+}
void
macro_undef (struct macro_source_file *source, int line,
if (n)
{
- /* This function is the only place a macro's end-of-scope
- location gets set to anything other than "end of the
- compilation unit" (i.e., end_file is zero). So if this macro
- already has its end-of-scope set, then we're probably seeing
- a second #undefinition for the same #definition. */
struct macro_key *key = (struct macro_key *) n->key;
- if (key->end_file)
+ /* If we're removing a definition at exactly the same point that
+ we defined it, then just delete the entry altogether. GCC
+ 4.1.2 will generate DWARF that says to do this if you pass it
+ arguments like '-DFOO -UFOO -DFOO=2'. */
+ if (source == key->start_file
+ && line == key->start_line)
+ splay_tree_remove (source->table->definitions, n->key);
+
+ else
{
- static struct complaint double_undef = {
- "macro '%s' is #undefined twice, at %s:%d and %s:%d",
- 0, 0
- };
- complain (&double_undef, name, source->filename, line,
- key->end_file->filename, key->end_line);
+ /* This function is the only place a macro's end-of-scope
+ location gets set to anything other than "end of the
+ compilation unit" (i.e., end_file is zero). So if this
+ macro already has its end-of-scope set, then we're
+ probably seeing a second #undefinition for the same
+ #definition. */
+ if (key->end_file)
+ {
+ std::string source_fullname = macro_source_fullname (source);
+ std::string key_fullname = macro_source_fullname (key->end_file);
+ complaint (_("macro '%s' is #undefined twice,"
+ " at %s:%d and %s:%d"),
+ name, source_fullname.c_str (), line,
+ key_fullname.c_str (),
+ key->end_line);
+ }
+
+ /* Whether or not we've seen a prior #undefinition, wipe out
+ the old ending point, and make this the ending point. */
+ key->end_file = source;
+ key->end_line = line;
}
-
- /* Whatever the case, wipe out the old ending point, and
- make this the ending point. */
- key->end_file = source;
- key->end_line = line;
}
else
{
has no macro definition in scope is ignored. So we should
ignore it too. */
#if 0
- static struct complaint no_macro_to_undefine = {
- "no definition for macro `%s' in scope to #undef at %s:%d",
- 0, 0
- };
- complain (&no_macro_to_undefine, name, source->filename, line);
+ complaint (_("no definition for macro `%s' in scope to #undef at %s:%d"),
+ name, source->filename, line);
#endif
}
}
+/* A helper function that rewrites the definition of a special macro,
+ when needed. */
+
+static struct macro_definition *
+fixup_definition (const char *filename, int line, struct macro_definition *def)
+{
+ static char *saved_expansion;
+
+ if (saved_expansion)
+ {
+ xfree (saved_expansion);
+ saved_expansion = NULL;
+ }
+
+ if (def->kind == macro_object_like)
+ {
+ if (def->argc == macro_FILE)
+ {
+ saved_expansion = macro_stringify (filename);
+ def->replacement = saved_expansion;
+ }
+ else if (def->argc == macro_LINE)
+ {
+ saved_expansion = xstrprintf ("%d", line);
+ def->replacement = saved_expansion;
+ }
+ }
+
+ return def;
+}
struct macro_definition *
macro_lookup_definition (struct macro_source_file *source,
splay_tree_node n = find_definition (name, source, line);
if (n)
- return (struct macro_definition *) n->value;
+ {
+ std::string source_fullname = macro_source_fullname (source);
+ return fixup_definition (source_fullname.c_str (), line,
+ (struct macro_definition *) n->value);
+ }
else
return 0;
}
if (n)
{
struct macro_key *key = (struct macro_key *) n->key;
+
*definition_line = key->start_line;
return key->start_file;
}
}
+/* The type for callback data for iterating the splay tree in
+ macro_for_each and macro_for_each_in_scope. Only the latter uses
+ the FILE and LINE fields. */
+struct macro_for_each_data
+{
+ gdb::function_view<macro_callback_fn> fn;
+ struct macro_source_file *file;
+ int line;
+};
+
+/* Helper function for macro_for_each. */
+static int
+foreach_macro (splay_tree_node node, void *arg)
+{
+ struct macro_for_each_data *datum = (struct macro_for_each_data *) arg;
+ struct macro_key *key = (struct macro_key *) node->key;
+ struct macro_definition *def;
+
+ std::string key_fullname = macro_source_fullname (key->start_file);
+ def = fixup_definition (key_fullname.c_str (), key->start_line,
+ (struct macro_definition *) node->value);
+
+ datum->fn (key->name, def, key->start_file, key->start_line);
+ return 0;
+}
+
+/* Call FN for every macro in TABLE. */
+void
+macro_for_each (struct macro_table *table,
+ gdb::function_view<macro_callback_fn> fn)
+{
+ struct macro_for_each_data datum;
+
+ datum.fn = fn;
+ datum.file = NULL;
+ datum.line = 0;
+ splay_tree_foreach (table->definitions, foreach_macro, &datum);
+}
+
+static int
+foreach_macro_in_scope (splay_tree_node node, void *info)
+{
+ struct macro_for_each_data *datum = (struct macro_for_each_data *) info;
+ struct macro_key *key = (struct macro_key *) node->key;
+ struct macro_definition *def;
+
+ std::string datum_fullname = macro_source_fullname (datum->file);
+ def = fixup_definition (datum_fullname.c_str (), datum->line,
+ (struct macro_definition *) node->value);
+
+ /* See if this macro is defined before the passed-in line, and
+ extends past that line. */
+ if (compare_locations (key->start_file, key->start_line,
+ datum->file, datum->line) < 0
+ && (!key->end_file
+ || compare_locations (key->end_file, key->end_line,
+ datum->file, datum->line) >= 0))
+ datum->fn (key->name, def, key->start_file, key->start_line);
+ return 0;
+}
+
+/* Call FN for every macro is visible in SCOPE. */
+void
+macro_for_each_in_scope (struct macro_source_file *file, int line,
+ gdb::function_view<macro_callback_fn> fn)
+{
+ struct macro_for_each_data datum;
+
+ datum.fn = fn;
+ datum.file = file;
+ datum.line = line;
+ splay_tree_foreach (file->table->definitions,
+ foreach_macro_in_scope, &datum);
+}
+
+
\f
/* Creating and freeing macro tables. */
struct macro_table *
-new_macro_table (struct obstack *obstack,
- struct bcache *b)
+new_macro_table (struct obstack *obstack, gdb::bcache *b,
+ struct compunit_symtab *cust)
{
struct macro_table *t;
/* First, get storage for the `struct macro_table' itself. */
if (obstack)
- t = obstack_alloc (obstack, sizeof (*t));
+ t = XOBNEW (obstack, struct macro_table);
else
- t = xmalloc (sizeof (*t));
+ t = XNEW (struct macro_table);
memset (t, 0, sizeof (*t));
t->obstack = obstack;
t->bcache = b;
- t->main_source = 0;
+ t->main_source = NULL;
+ t->compunit_symtab = cust;
+ t->redef_ok = 0;
t->definitions = (splay_tree_new_with_allocator
(macro_tree_compare,
((splay_tree_delete_key_fn) macro_tree_delete_key),
/* Free the table of macro definitions. */
splay_tree_delete (table->definitions);
}
+
+/* See macrotab.h for the comment. */
+
+std::string
+macro_source_fullname (struct macro_source_file *file)
+{
+ const char *comp_dir = NULL;
+
+ if (file->table->compunit_symtab != NULL)
+ comp_dir = COMPUNIT_DIRNAME (file->table->compunit_symtab);
+
+ if (comp_dir == NULL || IS_ABSOLUTE_PATH (file->filename))
+ return file->filename;
+
+ return std::string (comp_dir) + SLASH_STRING + file->filename;
+}
projects / deliverable / binutils-gdb.git / blobdiff