/* C preprocessor macro tables for GDB.
- Copyright (C) 2002, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 2002-2015 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
This file is part of GDB.
#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. */
#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;
static const char *
macro_bcache_str (struct macro_table *t, const char *s)
{
- return (char *) macro_bcache (t, s, strlen (s) + 1);
+ return macro_bcache (t, s, strlen (s) + 1);
}
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
the new one? */
if (*link && line == (*link)->included_at_line)
{
+ char *link_fullname, *source_fullname;
+
/* This means the compiler is emitting bogus debug info. (GCC
circa March 2002 did this.) It also means that the splay
tree ordering function, macro_tree_compare, will abort,
should tolerate bad debug info. So:
First, squawk. */
+
+ link_fullname = macro_source_fullname (*link);
+ source_fullname = macro_source_fullname (source);
complaint (&symfile_complaints,
_("both `%s' and `%s' allegedly #included at %s:%d"),
- included, (*link)->filename, source->filename, line);
+ included, link_fullname, source_fullname, line);
+ xfree (source_fullname);
+ xfree (link_fullname);
/* 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;
}
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 filename_cmp above should have triggered, and we need to
- check for a slash here. */
- if (name_len < src_name_len
- && IS_DIR_SEPARATOR (source->filename[src_name_len - name_len - 1])
- && filename_cmp (name,
- source->filename + src_name_len - name_len) == 0)
- return source;
- }
-
/* It's not us. Try all our children, and return the lowest. */
{
struct macro_source_file *child;
d->table = t;
d->kind = kind;
d->replacement = macro_bcache_str (t, replacement);
+ d->argc = argc;
if (kind == macro_function_like)
{
/* Now bcache the array of argument pointers itself. */
d->argv = macro_bcache (t, cached_argv, cached_argv_size);
- d->argc = argc;
}
/* We don't bcache the entire definition structure because it's got
if (! same)
{
+ char *source_fullname, *found_key_fullname;
+
+ source_fullname = macro_source_fullname (source);
+ found_key_fullname = macro_source_fullname (found_key->start_file);
complaint (&symfile_complaints,
_("macro `%s' redefined at %s:%d; "
"original definition at %s:%d"),
- name, source->filename, line,
- found_key->start_file->filename, found_key->start_line);
+ name, source_fullname, line, found_key_fullname,
+ found_key->start_line);
+ xfree (found_key_fullname);
+ xfree (source_fullname);
}
return found_key;
return 0;
}
+/* A helper function to define a new object-like macro. */
-void
-macro_define_object (struct macro_source_file *source, int line,
- const char *name, 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 kind)
{
struct macro_table *t = source->table;
struct macro_key *k = NULL;
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, macro_object_like, kind, 0, replacement);
splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
}
+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);
+}
+
+/* See macrotab.h. */
+
+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,
#definition. */
if (key->end_file)
{
+ char *source_fullname, *key_fullname;
+
+ source_fullname = macro_source_fullname (source);
+ key_fullname = macro_source_fullname (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);
+ name, source_fullname, line, key_fullname,
+ key->end_line);
+ xfree (key_fullname);
+ xfree (source_fullname);
}
/* Whether or not we've seen a prior #undefinition, wipe out
}
}
+/* 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;
+ {
+ struct macro_definition *retval;
+ char *source_fullname;
+
+ source_fullname = macro_source_fullname (source);
+ retval = fixup_definition (source_fullname, line,
+ (struct macro_definition *) n->value);
+ xfree (source_fullname);
+ return retval;
+ }
else
return 0;
}
{
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;
+ struct macro_definition *def;
+ char *key_fullname;
+
+ key_fullname = macro_source_fullname (key->start_file);
+ def = fixup_definition (key_fullname, key->start_line,
+ (struct macro_definition *) node->value);
+ xfree (key_fullname);
- (*datum->fn) (key->name, def, datum->user_data);
+ (*datum->fn) (key->name, def, key->start_file, key->start_line,
+ datum->user_data);
return 0;
}
{
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;
+ struct macro_definition *def;
+ char *datum_fullname;
+
+ datum_fullname = macro_source_fullname (datum->file);
+ def = fixup_definition (datum_fullname, datum->line,
+ (struct macro_definition *) node->value);
+ xfree (datum_fullname);
/* See if this macro is defined before the passed-in line, and
extends past that line. */
&& (!key->end_file
|| compare_locations (key->end_file, key->end_line,
datum->file, datum->line) >= 0))
- (*datum->fn) (key->name, def, datum->user_data);
+ (*datum->fn) (key->name, def, key->start_file, key->start_line,
+ datum->user_data);
return 0;
}
struct macro_table *
-new_macro_table (struct obstack *obstack,
- struct bcache *b)
+new_macro_table (struct obstack *obstack, struct 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 = NULL;
+ t->compunit_symtab = cust;
t->redef_ok = 0;
t->definitions = (splay_tree_new_with_allocator
(macro_tree_compare,
/* Free the table of macro definitions. */
splay_tree_delete (table->definitions);
}
+
+/* See macrotab.h for the comment. */
+
+char *
+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 xstrdup (file->filename);
+
+ return concat (comp_dir, SLASH_STRING, file->filename, NULL);
+}