/* debug.h -- Describe generic debugging information.
- Copyright (C) 1995 Free Software Foundation, Inc.
+ Copyright 1995, 1996 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@cygnus.com>.
This file is part of GNU Binutils.
enum debug_type_kind
{
+ /* Not used. */
+ DEBUG_KIND_ILLEGAL,
/* Indirect via a pointer. */
DEBUG_KIND_INDIRECT,
/* Void. */
enum debug_var_kind
{
+ /* Not used. */
+ DEBUG_VAR_ILLEGAL,
/* A global variable. */
DEBUG_GLOBAL,
/* A static variable. */
enum debug_parm_kind
{
+ /* Not used. */
+ DEBUG_PARM_ILLEGAL,
/* A stack based parameter. */
DEBUG_PARM_STACK,
/* A register parameter. */
/* Push a boolean type onto the type stack, given the size. */
boolean (*bool_type) PARAMS ((PTR, unsigned int));
- /* Push an enum type onto the type stack, given a NULL terminated
- array of names and the associated values. */
- boolean (*enum_type) PARAMS ((PTR, const char **, bfd_signed_vma *));
+ /* Push an enum type onto the type stack, given the tag, a NULL
+ terminated array of names and the associated values. If there is
+ no tag, the tag argument will be NULL. If this is an undefined
+ enum, the names and values arguments will be NULL. */
+ boolean (*enum_type) PARAMS ((PTR, const char *, const char **,
+ bfd_signed_vma *));
/* Pop the top type on the type stack, and push a pointer to that
type onto the type stack. */
boolean (*pointer_type) PARAMS ((PTR));
- /* Pop the top type on the type stack, and push a function returning
- that type onto the type stack. */
- boolean (*function_type) PARAMS ((PTR));
+ /* Push a function type onto the type stack. The second argument
+ indicates the number of argument types that have been pushed onto
+ the stack. If the number of argument types is passed as -1, then
+ the argument types of the function are unknown, and no types have
+ been pushed onto the stack. The third argument is true if the
+ function takes a variable number of arguments. The return type
+ of the function is pushed onto the type stack below the argument
+ types, if any. */
+ boolean (*function_type) PARAMS ((PTR, int, boolean));
/* Pop the top type on the type stack, and push a reference to that
type onto the type stack. */
class to which the method is attached. The third argument is the
number of argument types; these are pushed onto the type stack in
reverse order (the first type popped is the last argument to the
- method). An argument type of -1 means that no argument in
- formation is available. The next type on the type stack below
- the domain and the argument types is the return type of the
- method. All these types must be poppsed, and then the method
- type must be pushed. */
- boolean (*method_type) PARAMS ((PTR, boolean, int));
+ method). A value of -1 for the third argument means that no
+ argument information is available. The fourth argument is true
+ if the function takes a variable number of arguments. The next
+ type on the type stack below the domain and the argument types is
+ the return type of the method. All these types must be popped,
+ and then the method type must be pushed. */
+ boolean (*method_type) PARAMS ((PTR, boolean, int, boolean));
/* Pop the top type off the type stack, and push a const qualified
version of that type onto the type stack. */
/* 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 boolean argument is true for a
- struct, false for a union. The unsigned int argument is the
- size. */
- boolean (*start_struct_type) PARAMS ((PTR, boolean, unsigned int));
+ end_struct_type function. The second argument is the tag; this
+ 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
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 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, 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
- visibility. */
+ visibility. The type must be popped off the type stack. */
boolean (*class_static_member) PARAMS ((PTR, const char *, const char *,
enum debug_visibility));
/* 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,
/* Describe a static variant to the class method currently being
built. The arguments are the same as for class_method_variant,
- except that the last two arguments are omitted. */
+ except that the last two arguments are omitted. The type of the
+ variant must be popped off the type stack. */
boolean (*class_static_method_variant) PARAMS ((PTR, const char *,
enum debug_visibility,
boolean, boolean));
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 *));
/* Pop the type stack, and declare it as a tagged struct or union or
- enum or whatever. */
+ enum or whatever. The tag passed down here is redundant, since
+ was also passed when enum_type, start_struct_type, or
+ start_class_type was called. */
boolean (*tag) PARAMS ((PTR, const char *));
/* This is called to record a named integer constant. */
starting address of the block. */
boolean (*start_block) PARAMS ((PTR, bfd_vma));
- /* Record line number information for the current block. */
- boolean (*lineno) PARAMS ((PTR, const char *, unsigned long, bfd_vma));
-
/* Finish writing out a block. The argument is the ending address
of the block. */
boolean (*end_block) PARAMS ((PTR, bfd_vma));
/* Finish writing out a function. */
boolean (*end_function) PARAMS ((PTR));
+
+ /* Record line number information for the current compilation unit. */
+ boolean (*lineno) PARAMS ((PTR, const char *, unsigned long, bfd_vma));
};
/* Exported functions. */
extern boolean debug_set_filename PARAMS ((PTR, const char *));
-/* Append a string to the source filename. */
-
-extern boolean debug_append_filename PARAMS ((PTR, const char *));
-
/* Change source files to the given file name. This is used for
include files in a single compilation unit. */
extern boolean debug_end_block PARAMS ((PTR, bfd_vma));
-/* Associate a line number in the current source file and function
- with a given address. */
+/* Associate a line number in the current source file with a given
+ address. */
extern boolean debug_record_line PARAMS ((PTR, unsigned long, bfd_vma));
extern debug_type debug_make_pointer_type
PARAMS ((PTR, debug_type));
-/* Make a function returning a given type. FIXME: We should be able
- to record the parameter types. */
+/* Make a function type. The second argument is the return type. The
+ third argument is a NULL terminated array of argument types. The
+ fourth argument is true if the function takes a variable number of
+ arguments. If the third argument is NULL, then the argument types
+ are unknown. */
-extern debug_type debug_make_function_type PARAMS ((PTR, debug_type));
+extern debug_type debug_make_function_type
+ PARAMS ((PTR, debug_type, debug_type *, boolean));
/* Make a reference to a given type. */
PARAMS ((PTR, debug_type, debug_type));
/* Make a type for a method function. The second argument is the
- return type, the third argument is the domain, and the fourth
- argument is a NULL terminated array of argument types. The domain
- and the argument array may be NULL, in which case this is a stub
- method and that information is not available. Stabs debugging uses
- this, and gets the argument types from the mangled name. */
+ return type. The third argument is the domain. The fourth
+ argument is a NULL terminated array of argument types. The fifth
+ argument is true if the function takes a variable number of
+ arguments, in which case the array of argument types indicates the
+ types of the first arguments. The domain and the argument array
+ may be NULL, in which case this is a stub method and that
+ information is not available. Stabs debugging uses this, and gets
+ the argument types from the mangled name. */
extern debug_type debug_make_method_type
- PARAMS ((PTR, debug_type, debug_type, debug_type *));
+ PARAMS ((PTR, debug_type, debug_type, debug_type *, boolean));
/* Make a const qualified version of a given type. */
/* Make a base class for an object. The second argument is the base
class type. The third argument is the bit position of this base
- class in the object (always 0 unless doing multiple inheritance).
- The fourth argument is whether this is a virtual class. The fifth
- argument is the visibility of the base class. */
+ class in the object. The fourth argument is whether this is a
+ virtual class. The fifth argument is the visibility of the base
+ class. */
extern debug_baseclass debug_make_baseclass
PARAMS ((PTR, debug_type, bfd_vma, boolean, enum debug_visibility));
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
+ function. The seventh argument is the index in the virtual
function table, if any. The eighth argument is the virtual
- function context. FIXME: Are the const and volatile arguments
- necessary? Could we just use debug_make_const_type? The handling
- of the second argument is biased toward the way that stabs works. */
+ function context. */
extern debug_method_variant debug_make_method_variant
PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean,
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 size of a type. */
+
+extern bfd_vma debug_get_type_size 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. The last argument points to a
+ boolean which is set to true if the function takes a variable
+ number of arguments. */
+
+extern const debug_type *debug_get_parameter_types PARAMS ((PTR,
+ debug_type,
+ boolean *));
+
+/* Get the target type of a pointer or reference or const or volatile
+ type. */
+
+extern debug_type debug_get_target_type 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));
+
+/* Get the name of a field. */
+
+extern const char *debug_get_field_name PARAMS ((PTR, debug_field));
+
+/* Get the bit position of a field within the containing structure.
+ If the field is a static member, this will return (bfd_vma) -1. */
+
+extern bfd_vma debug_get_field_bitpos PARAMS ((PTR, debug_field));
+
+/* Get the bit size of a field. If the field is a static member, this
+ will return (bfd_vma) -1. */
+
+extern bfd_vma debug_get_field_bitsize PARAMS ((PTR, debug_field));
+
+/* Get the visibility of a field. */
+
+extern enum debug_visibility debug_get_field_visibility
+ PARAMS ((PTR, debug_field));
+
+/* Get the physical name of a field, if it is a static member. If the
+ field is not a static member, this will return NULL. */
+
+extern const char *debug_get_field_physname 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
projects / deliverable / binutils-gdb.git / blobdiff