X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmacrotab.c;h=2171580637ee176d896b6228a18846bd82139924;hb=e66cfcef729d758a5e605d57600530ad9b1bb9c3;hp=c33c028d225a5009f6000f7c325e2dbb8f78739a;hpb=9a044a8903fdfe53411787984379191d15373019;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/macrotab.c b/gdb/macrotab.c
index c33c028d22..2171580637 100644
--- a/gdb/macrotab.c
+++ b/gdb/macrotab.c
@@ -1,5 +1,5 @@
 /* C preprocessor macro tables for GDB.
-   Copyright (C) 2002, 2007, 2008 Free Software Foundation, Inc.
+   Copyright (C) 2002-2018 Free Software Foundation, Inc.
    Contributed by Red Hat, Inc.
 
    This file is part of GDB.
@@ -20,13 +20,14 @@
 #include "defs.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"
 
 
 /* The macro table structure.  */
@@ -46,6 +47,9 @@ struct macro_table
      #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;
@@ -113,6 +117,7 @@ macro_bcache (struct macro_table *t, const void *addr, int len)
   else
     {
       void *copy = xmalloc (len);
+
       memcpy (copy, addr, len);
       return copy;
     }
@@ -125,7 +130,7 @@ macro_bcache (struct macro_table *t, const void *addr, int len)
 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);
 }
 
 
@@ -158,7 +163,7 @@ struct macro_key
   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
@@ -316,6 +321,7 @@ key_compare (struct macro_key *key,
              const char *name, struct macro_source_file *file, int line)
 {
   int names = strcmp (key->name, name);
+
   if (names)
     return names;
 
@@ -346,7 +352,7 @@ new_macro_key (struct macro_table *t,
                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;
@@ -379,7 +385,8 @@ new_source_file (struct macro_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;
@@ -444,7 +451,7 @@ 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
@@ -459,6 +466,8 @@ macro_include (struct macro_source_file *source,
      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,
@@ -466,9 +475,13 @@ macro_include (struct macro_source_file *source,
          should tolerate bad debug info.  So:
 
          First, squawk.  */
-      complaint (&symfile_complaints,
-		 _("both `%s' and `%s' allegedly #included at %s:%d"), included,
-		 (*link)->filename, source->filename, line);
+
+      link_fullname = macro_source_fullname (*link);
+      source_fullname = macro_source_fullname (source);
+      complaint (_("both `%s' and `%s' allegedly #included at %s:%d"),
+		 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.  */
@@ -483,13 +496,13 @@ macro_include (struct macro_source_file *source,
   /* 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;
 }
 
 
@@ -497,24 +510,9 @@ struct macro_source_file *
 macro_lookup_inclusion (struct macro_source_file *source, const char *name)
 {
   /* Is SOURCE itself named NAME?  */
-  if (strcmp (name, source->filename) == 0)
+  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) == 0)
-      return source;
-  }
-
   /* It's not us.  Try all our children, and return the lowest.  */
   {
     struct macro_source_file *child;
@@ -555,12 +553,14 @@ new_macro_definition (struct macro_table *t,
                       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)
     {
@@ -569,13 +569,13 @@ new_macro_definition (struct macro_table *t,
       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
@@ -725,10 +725,16 @@ check_for_redefinition (struct macro_source_file *source, int line,
 
       if (! same)
         {
-	  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);
+	  char *source_fullname, *found_key_fullname;
+	  
+	  source_fullname = macro_source_fullname (source);
+	  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, line, found_key_fullname,
+		     found_key->start_line);
+	  xfree (found_key_fullname);
+	  xfree (source_fullname);
         }
 
       return found_key;
@@ -737,10 +743,12 @@ check_for_redefinition (struct macro_source_file *source, int line,
     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;
@@ -766,10 +774,28 @@ macro_define_object (struct macro_source_file *source, int line,
     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,
@@ -827,12 +853,16 @@ macro_undef (struct macro_source_file *source, int line,
              #definition.  */
           if (key->end_file)
             {
-              complaint (&symfile_complaints,
-                         _("macro '%s' is #undefined twice,"
+	      char *source_fullname, *key_fullname;
+
+	      source_fullname = macro_source_fullname (source);
+	      key_fullname = macro_source_fullname (key->end_file);
+              complaint (_("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
@@ -847,13 +877,42 @@ macro_undef (struct macro_source_file *source, int line,
          has no macro definition in scope is ignored.  So we should
          ignore it too.  */
 #if 0
-      complaint (&symfile_complaints,
-		 _("no definition for macro `%s' in scope to #undef at %s:%d"),
+      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,
@@ -862,7 +921,16 @@ 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;
 }
@@ -879,6 +947,7 @@ macro_definition_location (struct macro_source_file *source,
   if (n)
     {
       struct macro_key *key = (struct macro_key *) n->key;
+
       *definition_line = key->start_line;
       return key->start_file;
     }
@@ -892,8 +961,7 @@ macro_definition_location (struct macro_source_file *source,
    the FILE and LINE fields.  */
 struct macro_for_each_data
 {
-  macro_callback_fn fn;
-  void *user_data;
+  gdb::function_view<macro_callback_fn> fn;
   struct macro_source_file *file;
   int line;
 };
@@ -904,19 +972,26 @@ 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);
+  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, key->start_file, key->start_line);
   return 0;
 }
 
 /* Call FN for every macro in TABLE.  */
 void
-macro_for_each (struct macro_table *table, macro_callback_fn fn,
-		void *user_data)
+macro_for_each (struct macro_table *table,
+		gdb::function_view<macro_callback_fn> fn)
 {
   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);
@@ -927,7 +1002,13 @@ 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;
+  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.  */
@@ -936,18 +1017,18 @@ foreach_macro_in_scope (splay_tree_node node, void *info)
       && (!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);
   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)
+			 gdb::function_view<macro_callback_fn> fn)
 {
   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,
@@ -960,21 +1041,22 @@ macro_for_each_in_scope (struct macro_source_file *file, int line,
 
 
 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,
@@ -997,3 +1079,19 @@ free_macro_table (struct macro_table *table)
   /* 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, (char *) NULL);
+}