* debug.h (enum debug_type_kind): Add DEBUG_KIND_ILLEGAL.

	(struct debug_write_fns): Add field ellipsis_type.  Add id
	parameter to start_struct_type, start_class_type, and tag_type.
	(debug_make_ellipsis_type): Declare.
	(debug_find_named_type): Declare.
	(debug_get_type_kind): Declare.
	(debug_get_return_type): Declare.
	(debug_get_parameter_types): Declare.
	(debug_get_fields): Declare.
	(debug_get_field_type): Declare.
	* debug.c (struct debug_handle): Add fields class_id and base_id.
	(struct debug_class_type): Add field id.
	(struct debug_method_variant): Rename argtypes to physname.
	Change all uses.
	(debug_ellipsis_type): New static variable.
	(ELLIPSIS_P): New macro.
	(debug_make_ellipsis_type): New function.
	(debug_make_method_variant): Rename argtypes to physname.
	(debug_make_static_method_variant): Likewise.
	(debug_name_type): Always put types in the global namespace.
	(debug_find_named_type): New function.
	(debug_find_tagged_type): Treat DEBUG_KIND_ILLEGAL specially,
	rather than DEBUG_KIND_VOID.
	(debug_get_real_type): New static function.
	(debug_get_type_kind): New function.
	(debug_get_return_type): New function.
	(debug_get_parameter_types): New function.
	(debug_get_fields): New function.
	(debug_get_field_type): New function.
	(debug_write): Initialize base_id.
	(debug_write_type): Pass new id argument to tag_type.  Handle
	DEBUG_KIND_ILLEGAL.  Use id for	DEBUG_KIND_STRUCT and
	DEBUG_KIND_UNION.  Handle ellipsis for method arguments.
	(debug_write_class_type): Don't dereference kclass if it is NULL.
	Use id.
	* prdbg.c (pr_fns): Add pr_ellipsis_type.
	(pr_ellipsis_type): New static function.
	(pr_pointer_type): If this is a pointer to an array, parenthesize
	it correctly.
	(pr_start_struct_type): Add id parameter.
	(pr_start_class_type): Likewise.
	(pr_tag_type): Likewise.
	(pr_fix_visibility): Add the visibility to the top of the stack,
	not the second element on the stack.
	(pr_struct_field): Pop the stack before calling pr_fix_visibility.
	(pr_class_static_member): Likewise.
	(pr_class_start_method): Don't push a type, just set the method
	name in the type on the top of the stack.
	(pr_class_end_method): Don't pop the stack.
	(pr_class_method_variant): Rename argtypes parameter to physname.
	Append const and volatile rather than prepending them.  Add a
	space after the physname.
	(pr_class_static_method_variant): Likewise.
	* ieee.c (ieee_fns): Add ieee_ellipsis_type.
	(ieee_define_named_type): Use DEBUG_KIND_ILLEGAL rather than
	DEBUG_KIND_VOID.
	(write_ieee_debugging_info): Likewise.
	(ieee_typdef): Likewise.
	(ieee_ellipsis_type): New static function.
	(ieee_start_struct_type): Add id parameter.
	(ieee_start_class_type): Likewise.
	(ieee_tag_type): Likewise.
	(ieee_class_method_variant): Rename name to physname.
	(ieee_class_static_method_variant): Likewise.

1 files changed, 79 insertions, 30 deletions

diff --git a/binutils/debug.h b/binutils/debug.h
index 0c3a692..d40679b 100644
--- a/binutils/debug.h
+++ b/binutils/debug.h
@@ -32,6 +32,8 @@
 
 enum debug_type_kind
 {
+  /* Not used.  */
+  DEBUG_KIND_ILLEGAL,
   /* Indirect via a pointer.  */
   DEBUG_KIND_INDIRECT,
   /* Void.  */
@@ -172,6 +174,11 @@ struct debug_write_fns
 
   /* Each writer must keep a stack of types.  */
 
+  /* Push an ellipsis type onto the type stack.  This is not a real
+     type, but is used when a method takes a variable number of
+     arguments.  */
+  boolean (*ellipsis_type) PARAMS ((PTR));
+
   /* Push an empty type onto the type stack.  This type can appear if
      there is a reference to a type which is never defined.  */
   boolean (*empty_type) PARAMS ((PTR));
@@ -258,13 +265,14 @@ struct debug_write_fns
   /* Start building a struct.  This is followed by calls to the
      struct_field function, and finished by a call to the
      end_struct_type function.  The second argument is the tag; this
-     will be NULL if there isn't one.  The boolean argument is true
-     for a struct, false for a union.  The unsigned int argument is
-     the size.  If this is an undefined struct or union, the size will
-     be 0 and struct_field will not be called before end_struct_type
-     is called.  */
-  boolean (*start_struct_type) PARAMS ((PTR, const char *, boolean,
-					unsigned int));
+     will be NULL if there isn't one.  If the second argument is NULL,
+     the third argument is a constant identifying this struct for use
+     with tag_type.  The fourth argument is true for a struct, false
+     for a union.  The fifth argument is the size.  If this is an
+     undefined struct or union, the size will be 0 and struct_field
+     will not be called before end_struct_type is called.  */
+  boolean (*start_struct_type) PARAMS ((PTR, const char *, unsigned int,
+					boolean, unsigned int));
 
   /* Add a field to the struct type currently being built.  The type
      of the field should be popped off the type stack.  The arguments
@@ -280,16 +288,16 @@ struct debug_write_fns
      functions: struct_field, class_static_member, class_baseclass,
      class_start_method, class_method_variant,
      class_static_method_variant, and class_end_method.  The class is
-     finished by a call to end_class_type.  The second argument is the
-     tag; this will be NULL if there isn't one.  The boolean argument
-     is true for a struct, false for a union.  The next argument is
-     the size.  The next argument is true if there is a virtual
-     function table; if there is, the next argument is true if the
-     virtual function table can be found in the type itself, and is
-     false if the type of the object holding the virtual function
-     table should be popped from the type stack.  */
-  boolean (*start_class_type) PARAMS ((PTR, const char *, boolean,
-				       unsigned int, boolean, boolean));
+     finished by a call to end_class_type.  The first five arguments
+     are the same as for start_struct_type.  The sixth argument is
+     true if there is a virtual function table; if there is, the
+     seventh argument is true if the virtual function table can be
+     found in the type itself, and is false if the type of the object
+     holding the virtual function table should be popped from the type
+     stack.  */
+  boolean (*start_class_type) PARAMS ((PTR, const char *, unsigned int,
+				       boolean, unsigned int, boolean,
+				       boolean));
 
   /* Add a static member to the class currently being built.  The
      arguments are the field name, the physical name, and the
@@ -314,12 +322,11 @@ struct debug_write_fns
 
   /* Describe a variant to the class method currently being built.
      The type of the variant must be popped off the type stack.  The
-     second argument is a string which is either the physical name of
-     the function or describes the argument types; see the comment for
-     debug_make_method variant.  The following arguments are the
-     visibility, whether the variant is const, whether the variant is
-     volatile, the offset in the virtual function table, and whether
-     the context is on the type stack (below the variant type).  */
+     second argument is the physical name of the function.  The
+     following arguments are the visibility, whether the variant is
+     const, whether the variant is volatile, the offset in the virtual
+     function table, and whether the context is on the type stack
+     (below the variant type).  */
   boolean (*class_method_variant) PARAMS ((PTR, const char *,
 					   enum debug_visibility,
 					   boolean, boolean,
@@ -343,9 +350,17 @@ struct debug_write_fns
      call to typdef.  */
   boolean (*typedef_type) PARAMS ((PTR, const char *));
 
-  /* Push a type on the stack which was given a name by an earlier
-     call to tag.  */
-  boolean (*tag_type) PARAMS ((PTR, const char *, enum debug_type_kind));
+  /* Push a tagged type on the stack which was defined earlier.  If
+     the second argument is not NULL, the type was defined by a call
+     to tag.  If the second argument is NULL, the type was defined by
+     a call to start_struct_type or start_class_type with a tag of
+     NULL and the number of the third argument.  Either way, the
+     fourth argument is the tag kind.  Note that this may be called
+     for a struct (class) being defined, in between the call to
+     start_struct_type (start_class_type) and the call to
+     end_struct_type (end_class_type).  */
+  boolean (*tag_type) PARAMS ((PTR, const char *, unsigned int,
+			       enum debug_type_kind));
 
   /* Pop the type stack, and typedef it to the given name.  */
   boolean (*typdef) PARAMS ((PTR, const char *));
@@ -504,6 +519,13 @@ extern boolean debug_record_variable
 extern debug_type debug_make_indirect_type
   PARAMS ((PTR, debug_type *, const char *));
 
+/* Make an ellipsis type.  This is not a type at all, but is a marker
+   suitable for appearing in the list of argument types passed to
+   debug_make_method_type.  It should be used to indicate a method
+   which takes a variable number of arguments.  */
+
+extern debug_type debug_make_ellipsis_type PARAMS ((PTR));
+
 /* Make a void type.  */
 
 extern debug_type debug_make_void_type PARAMS ((PTR));
@@ -656,10 +678,9 @@ extern debug_field debug_make_static_member
 extern debug_method debug_make_method
   PARAMS ((PTR, const char *, debug_method_variant *));
 
-/* Make a method variant.  The second argument is either the physical
-   name of the function, or the encoded argument types, depending upon
-   whether the third argument specifies the argument types or not.
-   The third argument is the type of the function.  The fourth
+/* Make a method variant.  The second argument is the physical name of
+   the function.  The third argument is the type of the function,
+   probably constructed by debug_make_method_type.  The fourth
    argument is the visibility.  The fifth argument is whether this is
    a const function.  The sixth argument is whether this is a volatile
    function.  The seventh argument is the offset in the virtual
@@ -693,15 +714,43 @@ extern debug_type debug_tag_type PARAMS ((PTR, const char *, debug_type));
 
 extern boolean debug_record_type_size PARAMS ((PTR, debug_type, unsigned int));
 
+/* Find a named type.  */
+
+extern debug_type debug_find_named_type PARAMS ((PTR, const char *));
+
 /* Find a tagged type.  */
 
 extern debug_type debug_find_tagged_type
   PARAMS ((PTR, const char *, enum debug_type_kind));
 
+/* Get the kind of a type.  */
+
+extern enum debug_type_kind debug_get_type_kind PARAMS ((PTR, debug_type));
+
 /* Get the name of a type.  */
 
 extern const char *debug_get_type_name PARAMS ((PTR, debug_type));
 
+/* Get the return type of a function or method type.  */
+
+extern debug_type debug_get_return_type PARAMS ((PTR, debug_type));
+
+/* Get the NULL terminated array of parameter types for a function or
+   method type (actually, parameter types are not currently stored for
+   function types).  This may be used to determine whether a method
+   type is a stub method or not.  */
+
+extern const debug_type *debug_get_parameter_types PARAMS ((PTR, debug_type));
+
+/* Get the NULL terminated array of fields for a struct, union, or
+   class.  */
+
+extern const debug_field *debug_get_fields PARAMS ((PTR, debug_type));
+
+/* Get the type of a field.  */
+
+extern debug_type debug_get_field_type PARAMS ((PTR, debug_field));
+
 /* Write out the recorded debugging information.  This takes a set of
    function pointers which are called to do the actual writing.  The
    first PTR is the debugging handle.  The second PTR is a handle