X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=binutils%2Fdebug.h;h=d60285d0812ba4d2864cb2f05bee894bd2287921;hb=c2274b2767dba3175e585bd17f9f4a93b56cdc63;hp=0fed1535bf226bcd9c4293f2b071274da905042b;hpb=63840d265c1d65f4d4af7436b175ae12cf2d0a23;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/debug.h b/binutils/debug.h index 0fed1535bf..d60285d081 100644 --- a/binutils/debug.h +++ b/binutils/debug.h @@ -1,5 +1,5 @@ /* debug.h -- Describe generic debugging information. - Copyright (C) 1995, 1996 Free Software Foundation, Inc. + Copyright 1995, 1996 Free Software Foundation, Inc. Written by Ian Lance Taylor . This file is part of GNU Binutils. @@ -32,6 +32,8 @@ enum debug_type_kind { + /* Not used. */ + DEBUG_KIND_ILLEGAL, /* Indirect via a pointer. */ DEBUG_KIND_INDIRECT, /* Void. */ @@ -84,6 +86,8 @@ enum debug_type_kind enum debug_var_kind { + /* Not used. */ + DEBUG_VAR_ILLEGAL, /* A global variable. */ DEBUG_GLOBAL, /* A static variable. */ @@ -100,6 +104,8 @@ enum debug_var_kind enum debug_parm_kind { + /* Not used. */ + DEBUG_PARM_ILLEGAL, /* A stack based parameter. */ DEBUG_PARM_STACK, /* A register parameter. */ @@ -194,7 +200,8 @@ struct debug_write_fns /* 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. */ + 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 *)); @@ -202,9 +209,15 @@ struct debug_write_fns 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. */ @@ -239,12 +252,13 @@ struct debug_write_fns 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 popped, 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. */ @@ -257,11 +271,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. */ - 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 @@ -277,16 +294,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 @@ -311,12 +328,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, @@ -340,9 +356,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 *)); @@ -412,10 +436,6 @@ extern PTR debug_init PARAMS ((void)); 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. */ @@ -553,10 +573,14 @@ extern debug_type debug_make_enum_type 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. */ @@ -593,14 +617,17 @@ extern debug_type debug_make_offset_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. */ @@ -618,9 +645,9 @@ extern debug_type debug_make_undefined_tagged_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)); @@ -653,17 +680,14 @@ 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 + 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, @@ -690,15 +714,80 @@ 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 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