* buildsym.c (read_struct_type): Initialize structs allocated

	with alloca, to avoid using random values from stack later on.
	* defs.h (fprintf_filtered):  Add prototype.
	* gdbtypes.c (check_stub_method):  Fix misleading comments.
	* gdbtypes.c (print_arg_types, dump_fn_fieldlists):  New maint
	support functions.
	* gdbtypes.c (print_cplus_stuff, recursive_dump_type):  Many
	small changes to maint support functions.
	* gdbtypes.h (cplus_struct_type):  Reorganize member ordering
	for some fields and expand comments.
	* objfiles.c (allocate_objfile):  Use new obstack_alloc_arg
	macro and track change to obstack_full_begin macro.
	* utils.c (fprintfi_filtered):  New function.
	* valprint.c (type_print_base):  Fixup field printing to not
	print extraneous lines and not print bogus "no data fields"
	messages for C++ classes with no data members.  Also use new
	fprintfi_filtered function.

5 files changed, 211 insertions, 94 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 4ae9e44..225f1c3 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,31 @@
+Mon Jul 20 21:09:53 1992  Fred Fish  (fnf@cygnus.com)
+
+	* buildsym.c (read_struct_type):  Initialize structs allocated
+	with alloca, to avoid using random values from stack later on.
+	* defs.h (fprintf_filtered):  Add prototype.
+	* gdbtypes.c (check_stub_method):  Fix misleading comments.
+	* gdbtypes.c (print_arg_types, dump_fn_fieldlists):  New maint
+	support functions.
+	* gdbtypes.c (print_cplus_stuff, recursive_dump_type):  Many
+	small changes to maint support functions.
+	* gdbtypes.h (cplus_struct_type):  Reorganize member ordering
+	for some fields and expand comments.
+	* objfiles.c (allocate_objfile):  Use new obstack_alloc_arg
+	macro and track change to obstack_full_begin macro.
+	* utils.c (fprintfi_filtered):  New function.
+	* valprint.c (type_print_base):  Fixup field printing to not
+	print extraneous lines and not print bogus "no data fields"
+	messages for C++ classes with no data members.  Also use new
+	fprintfi_filtered function.
+
+Sat Jul 18 15:48:58 1992  david d `zoo' zuhn  (zoo at cirdan.cygnus.com)
+
+	* configure.in: echo error messages to stderr, not stdout
+
+Fri Jul 17 17:07:24 1992  david d `zoo' zuhn  (zoo at cirdan.cygnus.com)
+
+	* configure.in: recognize hppa* instead of hppa
+
 Fri Jul 17 16:52:04 1992  Stu Grossman  (grossman at cygnus.com)
 
 	* energize.c:  Second cut at DynamicLoad message handling.
diff --git a/gdb/buildsym.c b/gdb/buildsym.c
index 5e472b5..9636cd2 100644
--- a/gdb/buildsym.c
+++ b/gdb/buildsym.c
@@ -2208,6 +2208,7 @@ read_struct_type (pp, type, objfile)
 
 	  /* Make this baseclass visible for structure-printing purposes.  */
 	  new = (struct nextfield *) alloca (sizeof (struct nextfield));
+	  memset (new, 0, sizeof (struct nextfield));
 	  new->next = list;
 	  list = new;
 	  list->visibility = via_public;
@@ -2240,6 +2241,7 @@ read_struct_type (pp, type, objfile)
 
       /* Get space to record the next field's data.  */
       new = (struct nextfield *) alloca (sizeof (struct nextfield));
+      memset (new, 0, sizeof (struct nextfield));
       new->next = list;
       list = new;
 
@@ -2477,10 +2479,13 @@ read_struct_type (pp, type, objfile)
 	  struct next_fnfield *sublist = 0;
 	  struct type *look_ahead_type = NULL;
 	  int length = 0;
-	  struct next_fnfieldlist *new_mainlist =
-	    (struct next_fnfieldlist *)alloca (sizeof (struct next_fnfieldlist));
+	  struct next_fnfieldlist *new_mainlist;
 	  char *main_fn_name;
 
+	  new_mainlist = (struct next_fnfieldlist *)
+	      alloca (sizeof (struct next_fnfieldlist));
+	  memset (new_mainlist, 0, sizeof (struct next_fnfieldlist));
+
 	  p = *pp;
 
 	  /* read in the name.  */
@@ -2520,7 +2525,8 @@ read_struct_type (pp, type, objfile)
 	  do
 	    {
 	      struct next_fnfield *new_sublist =
-		(struct next_fnfield *)alloca (sizeof (struct next_fnfield));
+		(struct next_fnfield *) alloca (sizeof (struct next_fnfield));
+	      memset (new_sublist, 0, sizeof (struct next_fnfield));
 
 	      /* Check for and handle cretinous dbx symbol name continuation!  */
 	      if (look_ahead_type == NULL) /* Normal case. */
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index f34dfcb..edd4c19 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -829,13 +829,13 @@ check_stub_method (type, i, j)
 	}
     }
 
-  if (p[-2] != '.')			/* ... */
+  if (p[-2] != '.')			/* Not '...' */
     {
-      argtypes[argcount] = builtin_type_void;	/* Ellist terminator */
+      argtypes[argcount] = builtin_type_void;	/* List terminator */
     }
   else
     {
-      argtypes[argcount] = NULL;		/* List terminator */
+      argtypes[argcount] = NULL;		/* Ellist terminator */
     }
 
   free (demangled_name);
@@ -1152,6 +1152,82 @@ print_bit_vector (bits, nbits)
     }
 }
 
+/* The args list is a strange beast.  It is either terminated by a NULL
+   pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
+   type for normal fixed argcount functions.  (FIXME someday)
+   Also note the first arg should be the "this" pointer, we may not want to
+   include it since we may get into a infinitely recursive situation. */
+
+static void
+print_arg_types (args, spaces)
+     struct type **args;
+     int spaces;
+{
+  if (args != NULL)
+    {
+      while (*args != NULL)
+	{
+	  recursive_dump_type (*args, spaces + 2);
+	  if ((*args++) -> code == TYPE_CODE_VOID)
+	    {
+	      break;
+	    }
+	}
+    }
+}
+
+static void
+dump_fn_fieldlists (type, spaces)
+     struct type *type;
+     int spaces;
+{
+  int method_idx;
+  int overload_idx;
+  struct fn_field *f;
+
+  printfi_filtered (spaces, "fn_fieldlists 0x%x\n",
+		    TYPE_FN_FIELDLISTS (type));
+  for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
+    {
+      f = TYPE_FN_FIELDLIST1 (type, method_idx);
+      printfi_filtered (spaces + 2, "[%d] name '%s' (0x%x) length %d\n",
+			method_idx,
+			TYPE_FN_FIELDLIST_NAME (type, method_idx),
+			TYPE_FN_FIELDLIST_NAME (type, method_idx),
+			TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
+      for (overload_idx = 0;
+	   overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
+	   overload_idx++)
+	{
+	  printfi_filtered (spaces + 4, "[%d] physname '%s' (0x%x)\n",
+			    overload_idx,
+			    TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
+			    TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
+	  printfi_filtered (spaces + 8, "type 0x%x\n",
+			    TYPE_FN_FIELD_TYPE (f, overload_idx));
+	  recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
+			       spaces + 8 + 2);
+	  printfi_filtered (spaces + 8, "args 0x%x\n",
+			    TYPE_FN_FIELD_ARGS (f, overload_idx));
+	  print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
+	  printfi_filtered (spaces + 8, "fcontext 0x%x\n",
+			    TYPE_FN_FIELD_FCONTEXT (f, overload_idx));
+	  printfi_filtered (spaces + 8, "is_const %d\n",
+			    TYPE_FN_FIELD_CONST (f, overload_idx));
+	  printfi_filtered (spaces + 8, "is_volatile %d\n",
+			    TYPE_FN_FIELD_VOLATILE (f, overload_idx));
+	  printfi_filtered (spaces + 8, "is_private %d\n",
+			    TYPE_FN_FIELD_PRIVATE (f, overload_idx));
+	  printfi_filtered (spaces + 8, "is_protected %d\n",
+			    TYPE_FN_FIELD_PROTECTED (f, overload_idx));
+	  printfi_filtered (spaces + 8, "is_stub %d\n",
+			    TYPE_FN_FIELD_STUB (f, overload_idx));
+	  printfi_filtered (spaces + 8, "voffset %d\n",
+			    TYPE_FN_FIELD_VOFFSET (f, overload_idx));
+	}
+    }
+}
+
 static void
 print_cplus_stuff (type, spaces)
      struct type *type;
@@ -1159,13 +1235,17 @@ print_cplus_stuff (type, spaces)
 {
   int bitno;
 
-  printfi_filtered (spaces, "cplus_stuff: @ 0x%x\n",
+  printfi_filtered (spaces, "cplus_stuff 0x%x\n",
 		    TYPE_CPLUS_SPECIFIC (type));
-  printfi_filtered (spaces, "n_baseclasses: %d\n",
+  printfi_filtered (spaces, "n_baseclasses %d\n",
 		    TYPE_N_BASECLASSES (type));
+  printfi_filtered (spaces, "nfn_fields %d\n",
+		    TYPE_NFN_FIELDS (type));
+  printfi_filtered (spaces, "nfn_fields_total %d\n",
+		    TYPE_NFN_FIELDS_TOTAL (type));
   if (TYPE_N_BASECLASSES (type) > 0)
     {
-      printfi_filtered (spaces, "virtual_field_bits: %d @ 0x%x:",
+      printfi_filtered (spaces, "virtual_field_bits %d 0x%x",
 			TYPE_N_BASECLASSES (type),
 			TYPE_FIELD_VIRTUAL_BITS (type));
       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
@@ -1176,7 +1256,7 @@ print_cplus_stuff (type, spaces)
     {
       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
 	{
-	  printfi_filtered (spaces, "private_field_bits: %d @ 0x%x:",
+	  printfi_filtered (spaces, "private_field_bits %d 0x%x",
 			    TYPE_NFIELDS (type),
 			    TYPE_FIELD_PRIVATE_BITS (type));
 	  print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
@@ -1185,7 +1265,7 @@ print_cplus_stuff (type, spaces)
 	}
       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
 	{
-	  printfi_filtered (spaces, "protected_field_bits: %d @ 0x%x:",
+	  printfi_filtered (spaces, "protected_field_bits %d 0x%x",
 			    TYPE_NFIELDS (type),
 			    TYPE_FIELD_PROTECTED_BITS (type));
 	  print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
@@ -1193,6 +1273,10 @@ print_cplus_stuff (type, spaces)
 	  puts_filtered ("\n");
 	}
     }
+  if (TYPE_NFN_FIELDS (type) > 0)
+    {
+      dump_fn_fieldlists (type, spaces);
+    }
 }
 
 void
@@ -1202,88 +1286,88 @@ recursive_dump_type (type, spaces)
 {
   int idx;
 
-  printfi_filtered (spaces, "type node @ 0x%x\n", type);
-  printfi_filtered (spaces, "name: @ 0x%x '%s'\n", TYPE_NAME (type),
+  printfi_filtered (spaces, "type node 0x%x\n", type);
+  printfi_filtered (spaces, "name '%s' (0x%x)\n", TYPE_NAME (type),
 		    TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
-  printfi_filtered (spaces, "code: 0x%x ", TYPE_CODE (type));
+  printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
   switch (TYPE_CODE (type))
     {
       case TYPE_CODE_UNDEF:
-        printf_filtered ("TYPE_CODE_UNDEF");
+        printf_filtered ("(TYPE_CODE_UNDEF)");
 	break;
       case TYPE_CODE_PTR:
-	printf_filtered ("TYPE_CODE_PTR");
+	printf_filtered ("(TYPE_CODE_PTR)");
 	break;
       case TYPE_CODE_ARRAY:
-	printf_filtered ("TYPE_CODE_ARRAY");
+	printf_filtered ("(TYPE_CODE_ARRAY)");
 	break;
       case TYPE_CODE_STRUCT:
-	printf_filtered ("TYPE_CODE_STRUCT");
+	printf_filtered ("(TYPE_CODE_STRUCT)");
 	break;
       case TYPE_CODE_UNION:
-	printf_filtered ("TYPE_CODE_UNION");
+	printf_filtered ("(TYPE_CODE_UNION)");
 	break;
       case TYPE_CODE_ENUM:
-	printf_filtered ("TYPE_CODE_ENUM");
+	printf_filtered ("(TYPE_CODE_ENUM)");
 	break;
       case TYPE_CODE_FUNC:
-	printf_filtered ("TYPE_CODE_FUNC");
+	printf_filtered ("(TYPE_CODE_FUNC)");
 	break;
       case TYPE_CODE_INT:
-	printf_filtered ("TYPE_CODE_INT");
+	printf_filtered ("(TYPE_CODE_INT)");
 	break;
       case TYPE_CODE_FLT:
-	printf_filtered ("TYPE_CODE_FLT");
+	printf_filtered ("(TYPE_CODE_FLT)");
 	break;
       case TYPE_CODE_VOID:
-	printf_filtered ("TYPE_CODE_VOID");
+	printf_filtered ("(TYPE_CODE_VOID)");
 	break;
       case TYPE_CODE_SET:
-	printf_filtered ("TYPE_CODE_SET");
+	printf_filtered ("(TYPE_CODE_SET)");
 	break;
       case TYPE_CODE_RANGE:
-	printf_filtered ("TYPE_CODE_RANGE");
+	printf_filtered ("(TYPE_CODE_RANGE)");
 	break;
       case TYPE_CODE_PASCAL_ARRAY:
-	printf_filtered ("TYPE_CODE_PASCAL_ARRAY");
+	printf_filtered ("(TYPE_CODE_PASCAL_ARRAY)");
 	break;
       case TYPE_CODE_ERROR:
-	printf_filtered ("TYPE_CODE_ERROR");
+	printf_filtered ("(TYPE_CODE_ERROR)");
 	break;
       case TYPE_CODE_MEMBER:
-	printf_filtered ("TYPE_CODE_MEMBER");
+	printf_filtered ("(TYPE_CODE_MEMBER)");
 	break;
       case TYPE_CODE_METHOD:
-	printf_filtered ("TYPE_CODE_METHOD");
+	printf_filtered ("(TYPE_CODE_METHOD)");
 	break;
       case TYPE_CODE_REF:
-	printf_filtered ("TYPE_CODE_REF");
+	printf_filtered ("(TYPE_CODE_REF)");
 	break;
       case TYPE_CODE_CHAR:
-	printf_filtered ("TYPE_CODE_CHAR");
+	printf_filtered ("(TYPE_CODE_CHAR)");
 	break;
       case TYPE_CODE_BOOL:
-	printf_filtered ("TYPE_CODE_BOOL");
+	printf_filtered ("(TYPE_CODE_BOOL)");
 	break;
       default:
-	printf_filtered ("<UNKNOWN TYPE CODE>");
+	printf_filtered ("(UNKNOWN TYPE CODE)");
 	break;
     }
   puts_filtered ("\n");
-  printfi_filtered (spaces, "length: %d\n", TYPE_LENGTH (type));
-  printfi_filtered (spaces, "objfile: @ 0x%x\n", TYPE_OBJFILE (type));
-  printfi_filtered (spaces, "target_type: @ 0x%x\n", TYPE_TARGET_TYPE (type));
+  printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
+  printfi_filtered (spaces, "objfile 0x%x\n", TYPE_OBJFILE (type));
+  printfi_filtered (spaces, "target_type 0x%x\n", TYPE_TARGET_TYPE (type));
   if (TYPE_TARGET_TYPE (type) != NULL)
     {
       recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
     }
-  printfi_filtered (spaces, "pointer_type: @ 0x%x\n",
+  printfi_filtered (spaces, "pointer_type 0x%x\n",
 		    TYPE_POINTER_TYPE (type));
-  printfi_filtered (spaces, "reference_type: @ 0x%x\n",
+  printfi_filtered (spaces, "reference_type 0x%x\n",
 		    TYPE_REFERENCE_TYPE (type));
-  printfi_filtered (spaces, "function_type: @ 0x%x\n",
+  printfi_filtered (spaces, "function_type 0x%x\n",
 		    TYPE_FUNCTION_TYPE (type));
-  printfi_filtered (spaces, "flags: 0x%x", TYPE_FLAGS (type));
+  printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
   if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
     {
       puts_filtered (" TYPE_FLAG_UNSIGNED");
@@ -1297,12 +1381,12 @@ recursive_dump_type (type, spaces)
       puts_filtered (" TYPE_FLAG_STUB");
     }
   puts_filtered ("\n");
-  printfi_filtered (spaces, "nfields: %d @ 0x%x\n", TYPE_NFIELDS (type),
+  printfi_filtered (spaces, "nfields %d 0x%x\n", TYPE_NFIELDS (type),
 		    TYPE_FIELDS (type));
   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
     {
       printfi_filtered (spaces + 2,
-			"[%d] bitpos %d bitsize %d type 0x%x name 0x%x '%s'\n",
+			"[%d] bitpos %d bitsize %d type 0x%x name '%s' (0x%x)\n",
 			idx, TYPE_FIELD_BITPOS (type, idx),
 			TYPE_FIELD_BITSIZE (type, idx),
 			TYPE_FIELD_TYPE (type, idx),
@@ -1315,19 +1399,19 @@ recursive_dump_type (type, spaces)
 	  recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
 	}
     }
-  printfi_filtered (spaces, "vptr_basetype: @ 0x%x\n",
+  printfi_filtered (spaces, "vptr_basetype 0x%x\n",
 		    TYPE_VPTR_BASETYPE (type));
   if (TYPE_VPTR_BASETYPE (type) != NULL)
     {
       recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
     }
-  printfi_filtered (spaces, "vptr_fieldno: %d\n", TYPE_VPTR_FIELDNO (type));
+  printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
   switch (TYPE_CODE (type))
     {
       case TYPE_CODE_METHOD:
       case TYPE_CODE_FUNC:
-	printfi_filtered (spaces, "arg_types: @ 0x%x\n",
-			  TYPE_ARG_TYPES (type));
+	printfi_filtered (spaces, "arg_types 0x%x\n", TYPE_ARG_TYPES (type));
+	print_arg_types (TYPE_ARG_TYPES (type), spaces);
 	break;
 
       case TYPE_CODE_STRUCT:
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index cbc329e..fa1eb73 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -246,6 +246,20 @@ struct type
 
 struct cplus_struct_type
 {
+  /* Number of base classes this type derives from. */
+
+  short n_baseclasses;
+
+  /* Number of methods with unique names.  All overloaded methods with
+     the same name count only once. */
+
+  short nfn_fields;
+
+  /* Number of methods described for this type plus all the
+     methods that it derives from.  */
+
+  int nfn_fields_total;
+
   /* For derived classes, the number of base classes is given by
      n_baseclasses and virtual_field_bits is a bit vector containing one bit
      per base class.
@@ -267,23 +281,12 @@ struct cplus_struct_type
 
   B_TYPE *protected_field_bits;
 
-  /* Number of methods described for this type */
-
-  short nfn_fields;
-
-  /* Number of base classes this type derives from. */
-
-  short n_baseclasses;
-
-  /* Number of methods described for this type plus all the
-     methods that it derives from.  */
-
-  int nfn_fields_total;
-
   /* For classes, structures, and unions, a description of each field,
      which consists of an overloaded name, followed by the types of
      arguments that the method expects, and then the name after it
-     has been renamed to make it distinct.  */
+     has been renamed to make it distinct.
+
+     fn_fieldlists points to an array of nfn_fields of these. */
 
   struct fn_fieldlist
     {
@@ -301,6 +304,10 @@ struct cplus_struct_type
       struct fn_field
 	{
 
+	  /* The name after it has been processed */
+
+	  char *physname;
+
 	  /* The return value of the method */
 
 	  struct type *type;
@@ -309,15 +316,13 @@ struct cplus_struct_type
 
 	  struct type **args;
 
-	  /* The name after it has been processed */
-
-	  char *physname;
-
-	  /* For virtual functions.   */
-	  /* First baseclass that defines this virtual function.   */
+	  /* For virtual functions.
+	     First baseclass that defines this virtual function.   */
 
 	  struct type *fcontext;
 
+	  /* Attributes. */
+
 	  unsigned int is_const : 1;
 	  unsigned int is_volatile : 1;
 	  unsigned int is_private : 1;
@@ -328,7 +333,7 @@ struct cplus_struct_type
 	  /* Index into that baseclass's virtual function table,
 	     minus 2; else if static: VOFFSET_STATIC; else: 0.  */
 
-	  unsigned voffset : 24;
+	  unsigned int voffset : 24;
 
 #	  define VOFFSET_STATIC 1
 
@@ -336,9 +341,6 @@ struct cplus_struct_type
 
     } *fn_fieldlists;
 
-  unsigned char via_protected;
-
-  unsigned char via_public;
 };
 
 /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
@@ -426,17 +428,18 @@ allocate_cplus_struct_type PARAMS ((struct type *));
 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
 
 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
-#define TYPE_FN_FIELD_NAME(thisfn, n) (thisfn)[n].name
+#define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)
-#define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
-#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
-#define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
-#define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
-#define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
-#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
+#define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
+#define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
+#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
+#define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
+#define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
+#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
+#define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
 
 extern struct type *builtin_type_void;
 extern struct type *builtin_type_char;
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index d2f6bbc..5e22be9 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -126,15 +126,15 @@ allocate_objfile (abfd, mapped)
 	  objfile -> mmfd = fd;
 	  objfile -> flags |= OBJF_MAPPED;
 	  mmalloc_setkey (objfile -> md, 0, objfile);
-	  obstack_full_begin (&objfile -> psymbol_obstack, 0, 0,
-			      xmmalloc, mfree, objfile -> md,
-			      OBSTACK_MMALLOC_LIKE);
-	  obstack_full_begin (&objfile -> symbol_obstack, 0, 0,
-			      xmmalloc, mfree, objfile -> md,
-			      OBSTACK_MMALLOC_LIKE);
-	  obstack_full_begin (&objfile -> type_obstack, 0, 0,
-			      xmmalloc, mfree, objfile -> md,
-			      OBSTACK_MMALLOC_LIKE);
+	  obstack_alloc_arg (&objfile -> psymbol_obstack, objfile -> md);
+	  obstack_full_begin (&objfile -> psymbol_obstack, 0, 0, xmmalloc,
+			      mfree);
+	  obstack_alloc_arg (&objfile -> symbol_obstack, objfile -> md);
+	  obstack_full_begin (&objfile -> symbol_obstack, 0, 0, xmmalloc,
+			      mfree);
+	  obstack_alloc_arg (&objfile -> type_obstack, objfile -> md);
+	  obstack_full_begin (&objfile -> type_obstack, 0, 0, xmmalloc,
+			      mfree);
 	}
     }
 
@@ -168,13 +168,9 @@ allocate_objfile (abfd, mapped)
       objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
       memset (objfile, 0, sizeof (struct objfile));
       objfile -> md = NULL;
-      obstack_full_begin (&objfile -> psymbol_obstack, 0, 0, xmalloc, free,
-			  (void *) 0, 0);
-      obstack_full_begin (&objfile -> symbol_obstack, 0, 0, xmalloc, free,
-			  (void *) 0, 0);
-      obstack_full_begin (&objfile -> type_obstack, 0, 0, xmalloc, free,
-			  (void *) 0, 0);
-
+      obstack_full_begin (&objfile -> psymbol_obstack, 0, 0, xmalloc, free);
+      obstack_full_begin (&objfile -> symbol_obstack, 0, 0, xmalloc, free);
+      obstack_full_begin (&objfile -> type_obstack, 0, 0, xmalloc, free);
     }
 
   /* Update the per-objfile information that comes from the bfd, ensuring