diff options
Diffstat (limited to 'binutils/debug.h')
| -rw-r--r-- | binutils/debug.h | 231 |
1 files changed, 117 insertions, 114 deletions
diff --git a/binutils/debug.h b/binutils/debug.h index c439be3..d53210e 100644 --- a/binutils/debug.h +++ b/binutils/debug.h @@ -1,5 +1,5 @@ /* debug.h -- Describe generic debugging information. - Copyright 1995, 1996 Free Software Foundation, Inc. + Copyright 1995, 1996, 2002 Free Software Foundation, Inc. Written by Ian Lance Taylor <ian@cygnus.com>. This file is part of GNU Binutils. @@ -169,126 +169,126 @@ struct debug_write_fns { /* This is called at the start of each new compilation unit with the name of the main file in the new unit. */ - boolean (*start_compilation_unit) PARAMS ((PTR, const char *)); + bfd_boolean (*start_compilation_unit) PARAMS ((PTR, const char *)); /* This is called at the start of each source file within a compilation unit, before outputting any global information for that file. The argument is the name of the file. */ - boolean (*start_source) PARAMS ((PTR, const char *)); + bfd_boolean (*start_source) PARAMS ((PTR, const char *)); /* Each writer must keep a stack of types. */ /* 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)); + bfd_boolean (*empty_type) PARAMS ((PTR)); /* Push a void type onto the type stack. */ - boolean (*void_type) PARAMS ((PTR)); + bfd_boolean (*void_type) PARAMS ((PTR)); /* Push an integer type onto the type stack, given the size and whether it is unsigned. */ - boolean (*int_type) PARAMS ((PTR, unsigned int, boolean)); + bfd_boolean (*int_type) PARAMS ((PTR, unsigned int, bfd_boolean)); /* Push a floating type onto the type stack, given the size. */ - boolean (*float_type) PARAMS ((PTR, unsigned int)); + bfd_boolean (*float_type) PARAMS ((PTR, unsigned int)); /* Push a complex type onto the type stack, given the size. */ - boolean (*complex_type) PARAMS ((PTR, unsigned int)); + bfd_boolean (*complex_type) PARAMS ((PTR, unsigned int)); - /* Push a boolean type onto the type stack, given the size. */ - boolean (*bool_type) PARAMS ((PTR, unsigned int)); + /* Push a bfd_boolean type onto the type stack, given the size. */ + bfd_boolean (*bool_type) PARAMS ((PTR, unsigned int)); /* 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 *)); + bfd_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)); + bfd_boolean (*pointer_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 + 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)); + bfd_boolean (*function_type) PARAMS ((PTR, int, bfd_boolean)); /* Pop the top type on the type stack, and push a reference to that type onto the type stack. */ - boolean (*reference_type) PARAMS ((PTR)); + bfd_boolean (*reference_type) PARAMS ((PTR)); /* Pop the top type on the type stack, and push a range of that type with the given lower and upper bounds onto the type stack. */ - boolean (*range_type) PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma)); + bfd_boolean (*range_type) PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma)); /* Push an array type onto the type stack. The top type on the type stack is the range, and the next type on the type stack is the element type. These should be popped before the array type is pushed. The arguments are the lower bound, the upper bound, and whether the array is a string. */ - boolean (*array_type) PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, - boolean)); + bfd_boolean (*array_type) + PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, bfd_boolean)); /* Pop the top type on the type stack, and push a set of that type onto the type stack. The argument indicates whether this set is a bitstring. */ - boolean (*set_type) PARAMS ((PTR, boolean)); + bfd_boolean (*set_type) PARAMS ((PTR, bfd_boolean)); /* Push an offset type onto the type stack. The top type on the type stack is the target type, and the next type on the type stack is the base type. These should be popped before the offset type is pushed. */ - boolean (*offset_type) PARAMS ((PTR)); + bfd_boolean (*offset_type) PARAMS ((PTR)); /* Push a method type onto the type stack. If the second argument - is true, the top type on the stack is the class to which the + is TRUE, the top type on the stack is the class to which the method belongs; otherwise, the class must be determined by the 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). A value of -1 for the third argument means that no - argument information is available. The fourth argument is true + 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)); + bfd_boolean (*method_type) PARAMS ((PTR, bfd_boolean, int, bfd_boolean)); /* Pop the top type off the type stack, and push a const qualified version of that type onto the type stack. */ - boolean (*const_type) PARAMS ((PTR)); + bfd_boolean (*const_type) PARAMS ((PTR)); /* Pop the top type off the type stack, and push a volatile qualified version of that type onto the type stack. */ - boolean (*volatile_type) PARAMS ((PTR)); + bfd_boolean (*volatile_type) PARAMS ((PTR)); /* 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. 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 + 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)); + bfd_boolean (*start_struct_type) + PARAMS ((PTR, const char *, unsigned int, bfd_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 are the name, the bit position, the bit size (may be zero if the field is not packed), and the visibility. */ - boolean (*struct_field) PARAMS ((PTR, const char *, bfd_vma, bfd_vma, - enum debug_visibility)); + bfd_boolean (*struct_field) + PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility)); /* Finish building a struct, and push it onto the type stack. */ - boolean (*end_struct_type) PARAMS ((PTR)); + bfd_boolean (*end_struct_type) PARAMS ((PTR)); /* Start building a class. This is followed by calls to several functions: struct_field, class_static_member, class_baseclass, @@ -296,27 +296,27 @@ struct debug_write_fns class_static_method_variant, and class_end_method. The class is 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 + 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)); + bfd_boolean (*start_class_type) + PARAMS ((PTR, const char *, unsigned int, bfd_boolean, unsigned int, + bfd_boolean, bfd_boolean)); /* Add a static member to the class currently being built. The arguments are the field name, the physical name, and the visibility. The type must be popped off the type stack. */ - boolean (*class_static_member) PARAMS ((PTR, const char *, const char *, - enum debug_visibility)); + bfd_boolean (*class_static_member) + PARAMS ((PTR, const char *, const char *, enum debug_visibility)); /* Add a baseclass to the class currently being built. The type of the baseclass must be popped off the type stack. The arguments are the bit position, whether the class is virtual, and the visibility. */ - boolean (*class_baseclass) PARAMS ((PTR, bfd_vma, boolean, - enum debug_visibility)); + bfd_boolean (*class_baseclass) + PARAMS ((PTR, bfd_vma, bfd_boolean, enum debug_visibility)); /* Start adding a method to the class currently being built. This is followed by calls to class_method_variant and @@ -324,7 +324,7 @@ struct debug_write_fns method which take different arguments. The method is finished with a call to class_end_method. The argument is the method name. */ - boolean (*class_start_method) PARAMS ((PTR, const char *)); + bfd_boolean (*class_start_method) PARAMS ((PTR, const char *)); /* Describe a variant to the class method currently being built. The type of the variant must be popped off the type stack. The @@ -333,28 +333,27 @@ struct debug_write_fns 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, - bfd_vma, boolean)); + bfd_boolean (*class_method_variant) + PARAMS ((PTR, const char *, enum debug_visibility, bfd_boolean, + bfd_boolean, bfd_vma, bfd_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. 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)); + bfd_boolean (*class_static_method_variant) + PARAMS ((PTR, const char *, enum debug_visibility, bfd_boolean, + bfd_boolean)); /* Finish describing a class method. */ - boolean (*class_end_method) PARAMS ((PTR)); + bfd_boolean (*class_end_method) PARAMS ((PTR)); /* Finish describing a class, and push it onto the type stack. */ - boolean (*end_class_type) PARAMS ((PTR)); + bfd_boolean (*end_class_type) PARAMS ((PTR)); /* Push a type on the stack which was given a name by an earlier call to typdef. */ - boolean (*typedef_type) PARAMS ((PTR, const char *)); + bfd_boolean (*typedef_type) PARAMS ((PTR, const char *)); /* 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 @@ -365,58 +364,58 @@ struct debug_write_fns 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)); + bfd_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 *)); + bfd_boolean (*typdef) PARAMS ((PTR, const char *)); /* Pop the type stack, and declare it as a tagged struct or union or 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 *)); + bfd_boolean (*tag) PARAMS ((PTR, const char *)); /* This is called to record a named integer constant. */ - boolean (*int_constant) PARAMS ((PTR, const char *, bfd_vma)); + bfd_boolean (*int_constant) PARAMS ((PTR, const char *, bfd_vma)); /* This is called to record a named floating point constant. */ - boolean (*float_constant) PARAMS ((PTR, const char *, double)); + bfd_boolean (*float_constant) PARAMS ((PTR, const char *, double)); /* This is called to record a typed integer constant. The type is popped off the type stack. */ - boolean (*typed_constant) PARAMS ((PTR, const char *, bfd_vma)); + bfd_boolean (*typed_constant) PARAMS ((PTR, const char *, bfd_vma)); /* This is called to record a variable. The type is popped off the type stack. */ - boolean (*variable) PARAMS ((PTR, const char *, enum debug_var_kind, - bfd_vma)); + bfd_boolean (*variable) + PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma)); /* Start writing out a function. The return type must be popped off - the stack. The boolean is true if the function is global. This + the stack. The bfd_boolean is TRUE if the function is global. This is followed by calls to function_parameter, followed by block information. */ - boolean (*start_function) PARAMS ((PTR, const char *, boolean)); + bfd_boolean (*start_function) PARAMS ((PTR, const char *, bfd_boolean)); /* Record a function parameter for the current function. The type must be popped off the stack. */ - boolean (*function_parameter) PARAMS ((PTR, const char *, - enum debug_parm_kind, bfd_vma)); + bfd_boolean (*function_parameter) + PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma)); /* Start writing out a block. There is at least one top level block per function. Blocks may be nested. The argument is the starting address of the block. */ - boolean (*start_block) PARAMS ((PTR, bfd_vma)); + bfd_boolean (*start_block) PARAMS ((PTR, bfd_vma)); /* Finish writing out a block. The argument is the ending address of the block. */ - boolean (*end_block) PARAMS ((PTR, bfd_vma)); + bfd_boolean (*end_block) PARAMS ((PTR, bfd_vma)); /* Finish writing out a function. */ - boolean (*end_function) PARAMS ((PTR)); + bfd_boolean (*end_function) PARAMS ((PTR)); /* Record line number information for the current compilation unit. */ - boolean (*lineno) PARAMS ((PTR, const char *, unsigned long, bfd_vma)); + bfd_boolean (*lineno) PARAMS ((PTR, const char *, unsigned long, bfd_vma)); }; /* Exported functions. */ @@ -434,81 +433,83 @@ extern PTR debug_init PARAMS ((void)); /* Set the source filename. This implicitly starts a new compilation unit. */ -extern boolean debug_set_filename PARAMS ((PTR, const char *)); +extern bfd_boolean debug_set_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_start_source PARAMS ((PTR, const char *)); +extern bfd_boolean debug_start_source PARAMS ((PTR, const char *)); /* Record a function definition. This implicitly starts a function block. The debug_type argument is the type of the return value. - The boolean indicates whether the function is globally visible. + The bfd_boolean indicates whether the function is globally visible. The bfd_vma is the address of the start of the function. Currently the parameter types are specified by calls to debug_record_parameter. */ -extern boolean debug_record_function - PARAMS ((PTR, const char *, debug_type, boolean, bfd_vma)); +extern bfd_boolean debug_record_function + PARAMS ((PTR, const char *, debug_type, bfd_boolean, bfd_vma)); /* Record a parameter for the current function. */ -extern boolean debug_record_parameter +extern bfd_boolean debug_record_parameter PARAMS ((PTR, const char *, debug_type, enum debug_parm_kind, bfd_vma)); /* End a function definition. The argument is the address where the function ends. */ -extern boolean debug_end_function PARAMS ((PTR, bfd_vma)); +extern bfd_boolean debug_end_function PARAMS ((PTR, bfd_vma)); /* Start a block in a function. All local information will be recorded in this block, until the matching call to debug_end_block. debug_start_block and debug_end_block may be nested. The argument is the address at which this block starts. */ -extern boolean debug_start_block PARAMS ((PTR, bfd_vma)); +extern bfd_boolean debug_start_block PARAMS ((PTR, bfd_vma)); /* Finish a block in a function. This matches the call to debug_start_block. The argument is the address at which this block ends. */ -extern boolean debug_end_block PARAMS ((PTR, bfd_vma)); +extern bfd_boolean debug_end_block PARAMS ((PTR, bfd_vma)); /* 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 bfd_boolean debug_record_line PARAMS ((PTR, unsigned long, bfd_vma)); /* Start a named common block. This is a block of variables that may move in memory. */ -extern boolean debug_start_common_block PARAMS ((PTR, const char *)); +extern bfd_boolean debug_start_common_block PARAMS ((PTR, const char *)); /* End a named common block. */ -extern boolean debug_end_common_block PARAMS ((PTR, const char *)); +extern bfd_boolean debug_end_common_block PARAMS ((PTR, const char *)); /* Record a named integer constant. */ -extern boolean debug_record_int_const PARAMS ((PTR, const char *, bfd_vma)); +extern bfd_boolean debug_record_int_const + PARAMS ((PTR, const char *, bfd_vma)); /* Record a named floating point constant. */ -extern boolean debug_record_float_const PARAMS ((PTR, const char *, double)); +extern bfd_boolean debug_record_float_const + PARAMS ((PTR, const char *, double)); /* Record a typed constant with an integral value. */ -extern boolean debug_record_typed_const +extern bfd_boolean debug_record_typed_const PARAMS ((PTR, const char *, debug_type, bfd_vma)); /* Record a label. */ -extern boolean debug_record_label +extern bfd_boolean debug_record_label PARAMS ((PTR, const char *, debug_type, bfd_vma)); /* Record a variable. */ -extern boolean debug_record_variable +extern bfd_boolean debug_record_variable PARAMS ((PTR, const char *, debug_type, enum debug_var_kind, bfd_vma)); /* Make an indirect type. The first argument is a pointer to the @@ -525,10 +526,11 @@ extern debug_type debug_make_indirect_type extern debug_type debug_make_void_type PARAMS ((PTR)); -/* Make an integer type of a given size. The boolean argument is true +/* Make an integer type of a given size. The bfd_boolean argument is TRUE if the integer is unsigned. */ -extern debug_type debug_make_int_type PARAMS ((PTR, unsigned int, boolean)); +extern debug_type debug_make_int_type + PARAMS ((PTR, unsigned int, bfd_boolean)); /* Make a floating point type of a given size. FIXME: On some platforms, like an Alpha, you probably need to be able to specify @@ -544,23 +546,23 @@ extern debug_type debug_make_bool_type PARAMS ((PTR, unsigned int)); extern debug_type debug_make_complex_type PARAMS ((PTR, unsigned int)); -/* Make a structure type. The second argument is true for a struct, - false for a union. The third argument is the size of the struct. +/* Make a structure type. The second argument is TRUE for a struct, + FALSE for a union. The third argument is the size of the struct. The fourth argument is a NULL terminated array of fields. */ extern debug_type debug_make_struct_type - PARAMS ((PTR, boolean, bfd_vma, debug_field *)); + PARAMS ((PTR, bfd_boolean, bfd_vma, debug_field *)); /* Make an object type. The first three arguments after the handle are the same as for debug_make_struct_type. The next arguments are a NULL terminated array of base classes, a NULL terminated array of methods, the type of the object holding the virtual function table - if it is not this object, and a boolean which is true if this + if it is not this object, and a bfd_boolean which is TRUE if this object has its own virtual function table. */ extern debug_type debug_make_object_type - PARAMS ((PTR, boolean, bfd_vma, debug_field *, debug_baseclass *, - debug_method *, debug_type, boolean)); + PARAMS ((PTR, bfd_boolean, bfd_vma, debug_field *, debug_baseclass *, + debug_method *, debug_type, bfd_boolean)); /* Make an enumeration type. The arguments are a null terminated array of strings, and an array of corresponding values. */ @@ -575,12 +577,12 @@ extern debug_type debug_make_pointer_type /* 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 + 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, debug_type *, boolean)); + PARAMS ((PTR, debug_type, debug_type *, bfd_boolean)); /* Make a reference to a given type. */ @@ -595,18 +597,18 @@ extern debug_type debug_make_range_type of the array. The third argument is the type of a range of the array. The fourth and fifth argument are the lower and upper bounds, respectively (if the bounds are not known, lower should be - 0 and upper should be -1). The sixth argument is true if this + 0 and upper should be -1). The sixth argument is TRUE if this array is actually a string, as in C. */ extern debug_type debug_make_array_type PARAMS ((PTR, debug_type, debug_type, bfd_signed_vma, bfd_signed_vma, - boolean)); + bfd_boolean)); /* Make a set of a given type. For example, a Pascal set type. The - boolean argument is true if this set is actually a bitstring, as in + bfd_boolean argument is TRUE if this set is actually a bitstring, as in CHILL. */ -extern debug_type debug_make_set_type PARAMS ((PTR, debug_type, boolean)); +extern debug_type debug_make_set_type PARAMS ((PTR, debug_type, bfd_boolean)); /* Make a type for a pointer which is relative to an object. The second argument is the type of the object to which the pointer is @@ -619,7 +621,7 @@ extern debug_type debug_make_offset_type /* Make a type for a method function. The second argument is the 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 + 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 @@ -627,7 +629,7 @@ extern debug_type debug_make_offset_type the argument types from the mangled name. */ extern debug_type debug_make_method_type - PARAMS ((PTR, debug_type, debug_type, debug_type *, boolean)); + PARAMS ((PTR, debug_type, debug_type, debug_type *, bfd_boolean)); /* Make a const qualified version of a given type. */ @@ -650,7 +652,7 @@ extern debug_type debug_make_undefined_tagged_type class. */ extern debug_baseclass debug_make_baseclass - PARAMS ((PTR, debug_type, bfd_vma, boolean, enum debug_visibility)); + PARAMS ((PTR, debug_type, bfd_vma, bfd_boolean, enum debug_visibility)); /* Make a field for a struct. The second argument is the name. The third argument is the type of the field. The fourth argument is @@ -690,16 +692,16 @@ extern debug_method debug_make_method function context. */ extern debug_method_variant debug_make_method_variant - PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean, - boolean, bfd_vma, debug_type)); + PARAMS ((PTR, const char *, debug_type, enum debug_visibility, bfd_boolean, + bfd_boolean, bfd_vma, debug_type)); /* Make a static method argument. The arguments are the same as for debug_make_method_variant, except that the last two are omitted since a static method can not also be virtual. */ extern debug_method_variant debug_make_static_method_variant - PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean, - boolean)); + PARAMS ((PTR, const char *, debug_type, enum debug_visibility, bfd_boolean, + bfd_boolean)); /* Name a type. This returns a new type with an attached name. */ @@ -712,7 +714,8 @@ extern debug_type debug_tag_type PARAMS ((PTR, const char *, debug_type)); /* Record the size of a given type. */ -extern boolean debug_record_type_size PARAMS ((PTR, debug_type, unsigned int)); +extern bfd_boolean debug_record_type_size + PARAMS ((PTR, debug_type, unsigned int)); /* Find a named type. */ @@ -743,12 +746,11 @@ extern debug_type debug_get_return_type PARAMS ((PTR, debug_type)); 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 + bfd_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 *)); +extern const debug_type *debug_get_parameter_types + PARAMS ((PTR, debug_type, bfd_boolean *)); /* Get the target type of a pointer or reference or const or volatile type. */ @@ -793,6 +795,7 @@ extern const char *debug_get_field_physname PARAMS ((PTR, debug_field)); first PTR is the debugging handle. The second PTR is a handle which is passed to the functions. */ -extern boolean debug_write PARAMS ((PTR, const struct debug_write_fns *, PTR)); +extern bfd_boolean debug_write + PARAMS ((PTR, const struct debug_write_fns *, PTR)); #endif /* DEBUG_H */ |