[PATCH 2/7] [python] API for macros: memory management quirks.

[matt rice <ratmice@gmail.com>]

2011-08-23  Matt Rice  <ratmice@gmail.com

	* dwarf2read.c (macro_start_file): Update args in call to
	new_macro_table.
	* macroscope.c (_initialize_macroscope): Ditto.
	* macrotab.c (struct macro_table): Remove obstack and bcache,
	add objfile.
	(macro_alloc): Replace obstack and bcache usage with those from
	the objfile.
	(macro_free, macro_bcache_free, macro_allow_redefinitions): Ditto
	(macro_bcache, new_macro_table): Ditto, and add assertions.
	(macro_table_objfile): New function.
	* macrotab.h: Replace forward declarations of bcache and obstack
	with objfile.
	(enum macro_table_type, macro_table_objfile): Add.
---
 gdb/dwarf2read.c |    3 +--
 gdb/macroscope.c |    2 +-
 gdb/macrotab.c   |   53 ++++++++++++++++++++++++++++++++---------------------
 gdb/macrotab.h   |   44 ++++++++++++++++++++++++++------------------
 4 files changed, 60 insertions(+), 42 deletions(-)

diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index f66c1d9..c56f431 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -14351,8 +14351,7 @@ macro_start_file (int file, int line,
   /* We don't create a macro table for this compilation unit
      at all until we actually get a filename.  */
   if (! pending_macros)
-    pending_macros = new_macro_table (&objfile->objfile_obstack,
-                                      objfile->macro_cache);
+    pending_macros = new_macro_table (objfile, macro_table_type_from_objfile);
 
   if (! current_file)
     /* If we have no current file, then this must be the start_file
diff --git a/gdb/macroscope.c b/gdb/macroscope.c
index b529e68..2447670 100644
--- a/gdb/macroscope.c
+++ b/gdb/macroscope.c
@@ -160,7 +160,7 @@ extern initialize_file_ftype _initialize_macroscope;
 void
 _initialize_macroscope (void)
 {
-  macro_user_macros = new_macro_table (0, 0);
+  macro_user_macros = new_macro_table (NULL, macro_table_type_user_defined);
   macro_set_main (macro_user_macros, "<user-defined>");
   macro_allow_redefinitions (macro_user_macros);
 }
diff --git a/gdb/macrotab.c b/gdb/macrotab.c
index efcf835..b2825d2 100644
--- a/gdb/macrotab.c
+++ b/gdb/macrotab.c
@@ -35,13 +35,10 @@
 
 struct macro_table
 {
-  /* The obstack this table's data should be allocated in, or zero if
-     we should use xmalloc.  */
-  struct obstack *obstack;
-
-  /* The bcache we should use to hold macro names, argument names, and
-     definitions, or zero if we should use xmalloc.  */
-  struct bcache *bcache;
+  /* The objfile who's obstack this table's data should be allocated in,
+     and bcache we should use to hold macro names, argument
+     names, and definitions, or zero if we should use xmalloc. */
+  struct objfile *objfile;
 
   /* The main source file for this compilation unit --- the one whose
      name was given to the compiler.  This is the root of the
@@ -83,8 +80,8 @@ struct macro_table
 static void *
 macro_alloc (int size, struct macro_table *t)
 {
-  if (t->obstack)
-    return obstack_alloc (t->obstack, size);
+  if (t->objfile)
+    return obstack_alloc (&t->objfile->objfile_obstack, size);
   else
     return xmalloc (size);
 }
@@ -93,7 +90,7 @@ macro_alloc (int size, struct macro_table *t)
 static void
 macro_free (void *object, struct macro_table *t)
 {
-  if (t->obstack)
+  if (t->objfile)
     /* 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
@@ -110,8 +107,10 @@ macro_free (void *object, struct macro_table *t)
 static const void *
 macro_bcache (struct macro_table *t, const void *addr, int len)
 {
-  if (t->bcache)
-    return bcache (addr, len, t->bcache);
+  gdb_assert (t->objfile == NULL || (t->objfile && t->objfile->macro_cache));
+
+  if (t->objfile && t->objfile->macro_cache)
+    return bcache (addr, len, t->objfile->macro_cache);
   else
     {
       void *copy = xmalloc (len);
@@ -137,7 +136,7 @@ macro_bcache_str (struct macro_table *t, const char *s)
 static void
 macro_bcache_free (struct macro_table *t, void *obj)
 {
-  if (t->bcache)
+  if (t->objfile)
     /* 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
@@ -147,6 +146,12 @@ macro_bcache_free (struct macro_table *t, void *obj)
     xfree (obj);
 }
 
+/* Return the objfile of the macro table, NULL if it is user defined.  */
+struct objfile *
+macro_table_objfile (struct macro_table *table)
+{
+  return table->objfile;
+}
 
 \f
 /* Macro tree keys, w/their comparison, allocation, and freeing functions.  */
@@ -438,7 +443,7 @@ macro_main (struct macro_table *t)
 void
 macro_allow_redefinitions (struct macro_table *t)
 {
-  gdb_assert (! t->obstack);
+  gdb_assert (! t->objfile);
   t->redef_ok = 1;
 }
 
@@ -972,20 +977,26 @@ 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 objfile *objfile, enum macro_table_type table_type)
 {
   struct macro_table *t;
 
+  if (table_type == macro_table_type_user_defined)
+    gdb_assert (objfile == NULL);
+  else if (table_type == macro_table_type_from_objfile)
+    {
+      gdb_assert (objfile != NULL);
+      gdb_assert (objfile->macro_cache != NULL);
+    }
+
   /* First, get storage for the `struct macro_table' itself.  */
-  if (obstack)
-    t = obstack_alloc (obstack, sizeof (*t));
-  else
+  if (table_type == macro_table_type_from_objfile)
+    t = obstack_alloc (&objfile->objfile_obstack, sizeof (*t));
+  else if (table_type == macro_table_type_user_defined)
     t = xmalloc (sizeof (*t));
 
   memset (t, 0, sizeof (*t));
-  t->obstack = obstack;
-  t->bcache = b;
+  t->objfile = objfile;
   t->main_source = NULL;
   t->redef_ok = 0;
   t->definitions = (splay_tree_new_with_allocator
diff --git a/gdb/macrotab.h b/gdb/macrotab.h
index a10351a..a773c49 100644
--- a/gdb/macrotab.h
+++ b/gdb/macrotab.h
@@ -21,8 +21,7 @@
 #ifndef MACROTAB_H
 #define MACROTAB_H
 
-struct obstack;
-struct bcache;
+struct objfile;
 
 /* How do we represent a source location?  I mean, how should we
    represent them within GDB; the user wants to use all sorts of
@@ -149,23 +148,28 @@ struct macro_source_file
 };
 
 
-/* Create a new, empty macro table.  Allocate it in OBSTACK, or use
-   xmalloc if OBSTACK is zero.  Use BCACHE to store all macro names,
-   arguments, definitions, and anything else that might be the same
-   amongst compilation units in an executable file; if BCACHE is zero,
-   don't cache these things.
+enum macro_table_type {
+  macro_table_type_user_defined,
+  macro_table_type_from_objfile
+};
 
-   Note that, if either OBSTACK or BCACHE are non-zero, then removing
-   information from the table may leak memory.  Neither obstacks nor
-   bcaches really allow you to remove information, so although we can
-   update the data structure to record the change, we can't free the
-   old data.  At the moment, since we only provide obstacks and
-   bcaches for macro tables for symtabs, this isn't a problem; only
-   odd debugging information makes a definition and then deletes it at
-   the same source location (although 'gcc -DFOO -UFOO -DFOO=2' does
-   do that in GCC 4.1.2.).  */
-struct macro_table *new_macro_table (struct obstack *obstack,
-                                     struct bcache *bcache);
+/* Create a new, empty macro table.  Allocate it in OBJFILE's obstack,
+   or use xmalloc if OBJFILE is zero.  Use OBJFILE's bcache to store
+   all macro names, arguments, definitions, and anything else that
+   might be the same amongst compilation units in an executable file;
+   if OBJFILE is zero, don't cache these things.
+
+   Note that, if OBJFILE is non-zero, then removing information from the
+   table may leak memory.  Neither obstacks nor bcaches really allow
+   you to remove information, so although we can update the data
+   structure to record the change, we can't free the old data.
+   At the moment, since we only provide obstacks and bcaches for macro
+   tables for symtabs, this isn't a problem; only odd debugging
+   information makes a definition and then deletes it at the same
+   source location (although 'gcc -DFOO -UFOO -DFOO=2' does do that
+   in GCC 4.1.2.).  */
+struct macro_table *new_macro_table (struct objfile *objfile,
+				     enum macro_table_type table_type);
 
 
 /* Free TABLE, and any macro definitions, source file structures,
@@ -173,6 +177,10 @@ struct macro_table *new_macro_table (struct obstack *obstack,
    allocated on an obstack, or if it uses a bcache.  */
 void free_macro_table (struct macro_table *table);
 
+/* Returns the OBJFILE for the given table, if the table
+   is for user-defined macros this function will return NULL.  */
+struct objfile * macro_table_objfile (struct macro_table *table);
+
 
 /* Set FILENAME as the main source file of TABLE.  Return a source
    file structure describing that file; if we record the #definition
-- 
1.7.4.4