X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Fmacrotab.c;h=1e02b0a5df9c707f05e284f84c0695ba3e958fb7;hb=dadef93096fd397c3acf2078bcf6b526ff4e0da4;hp=d73ec9ea489129159aec34b9cec3e4b342b2b74b;hpb=ec2bcbe7540d6ffda2119ad95ba0b9326e497b28;p=platform%2Fupstream%2Fbinutils.git

diff --git a/gdb/macrotab.c b/gdb/macrotab.c
index d73ec9e..1e02b0a 100644
--- a/gdb/macrotab.c
+++ b/gdb/macrotab.c
@@ -1,12 +1,12 @@
 /* C preprocessor macro tables for GDB.
-   Copyright 2002 Free Software Foundation, Inc.
+   Copyright (C) 2002-2014 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,
@@ -15,20 +15,19 @@
    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"
 
 
 /* The macro table structure.  */
@@ -48,6 +47,14 @@ struct macro_table
      #inclusion tree; everything else is #included from here.  */
   struct macro_source_file *main_source;
 
+  /* Compilation directory for all files of this macro table.  It is allocated
+     on objfile's obstack.  */
+  const char *comp_dir;
+
+  /* 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
@@ -89,8 +96,14 @@ macro_alloc (int size, struct macro_table *t)
 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);
 }
 
 
@@ -105,6 +118,7 @@ macro_bcache (struct macro_table *t, const void *addr, int len)
   else
     {
       void *copy = xmalloc (len);
+
       memcpy (copy, addr, len);
       return copy;
     }
@@ -117,17 +131,23 @@ 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 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);
 }
 
 
@@ -144,7 +164,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
@@ -302,6 +322,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;
 
@@ -417,6 +438,14 @@ macro_main (struct macro_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,
@@ -426,11 +455,10 @@ macro_include (struct macro_source_file *source,
   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)
     ;
 
@@ -438,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,
@@ -445,12 +475,14 @@ macro_include (struct macro_source_file *source,
          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);
+      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_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.  */
@@ -479,29 +511,14 @@ 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))
+  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)
       {
@@ -543,6 +560,7 @@ new_macro_definition (struct macro_table *t,
   d->table = t;
   d->kind = kind;
   d->replacement = macro_bcache_str (t, replacement);
+  d->argc = argc;
 
   if (kind == macro_function_like)
     {
@@ -557,7 +575,6 @@ new_macro_definition (struct macro_table *t,
 
       /* 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
@@ -618,7 +635,7 @@ find_definition (const char *name,
   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)
@@ -638,7 +655,7 @@ find_definition (const char *name,
              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;
         }
     }
@@ -660,43 +677,88 @@ find_definition (const char *name,
 }
 
 
-/* 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 (&macro_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)
+        {
+	  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_fullname, line, found_key_fullname,
+		     found_key->start_line);
+	  xfree (found_key_fullname);
+	  xfree (source_fullname);
+        }
+
       return found_key;
     }
   else
     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;
+  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, 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
@@ -712,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,
@@ -723,10 +803,14 @@ macro_define_function (struct macro_source_file *source, int line,
                        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, macro_function_like,
+				argc, argv,
+				replacement);
 
   /* See comments about duplicate keys in macro_define_object.  */
   if (k && ! key_compare (k, name, source, line))
@@ -749,27 +833,44 @@ 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)
+            {
+	      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_fullname, line, key_fullname,
+			 key->end_line);
+	      xfree (key_fullname);
+	      xfree (source_fullname);
+            }
+
+          /* 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
     {
@@ -777,15 +878,43 @@ 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
-      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 (&symfile_complaints,
+		 _("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,
@@ -794,7 +923,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;
 }
@@ -811,6 +949,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;
     }
@@ -819,13 +958,98 @@ macro_definition_location (struct macro_source_file *source,
 }
 
 
+/* 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;
+  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,
+		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;
+  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.  */
+  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,
+		  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);
+}
+
+
 
 /* Creating and freeing macro tables.  */
 
 
 struct macro_table *
-new_macro_table (struct obstack *obstack,
-                 struct bcache *b)
+new_macro_table (struct obstack *obstack, struct bcache *b,
+		 const char *comp_dir)
 {
   struct macro_table *t;
 
@@ -838,7 +1062,9 @@ new_macro_table (struct obstack *obstack,
   memset (t, 0, sizeof (*t));
   t->obstack = obstack;
   t->bcache = b;
-  t->main_source = 0;
+  t->main_source = NULL;
+  t->comp_dir = comp_dir;
+  t->redef_ok = 0;
   t->definitions = (splay_tree_new_with_allocator
                     (macro_tree_compare,
                      ((splay_tree_delete_key_fn) macro_tree_delete_key),
@@ -860,3 +1086,14 @@ 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)
+{
+  if (file->table->comp_dir == NULL || IS_ABSOLUTE_PATH (file->filename))
+    return xstrdup (file->filename);
+
+  return concat (file->table->comp_dir, SLASH_STRING, file->filename, NULL);
+}