FYI: remove symtab::free_code and symtab::free_func

[Tom Tromey <tromey at redhat dot com>]

I'm checking this in on the trunk.

I noticed that symtab::free_code and symtab::free_func are mostly
unused.  This patch does the necessary work to completely remove them.

Two modules had to be changed.

First, jv-lang.c had to run a little bit of cleanup by itself, instead
of relying on generic code to do it.  (In fact I don't think this was
ever actually run, so this patch fixes a memory leak here.)

Second, mdebugread.c had to be changed to allocate its line table on the
objfile obstack.  Changing this pointed out that this code would fail
badly in the "no lines" case:

   st = new_symtab ("unknown", 0, pst->objfile);
=>
  LINETABLE (s) = new_linetable (maxlines);  /* maxlines == 0 here */
=>
  size = (size - 1) * sizeof (l->item) + sizeof (struct linetable);
  l = (struct linetable *) obstack_alloc (&objfile->objfile_obstack, size);

... but `size - 1' is -1, leading to a crazy allocation.


Built and regtested on x86-64 (compile farm).

Tom

2011-04-04  Tom Tromey  <tromey@redhat.com>

	* mdebugread.c (psymtab_to_symtab_1): Copy linetable to obstack.
	(new_symtab): Don't set `free_code' on symtab.
	(new_linetable): Properly handle size==0.
	* symtab.h (struct symtab) <free_code, free_func>: Remove.
	* symmisc.c (free_symtab): Don't free the linetable.  Don't call
	free_func.
	* jv-lang.c (struct jv_per_objfile_data): New.
	(jv_per_objfile_free): Free the data.
	(get_dynamics_objfile): Allocate a jv_per_objfile_data.
	(get_java_class_symtab): Set the `dict' field on the
	jv_per_objfile_data.
	(free_class_block): Remove.
	* buildsym.c (end_symtab): Don't set `free_code' or `free_func' on
	the symtab.

Index: buildsym.c
===================================================================
RCS file: /cvs/src/src/gdb/buildsym.c,v
retrieving revision 1.86
diff -u -r1.86 buildsym.c
--- buildsym.c	4 Apr 2011 14:29:26 -0000	1.86
+++ buildsym.c	4 Apr 2011 15:09:14 -0000
@@ -1100,8 +1100,6 @@
 	    {
 	      symtab->dirname = NULL;
 	    }
-	  symtab->free_code = free_linetable;
-	  symtab->free_func = NULL;
 
 	  /* Use whatever language we have been using for this
 	     subfile, not the one that was deduced in allocate_symtab
Index: jv-lang.c
===================================================================
RCS file: /cvs/src/src/gdb/jv-lang.c,v
retrieving revision 1.91
diff -u -r1.91 jv-lang.c
--- jv-lang.c	2 Mar 2011 00:42:53 -0000	1.91
+++ jv-lang.c	4 Apr 2011 15:09:14 -0000
@@ -72,17 +72,30 @@
 static struct type *java_link_class_type (struct gdbarch *,
 					  struct type *, struct value *);
 
+/* An instance of this structure is used to store some data that must
+   be freed.  */
+
+struct jv_per_objfile_data
+{
+  /* The expandable dictionary we use.  */
+  struct dictionary *dict;
+};
+
 /* A function called when the dynamics_objfile is freed.  We use this
    to clean up some internal state.  */
 static void
-jv_per_objfile_free (struct objfile *objfile, void *ignore)
+jv_per_objfile_free (struct objfile *objfile, void *data)
 {
+  struct jv_per_objfile_data *jv_data = data;
+
   gdb_assert (objfile == dynamics_objfile);
-  /* Clean up all our cached state.  These objects are all allocated
-     in the dynamics_objfile, so we don't need to actually free
-     anything.  */
+  /* Clean up all our cached state.  */
   dynamics_objfile = NULL;
   class_symtab = NULL;
+
+  if (jv_data->dict)
+    dict_free (jv_data->dict);
+  xfree (jv_data);
 }
 
 /* FIXME: carlton/2003-02-04: This is the main or only caller of
@@ -96,22 +109,19 @@
 {
   if (dynamics_objfile == NULL)
     {
+      struct jv_per_objfile_data *data;
+
       /* Mark it as shared so that it is cleared when the inferior is
 	 re-run.  */
       dynamics_objfile = allocate_objfile (NULL, OBJF_SHARED);
       dynamics_objfile->gdbarch = gdbarch;
-      /* We don't have any data to store, but this lets us get a
-	 notification when the objfile is destroyed.  Since we have to
-	 store a non-NULL value, we just pick something arbitrary and
-	 safe.  */
-      set_objfile_data (dynamics_objfile, jv_dynamics_objfile_data_key,
-			&dynamics_objfile);
+
+      data = XCNEW (struct jv_per_objfile_data);
+      set_objfile_data (dynamics_objfile, jv_dynamics_objfile_data_key, data);
     }
   return dynamics_objfile;
 }
 
-static void free_class_block (struct symtab *symtab);
-
 static struct symtab *
 get_java_class_symtab (struct gdbarch *gdbarch)
 {
@@ -120,6 +130,7 @@
       struct objfile *objfile = get_dynamics_objfile (gdbarch);
       struct blockvector *bv;
       struct block *bl;
+      struct jv_per_objfile_data *jv_data;
 
       class_symtab = allocate_symtab ("<java-classes>", objfile);
       class_symtab->language = language_java;
@@ -139,7 +150,10 @@
       bl = allocate_block (&objfile->objfile_obstack);
       BLOCK_DICT (bl) = dict_create_hashed_expandable ();
       BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
-      class_symtab->free_func = free_class_block;
+
+      /* Arrange to free the dict.  */
+      jv_data = objfile_data (objfile, jv_dynamics_objfile_data_key);
+      jv_data->dict = BLOCK_DICT (bl);
     }
   return class_symtab;
 }
@@ -172,16 +186,6 @@
   return sym;
 }
 
-/* Free the dynamic symbols block.  */
-static void
-free_class_block (struct symtab *symtab)
-{
-  struct blockvector *bv = BLOCKVECTOR (symtab);
-  struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-
-  dict_free (BLOCK_DICT (bl));
-}
-
 struct type *
 java_lookup_class (char *name)
 {
Index: mdebugread.c
===================================================================
RCS file: /cvs/src/src/gdb/mdebugread.c,v
retrieving revision 1.122
diff -u -r1.122 mdebugread.c
--- mdebugread.c	23 Mar 2011 18:23:54 -0000	1.122
+++ mdebugread.c	4 Apr 2011 15:09:15 -0000
@@ -4204,7 +4204,7 @@
     {
       /* This symbol table contains ordinary ecoff entries.  */
 
-      int maxlines;
+      int maxlines, size;
       EXTR *ext_ptr;
 
       if (fh == 0)
@@ -4311,7 +4311,14 @@
 	    }
 	}
 
-      LINETABLE (st) = lines;
+      size = lines->nitems;
+      if (size > 1)
+	--size;
+      LINETABLE (st) = obstack_copy (&current_objfile->objfile_obstack,
+				     lines,
+				     (sizeof (struct linetable)
+				      + size * sizeof (lines->item)));
+      xfree (lines);
 
       /* .. and our share of externals.
          XXX use the global list to speed up things here.  How?
@@ -4763,7 +4770,6 @@
   BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
     BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
 
-  s->free_code = free_linetable;
   s->debugformat = "ECOFF";
   return (s);
 }
@@ -4803,7 +4809,9 @@
 {
   struct linetable *l;
 
-  size = (size - 1) * sizeof (l->item) + sizeof (struct linetable);
+  if (size > 1)
+    --size;
+  size = size * sizeof (l->item) + sizeof (struct linetable);
   l = (struct linetable *) xmalloc (size);
   l->nitems = 0;
   return l;
Index: symmisc.c
===================================================================
RCS file: /cvs/src/src/gdb/symmisc.c,v
retrieving revision 1.78
diff -u -r1.78 symmisc.c
--- symmisc.c	4 Apr 2011 14:29:26 -0000	1.78
+++ symmisc.c	4 Apr 2011 15:09:20 -0000
@@ -79,37 +79,11 @@
 
 static int print_symbol (void *);
 
-/* Free all the storage associated with the struct symtab <- S.
-   Note that some symtabs have contents that all live inside one big block of
-   memory, and some share the contents of another symbol table and so you
-   should not free the contents on their behalf (except sometimes the
-   linetable, which maybe per symtab even when the rest is not).
-   It is s->free_code that says which alternative to use.  */
+/* Free all the storage associated with the struct symtab <- S.  */
 
 void
 free_symtab (struct symtab *s)
 {
-  switch (s->free_code)
-    {
-    case free_nothing:
-      /* All the contents are part of a big block of memory (an obstack),
-         and some other symtab is in charge of freeing that block.
-         Therefore, do nothing.  */
-      break;
-
-    case free_linetable:
-      /* Everything will be freed either by our `free_func'
-         or by some other symtab, except for our linetable.
-         Free that now.  */
-      if (LINETABLE (s))
-	xfree (LINETABLE (s));
-      break;
-    }
-
-  /* If there is a single block of memory to free, free it.  */
-  if (s->free_func != NULL)
-    s->free_func (s);
-
   /* Free source-related stuff.  */
   if (s->line_charpos != NULL)
     xfree (s->line_charpos);
Index: symtab.h
===================================================================
RCS file: /cvs/src/src/gdb/symtab.h,v
retrieving revision 1.175
diff -u -r1.175 symtab.h
--- symtab.h	4 Apr 2011 14:29:26 -0000	1.175
+++ symtab.h	4 Apr 2011 15:09:20 -0000
@@ -781,23 +781,6 @@
 
   char *dirname;
 
-  /* This component says how to free the data we point to:
-     free_nothing => do nothing; some other symtab will free
-     the data this one uses.
-     free_linetable => free just the linetable.  FIXME: Is this redundant
-     with the primary field?  */
-
-  enum free_code
-  {
-    free_nothing, free_linetable
-  }
-  free_code;
-
-  /* A function to call to free space, if necessary.  This is IN
-     ADDITION to the action indicated by free_code.  */
-
-  void (*free_func)(struct symtab *symtab);
-
   /* Total number of lines found in source file.  */
 
   int nlines;