/* C preprocessor macro tables for GDB.
- Copyright (C) 2002, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
This file is part of GDB.
#inclusion tree; everything else is #included from here. */
struct macro_source_file *main_source;
+ /* 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);
}
else
{
void *copy = xmalloc (len);
+
memcpy (copy, addr, len);
return copy;
}
/* Free a possibly bcached object OBJ. That is, if the macro table T
- has a bcache, it's an error; otherwise, xfree OBJ. */
+ 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);
}
const char *name, struct macro_source_file *file, int line)
{
int names = strcmp (key->name, name);
+
if (names)
return names;
}
+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 *name, 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, macro_object_like,
- 0, 0,
- replacement);
+ if (! t->redef_ok)
+ k = check_for_redefinition (source, line,
+ name, macro_object_like,
+ 0, 0,
+ replacement);
/* If we're redefining a symbol, and the existing key would be
identical to our new key, then the splay_tree_insert function
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, macro_function_like,
- argc, argv,
- replacement);
+ if (! t->redef_ok)
+ k = check_for_redefinition (source, line,
+ name, macro_function_like,
+ argc, argv,
+ replacement);
/* See comments about duplicate keys in macro_define_object. */
if (k && ! key_compare (k, name, source, 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
{
- complaint (&symfile_complaints,
- _("macro '%s' is #undefined twice, at %s:%d and %s:%d"), 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)
+ {
+ complaint (&symfile_complaints,
+ _("macro '%s' is #undefined twice,"
+ " at %s:%d and %s:%d"),
+ name,
+ source->filename, line,
+ key->end_file->filename, key->end_line);
+ }
- /* Whatever the case, wipe out the old ending point, and
- make this the ending point. */
- key->end_file = source;
- key->end_line = 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;
+ }
}
else
{
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
+{
+ macro_callback_fn fn;
+ void *user_data;
+ 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 = (struct macro_definition *) node->value;
+
+ (*datum->fn) (key->name, def, datum->user_data);
+ return 0;
+}
+
+/* Call FN for every macro in TABLE. */
+void
+macro_for_each (struct macro_table *table, macro_callback_fn fn,
+ void *user_data)
+{
+ struct macro_for_each_data datum;
+
+ datum.fn = fn;
+ datum.user_data = user_data;
+ 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 = (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, datum->user_data);
+ return 0;
+}
+
+/* Call FN for every macro is visible in SCOPE. */
+void
+macro_for_each_in_scope (struct macro_source_file *file, int line,
+ macro_callback_fn fn, void *user_data)
+{
+ struct macro_for_each_data datum;
+
+ datum.fn = fn;
+ datum.user_data = user_data;
+ datum.file = file;
+ datum.line = line;
+ splay_tree_foreach (file->table->definitions,
+ foreach_macro_in_scope, &datum);
+}
+
+
\f
/* Creating and freeing macro tables. */
t->obstack = obstack;
t->bcache = b;
t->main_source = NULL;
+ t->redef_ok = 0;
t->definitions = (splay_tree_new_with_allocator
(macro_tree_compare,
((splay_tree_delete_key_fn) macro_tree_delete_key),