X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=binutils%2Fdebug.c;h=07d38acfe4021aac62f154ca4f62e0df11622cc0;hb=cc429f578cef8587d7e95936659d010a00a626df;hp=c6ce8a7c01495f5862690b725533985e86b6ab86;hpb=fa803dc60f0bf01297674c41d001798e18ade4dc;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/debug.c b/binutils/debug.c index c6ce8a7c01..07d38acfe4 100644 --- a/binutils/debug.c +++ b/binutils/debug.c @@ -1,5 +1,6 @@ /* debug.c -- Handle generic debugging information. - Copyright (C) 1995, 1996 Free Software Foundation, Inc. + Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003 + Free Software Foundation, Inc. Written by Ian Lance Taylor . This file is part of GNU Binutils. @@ -16,13 +17,13 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ /* This file implements a generic debugging format. We may eventually have readers which convert different formats into this generic format, and writers which write it out. The initial impetus for - this was writing a convertor from stabs to HP IEEE-695 debugging + this was writing a converter from stabs to HP IEEE-695 debugging format. */ #include @@ -56,6 +57,9 @@ struct debug_handle unsigned int class_id; /* The base for class_id for this call to debug_write. */ unsigned int base_id; + /* The current line number in debug_write. */ + struct debug_lineno *current_write_lineno; + unsigned int current_write_lineno_index; /* A list of classes which have assigned ID's during debug_write. This is linked through the next_id field of debug_class_type. */ struct debug_class_id *id_list; @@ -108,7 +112,7 @@ struct debug_type struct debug_indirect_type *kindirect; /* DEBUG_KIND_INT. */ /* Whether the integer is unsigned. */ - boolean kint; + bfd_boolean kint; /* DEBUG_KIND_STRUCT, DEBUG_KIND_UNION, DEBUG_KIND_CLASS, DEBUG_KIND_UNION_CLASS. */ struct debug_class_type *kclass; @@ -191,7 +195,7 @@ struct debug_function_type /* NULL terminated array of argument types. */ debug_type *arg_types; /* Whether the function takes a variable number of arguments. */ - boolean varargs; + bfd_boolean varargs; }; /* Information kept for a range. */ @@ -219,7 +223,7 @@ struct debug_array_type /* Upper bound. */ bfd_signed_vma upper; /* Whether this array is really a string. */ - boolean stringp; + bfd_boolean stringp; }; /* Information kept for a set. */ @@ -229,7 +233,7 @@ struct debug_set_type /* Base type. */ debug_type type; /* Whether this set is really a bitstring. */ - boolean bitstringp; + bfd_boolean bitstringp; }; /* Information kept for an offset type (a based pointer). */ @@ -253,7 +257,7 @@ struct debug_method_type /* A NULL terminated array of argument types. */ debug_type *arg_types; /* Whether the method takes a variable number of arguments. */ - boolean varargs; + bfd_boolean varargs; }; /* Information kept for a named type. */ @@ -277,7 +281,7 @@ struct debug_field /* Visibility of the field. */ enum debug_visibility visibility; /* Whether this is a static member. */ - boolean static_member; + bfd_boolean static_member; union { /* If static_member is false. */ @@ -305,7 +309,7 @@ struct debug_baseclass /* Bit position of the base class in the object. */ unsigned int bitpos; /* Whether the base class is virtual. */ - boolean virtual; + bfd_boolean virtual; /* Visibility of the base class. */ enum debug_visibility visibility; }; @@ -332,9 +336,9 @@ struct debug_method_variant /* The visibility of the function. */ enum debug_visibility visibility; /* Whether the function is const. */ - boolean constp; + bfd_boolean constp; /* Whether the function is volatile. */ - boolean volatilep; + bfd_boolean volatilep; /* The offset to the function in the virtual function table. */ bfd_vma voffset; /* If voffset is VOFFSET_STATIC_METHOD, this is a static method. */ @@ -538,45 +542,58 @@ struct debug_type_compare_list struct debug_type *t2; }; +/* During debug_get_real_type, a linked list of these structures is + kept on the stack to avoid infinite recursion. */ + +struct debug_type_real_list +{ + /* Next type on list. */ + struct debug_type_real_list *next; + /* The type we are checking. */ + struct debug_type *t; +}; + /* Local functions. */ -static void debug_error PARAMS ((const char *)); +static void debug_error (const char *); static struct debug_name *debug_add_to_namespace - PARAMS ((struct debug_handle *, struct debug_namespace **, const char *, - enum debug_object_kind, enum debug_object_linkage)); + (struct debug_handle *, struct debug_namespace **, const char *, + enum debug_object_kind, enum debug_object_linkage); static struct debug_name *debug_add_to_current_namespace - PARAMS ((struct debug_handle *, const char *, enum debug_object_kind, - enum debug_object_linkage)); + (struct debug_handle *, const char *, enum debug_object_kind, + enum debug_object_linkage); static struct debug_type *debug_make_type - PARAMS ((struct debug_handle *, enum debug_type_kind, unsigned int)); -static struct debug_type *debug_get_real_type PARAMS ((PTR, debug_type)); -static boolean debug_write_name - PARAMS ((struct debug_handle *, const struct debug_write_fns *, PTR, - struct debug_name *)); -static boolean debug_write_type - PARAMS ((struct debug_handle *, const struct debug_write_fns *, PTR, - struct debug_type *, struct debug_name *)); -static boolean debug_write_class_type - PARAMS ((struct debug_handle *, const struct debug_write_fns *, PTR, - struct debug_type *, const char *)); -static boolean debug_write_function - PARAMS ((struct debug_handle *, const struct debug_write_fns *, PTR, - const char *, enum debug_object_linkage, struct debug_function *)); -static boolean debug_write_block - PARAMS ((struct debug_handle *, const struct debug_write_fns *, PTR, - struct debug_block *)); -static boolean debug_set_class_id - PARAMS ((struct debug_handle *, const char *, struct debug_type *)); -static boolean debug_type_samep - PARAMS ((struct debug_handle *, struct debug_type *, struct debug_type *)); -static boolean debug_class_type_samep - PARAMS ((struct debug_handle *, struct debug_type *, struct debug_type *)); + (struct debug_handle *, enum debug_type_kind, unsigned int); +static struct debug_type *debug_get_real_type + (void *, debug_type, struct debug_type_real_list *); +static bfd_boolean debug_write_name + (struct debug_handle *, const struct debug_write_fns *, void *, + struct debug_name *); +static bfd_boolean debug_write_type + (struct debug_handle *, const struct debug_write_fns *, void *, + struct debug_type *, struct debug_name *); +static bfd_boolean debug_write_class_type + (struct debug_handle *, const struct debug_write_fns *, void *, + struct debug_type *, const char *); +static bfd_boolean debug_write_function + (struct debug_handle *, const struct debug_write_fns *, void *, + const char *, enum debug_object_linkage, struct debug_function *); +static bfd_boolean debug_write_block + (struct debug_handle *, const struct debug_write_fns *, void *, + struct debug_block *); +static bfd_boolean debug_write_linenos + (struct debug_handle *, const struct debug_write_fns *, void *, bfd_vma); +static bfd_boolean debug_set_class_id + (struct debug_handle *, const char *, struct debug_type *); +static bfd_boolean debug_type_samep + (struct debug_handle *, struct debug_type *, struct debug_type *); +static bfd_boolean debug_class_type_samep + (struct debug_handle *, struct debug_type *, struct debug_type *); /* Issue an error message. */ static void -debug_error (message) - const char *message; +debug_error (const char *message) { fprintf (stderr, "%s\n", message); } @@ -584,12 +601,10 @@ debug_error (message) /* Add an object to a namespace. */ static struct debug_name * -debug_add_to_namespace (info, nsp, name, kind, linkage) - struct debug_handle *info; - struct debug_namespace **nsp; - const char *name; - enum debug_object_kind kind; - enum debug_object_linkage linkage; +debug_add_to_namespace (struct debug_handle *info ATTRIBUTE_UNUSED, + struct debug_namespace **nsp, const char *name, + enum debug_object_kind kind, + enum debug_object_linkage linkage) { struct debug_name *n; struct debug_namespace *ns; @@ -621,18 +636,16 @@ debug_add_to_namespace (info, nsp, name, kind, linkage) /* Add an object to the current namespace. */ static struct debug_name * -debug_add_to_current_namespace (info, name, kind, linkage) - struct debug_handle *info; - const char *name; - enum debug_object_kind kind; - enum debug_object_linkage linkage; +debug_add_to_current_namespace (struct debug_handle *info, const char *name, + enum debug_object_kind kind, + enum debug_object_linkage linkage) { struct debug_namespace **nsp; if (info->current_unit == NULL || info->current_file == NULL) { - debug_error ("debug_add_to_current_namespace: no current file"); + debug_error (_("debug_add_to_current_namespace: no current file")); return NULL; } @@ -646,23 +659,21 @@ debug_add_to_current_namespace (info, name, kind, linkage) /* Return a handle for debugging information. */ -PTR -debug_init () +void * +debug_init (void) { struct debug_handle *ret; ret = (struct debug_handle *) xmalloc (sizeof *ret); memset (ret, 0, sizeof *ret); - return (PTR) ret; + return (void *) ret; } /* Set the source filename. This implicitly starts a new compilation unit. */ -boolean -debug_set_filename (handle, name) - PTR handle; - const char *name; +bfd_boolean +debug_set_filename (void *handle, const char *name) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_file *nfile; @@ -696,16 +707,14 @@ debug_set_filename (handle, name) info->current_block = NULL; info->current_lineno = NULL; - return true; + return TRUE; } /* Change source files to the given file name. This is used for include files in a single compilation unit. */ -boolean -debug_start_source (handle, name) - PTR handle; - const char *name; +bfd_boolean +debug_start_source (void *handle, const char *name) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_file *f, **pf; @@ -715,8 +724,8 @@ debug_start_source (handle, name) if (info->current_unit == NULL) { - debug_error ("debug_start_source: no debug_set_filename call"); - return false; + debug_error (_("debug_start_source: no debug_set_filename call")); + return FALSE; } for (f = info->current_unit->files; f != NULL; f = f->next) @@ -726,7 +735,7 @@ debug_start_source (handle, name) && strcmp (f->filename, name) == 0) { info->current_file = f; - return true; + return TRUE; } } @@ -743,7 +752,7 @@ debug_start_source (handle, name) info->current_file = f; - return true; + return TRUE; } /* Record a function definition. This implicitly starts a function @@ -754,13 +763,10 @@ debug_start_source (handle, name) debug_record_parameter. FIXME: There is no way to specify nested functions. */ -boolean -debug_record_function (handle, name, return_type, global, addr) - PTR handle; - const char *name; - debug_type return_type; - boolean global; - bfd_vma addr; +bfd_boolean +debug_record_function (void *handle, const char *name, + debug_type return_type, bfd_boolean global, + bfd_vma addr) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_function *f; @@ -770,12 +776,12 @@ debug_record_function (handle, name, return_type, global, addr) if (name == NULL) name = ""; if (return_type == NULL) - return false; + return FALSE; if (info->current_unit == NULL) { - debug_error ("debug_record_function: no debug_set_filename call"); - return false; + debug_error (_("debug_record_function: no debug_set_filename call")); + return FALSE; } f = (struct debug_function *) xmalloc (sizeof *f); @@ -804,34 +810,30 @@ debug_record_function (handle, name, return_type, global, addr) ? DEBUG_LINKAGE_GLOBAL : DEBUG_LINKAGE_STATIC)); if (n == NULL) - return false; + return FALSE; n->u.function = f; - return true; + return TRUE; } /* Record a parameter for the current function. */ -boolean -debug_record_parameter (handle, name, type, kind, val) - PTR handle; - const char *name; - debug_type type; - enum debug_parm_kind kind; - bfd_vma val; +bfd_boolean +debug_record_parameter (void *handle, const char *name, debug_type type, + enum debug_parm_kind kind, bfd_vma val) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_parameter *p, **pp; if (name == NULL || type == NULL) - return false; + return FALSE; if (info->current_unit == NULL || info->current_function == NULL) { - debug_error ("debug_record_parameter: no current function"); - return false; + debug_error (_("debug_record_parameter: no current function")); + return FALSE; } p = (struct debug_parameter *) xmalloc (sizeof *p); @@ -848,15 +850,13 @@ debug_record_parameter (handle, name, type, kind, val) ; *pp = p; - return true; + return TRUE; } /* End a function. FIXME: This should handle function nesting. */ -boolean -debug_end_function (handle, addr) - PTR handle; - bfd_vma addr; +bfd_boolean +debug_end_function (void *handle, bfd_vma addr) { struct debug_handle *info = (struct debug_handle *) handle; @@ -864,14 +864,14 @@ debug_end_function (handle, addr) || info->current_block == NULL || info->current_function == NULL) { - debug_error ("debug_end_function: no current function"); - return false; + debug_error (_("debug_end_function: no current function")); + return FALSE; } if (info->current_block->parent != NULL) { - debug_error ("debug_end_function: some blocks were not closed"); - return false; + debug_error (_("debug_end_function: some blocks were not closed")); + return FALSE; } info->current_block->end = addr; @@ -879,7 +879,7 @@ debug_end_function (handle, addr) info->current_function = NULL; info->current_block = NULL; - return true; + return TRUE; } /* Start a block in a function. All local information will be @@ -887,10 +887,8 @@ debug_end_function (handle, addr) debug_start_block and debug_end_block may be nested. The bfd_vma argument is the address at which this block starts. */ -boolean -debug_start_block (handle, addr) - PTR handle; - bfd_vma addr; +bfd_boolean +debug_start_block (void *handle, bfd_vma addr) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_block *b, **pb; @@ -900,8 +898,8 @@ debug_start_block (handle, addr) if (info->current_unit == NULL || info->current_block == NULL) { - debug_error ("debug_start_block: no current block"); - return false; + debug_error (_("debug_start_block: no current block")); + return FALSE; } b = (struct debug_block *) xmalloc (sizeof *b); @@ -920,17 +918,15 @@ debug_start_block (handle, addr) info->current_block = b; - return true; + return TRUE; } /* Finish a block in a function. This matches the call to debug_start_block. The argument is the address at which this block ends. */ -boolean -debug_end_block (handle, addr) - PTR handle; - bfd_vma addr; +bfd_boolean +debug_end_block (void *handle, bfd_vma addr) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_block *parent; @@ -938,32 +934,29 @@ debug_end_block (handle, addr) if (info->current_unit == NULL || info->current_block == NULL) { - debug_error ("debug_end_block: no current block"); - return false; + debug_error (_("debug_end_block: no current block")); + return FALSE; } parent = info->current_block->parent; if (parent == NULL) { - debug_error ("debug_end_block: attempt to close top level block"); - return false; + debug_error (_("debug_end_block: attempt to close top level block")); + return FALSE; } info->current_block->end = addr; info->current_block = parent; - return true; + return TRUE; } /* Associate a line number in the current source file and function with a given address. */ -boolean -debug_record_line (handle, lineno, addr) - PTR handle; - unsigned long lineno; - bfd_vma addr; +bfd_boolean +debug_record_line (void *handle, unsigned long lineno, bfd_vma addr) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_lineno *l; @@ -971,8 +964,8 @@ debug_record_line (handle, lineno, addr) if (info->current_unit == NULL) { - debug_error ("debug_record_line: no current unit"); - return false; + debug_error (_("debug_record_line: no current unit")); + return FALSE; } l = info->current_lineno; @@ -984,7 +977,7 @@ debug_record_line (handle, lineno, addr) { l->linenos[i] = lineno; l->addrs[i] = addr; - return true; + return TRUE; } } } @@ -1013,102 +1006,91 @@ debug_record_line (handle, lineno, addr) info->current_lineno = l; - return true; + return TRUE; } /* Start a named common block. This is a block of variables that may move in memory. */ -boolean -debug_start_common_block (handle, name) - PTR handle; - const char *name; +bfd_boolean +debug_start_common_block (void *handle ATTRIBUTE_UNUSED, + const char *name ATTRIBUTE_UNUSED) { /* FIXME */ - debug_error ("debug_start_common_block: not implemented"); - return false; + debug_error (_("debug_start_common_block: not implemented")); + return FALSE; } /* End a named common block. */ -boolean -debug_end_common_block (handle, name) - PTR handle; - const char *name; +bfd_boolean +debug_end_common_block (void *handle ATTRIBUTE_UNUSED, + const char *name ATTRIBUTE_UNUSED) { /* FIXME */ - debug_error ("debug_end_common_block: not implemented"); - return false; + debug_error (_("debug_end_common_block: not implemented")); + return FALSE; } /* Record a named integer constant. */ -boolean -debug_record_int_const (handle, name, val) - PTR handle; - const char *name; - bfd_vma val; +bfd_boolean +debug_record_int_const (void *handle, const char *name, bfd_vma val) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_name *n; if (name == NULL) - return false; + return FALSE; n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_INT_CONSTANT, DEBUG_LINKAGE_NONE); if (n == NULL) - return false; + return FALSE; n->u.int_constant = val; - return true; + return TRUE; } /* Record a named floating point constant. */ -boolean -debug_record_float_const (handle, name, val) - PTR handle; - const char *name; - double val; +bfd_boolean +debug_record_float_const (void *handle, const char *name, double val) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_name *n; if (name == NULL) - return false; + return FALSE; n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_FLOAT_CONSTANT, DEBUG_LINKAGE_NONE); if (n == NULL) - return false; + return FALSE; n->u.float_constant = val; - return true; + return TRUE; } /* Record a typed constant with an integral value. */ -boolean -debug_record_typed_const (handle, name, type, val) - PTR handle; - const char *name; - debug_type type; - bfd_vma val; +bfd_boolean +debug_record_typed_const (void *handle, const char *name, debug_type type, + bfd_vma val) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_name *n; struct debug_typed_constant *tc; if (name == NULL || type == NULL) - return false; + return FALSE; n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_TYPED_CONSTANT, DEBUG_LINKAGE_NONE); if (n == NULL) - return false; + return FALSE; tc = (struct debug_typed_constant *) xmalloc (sizeof *tc); memset (tc, 0, sizeof *tc); @@ -1118,32 +1100,27 @@ debug_record_typed_const (handle, name, type, val) n->u.typed_constant = tc; - return true; + return TRUE; } /* Record a label. */ -boolean -debug_record_label (handle, name, type, addr) - PTR handle; - const char *name; - debug_type type; - bfd_vma addr; +bfd_boolean +debug_record_label (void *handle ATTRIBUTE_UNUSED, + const char *name ATTRIBUTE_UNUSED, + debug_type type ATTRIBUTE_UNUSED, + bfd_vma addr ATTRIBUTE_UNUSED) { /* FIXME. */ - debug_error ("debug_record_label not implemented"); - return false; + debug_error (_("debug_record_label: not implemented")); + return FALSE; } /* Record a variable. */ -boolean -debug_record_variable (handle, name, type, kind, val) - PTR handle; - const char *name; - debug_type type; - enum debug_var_kind kind; - bfd_vma val; +bfd_boolean +debug_record_variable (void *handle, const char *name, debug_type type, + enum debug_var_kind kind, bfd_vma val) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_namespace **nsp; @@ -1152,13 +1129,13 @@ debug_record_variable (handle, name, type, kind, val) struct debug_variable *v; if (name == NULL || type == NULL) - return false; + return FALSE; if (info->current_unit == NULL || info->current_file == NULL) { - debug_error ("debug_record_variable: no current file"); - return false; + debug_error (_("debug_record_variable: no current file")); + return FALSE; } if (kind == DEBUG_GLOBAL || kind == DEBUG_STATIC) @@ -1172,17 +1149,15 @@ debug_record_variable (handle, name, type, kind, val) else { if (info->current_block == NULL) - { - debug_error ("debug_record_variable: no current block"); - return false; - } - nsp = &info->current_block->locals; + nsp = &info->current_file->globals; + else + nsp = &info->current_block->locals; linkage = DEBUG_LINKAGE_AUTOMATIC; } n = debug_add_to_namespace (info, nsp, name, DEBUG_OBJECT_VARIABLE, linkage); if (n == NULL) - return false; + return FALSE; v = (struct debug_variable *) xmalloc (sizeof *v); memset (v, 0, sizeof *v); @@ -1193,17 +1168,14 @@ debug_record_variable (handle, name, type, kind, val) n->u.variable = v; - return true; + return TRUE; } /* Make a type with a given kind and size. */ -/*ARGSUSED*/ static struct debug_type * -debug_make_type (info, kind, size) - struct debug_handle *info; - enum debug_type_kind kind; - unsigned int size; +debug_make_type (struct debug_handle *info ATTRIBUTE_UNUSED, + enum debug_type_kind kind, unsigned int size) { struct debug_type *t; @@ -1220,10 +1192,7 @@ debug_make_type (info, kind, size) which is referenced before it is defined. */ debug_type -debug_make_indirect_type (handle, slot, tag) - PTR handle; - debug_type *slot; - const char *tag; +debug_make_indirect_type (void *handle, debug_type *slot, const char *tag) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1247,8 +1216,7 @@ debug_make_indirect_type (handle, slot, tag) /* Make a void type. There is only one of these. */ debug_type -debug_make_void_type (handle) - PTR handle; +debug_make_void_type (void *handle) { struct debug_handle *info = (struct debug_handle *) handle; @@ -1259,10 +1227,7 @@ debug_make_void_type (handle) if the integer is unsigned. */ debug_type -debug_make_int_type (handle, size, unsignedp) - PTR handle; - unsigned int size; - boolean unsignedp; +debug_make_int_type (void *handle, unsigned int size, bfd_boolean unsignedp) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1281,9 +1246,7 @@ debug_make_int_type (handle, size, unsignedp) the format. */ debug_type -debug_make_float_type (handle, size) - PTR handle; - unsigned int size; +debug_make_float_type (void *handle, unsigned int size) { struct debug_handle *info = (struct debug_handle *) handle; @@ -1293,9 +1256,7 @@ debug_make_float_type (handle, size) /* Make a boolean type of a given size. */ debug_type -debug_make_bool_type (handle, size) - PTR handle; - unsigned int size; +debug_make_bool_type (void *handle, unsigned int size) { struct debug_handle *info = (struct debug_handle *) handle; @@ -1305,9 +1266,7 @@ debug_make_bool_type (handle, size) /* Make a complex type of a given size. */ debug_type -debug_make_complex_type (handle, size) - PTR handle; - unsigned int size; +debug_make_complex_type (void *handle, unsigned int size) { struct debug_handle *info = (struct debug_handle *) handle; @@ -1319,11 +1278,8 @@ debug_make_complex_type (handle, size) The fourth argument is a NULL terminated array of fields. */ debug_type -debug_make_struct_type (handle, structp, size, fields) - PTR handle; - boolean structp; - bfd_vma size; - debug_field *fields; +debug_make_struct_type (void *handle, bfd_boolean structp, bfd_vma size, + debug_field *fields) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1353,16 +1309,10 @@ debug_make_struct_type (handle, structp, size, fields) object has its own virtual function table. */ debug_type -debug_make_object_type (handle, structp, size, fields, baseclasses, - methods, vptrbase, ownvptr) - PTR handle; - boolean structp; - bfd_vma size; - debug_field *fields; - debug_baseclass *baseclasses; - debug_method *methods; - debug_type vptrbase; - boolean ownvptr; +debug_make_object_type (void *handle, bfd_boolean structp, bfd_vma size, + debug_field *fields, debug_baseclass *baseclasses, + debug_method *methods, debug_type vptrbase, + bfd_boolean ownvptr) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1394,10 +1344,8 @@ debug_make_object_type (handle, structp, size, fields, baseclasses, array of strings, and an array of corresponding values. */ debug_type -debug_make_enum_type (handle, names, values) - PTR handle; - const char **names; - bfd_signed_vma *values; +debug_make_enum_type (void *handle, const char **names, + bfd_signed_vma *values) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1421,9 +1369,7 @@ debug_make_enum_type (handle, names, values) /* Make a pointer to a given type. */ debug_type -debug_make_pointer_type (handle, type) - PTR handle; - debug_type type; +debug_make_pointer_type (void *handle, debug_type type) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1449,11 +1395,8 @@ debug_make_pointer_type (handle, type) to record the parameter types. */ debug_type -debug_make_function_type (handle, type, arg_types, varargs) - PTR handle; - debug_type type; - debug_type *arg_types; - boolean varargs; +debug_make_function_type (void *handle, debug_type type, + debug_type *arg_types, bfd_boolean varargs) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1481,9 +1424,7 @@ debug_make_function_type (handle, type, arg_types, varargs) /* Make a reference to a given type. */ debug_type -debug_make_reference_type (handle, type) - PTR handle; - debug_type type; +debug_make_reference_type (void *handle, debug_type type) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1503,11 +1444,8 @@ debug_make_reference_type (handle, type) /* Make a range of a given type from a lower to an upper bound. */ debug_type -debug_make_range_type (handle, type, lower, upper) - PTR handle; - debug_type type; - bfd_signed_vma lower; - bfd_signed_vma upper; +debug_make_range_type (void *handle, debug_type type, bfd_signed_vma lower, + bfd_signed_vma upper) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1539,14 +1477,9 @@ debug_make_range_type (handle, type, lower, upper) actually a string, as in C. */ debug_type -debug_make_array_type (handle, element_type, range_type, lower, upper, - stringp) - PTR handle; - debug_type element_type; - debug_type range_type; - bfd_signed_vma lower; - bfd_signed_vma upper; - boolean stringp; +debug_make_array_type (void *handle, debug_type element_type, + debug_type range_type, bfd_signed_vma lower, + bfd_signed_vma upper, bfd_boolean stringp) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1578,10 +1511,7 @@ debug_make_array_type (handle, element_type, range_type, lower, upper, CHILL. */ debug_type -debug_make_set_type (handle, type, bitstringp) - PTR handle; - debug_type type; - boolean bitstringp; +debug_make_set_type (void *handle, debug_type type, bfd_boolean bitstringp) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1611,10 +1541,8 @@ debug_make_set_type (handle, type, bitstringp) to. */ debug_type -debug_make_offset_type (handle, base_type, target_type) - PTR handle; - debug_type base_type; - debug_type target_type; +debug_make_offset_type (void *handle, debug_type base_type, + debug_type target_type) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1643,12 +1571,9 @@ debug_make_offset_type (handle, base_type, target_type) argument is a NULL terminated array of argument types. */ debug_type -debug_make_method_type (handle, return_type, domain_type, arg_types, varargs) - PTR handle; - debug_type return_type; - debug_type domain_type; - debug_type *arg_types; - boolean varargs; +debug_make_method_type (void *handle, debug_type return_type, + debug_type domain_type, debug_type *arg_types, + bfd_boolean varargs) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1677,9 +1602,7 @@ debug_make_method_type (handle, return_type, domain_type, arg_types, varargs) /* Make a const qualified version of a given type. */ debug_type -debug_make_const_type (handle, type) - PTR handle; - debug_type type; +debug_make_const_type (void *handle, debug_type type) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1699,9 +1622,7 @@ debug_make_const_type (handle, type) /* Make a volatile qualified version of a given type. */ debug_type -debug_make_volatile_type (handle, type) - PTR handle; - debug_type type; +debug_make_volatile_type (void *handle, debug_type type) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1722,10 +1643,8 @@ debug_make_volatile_type (handle, type) been mentioned, but not defined. */ debug_type -debug_make_undefined_tagged_type (handle, name, kind) - PTR handle; - const char *name; - enum debug_type_kind kind; +debug_make_undefined_tagged_type (void *handle, const char *name, + enum debug_type_kind kind) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1743,7 +1662,7 @@ debug_make_undefined_tagged_type (handle, name, kind) break; default: - debug_error ("debug_make_undefined_type: unsupported kind"); + debug_error (_("debug_make_undefined_type: unsupported kind")); return DEBUG_TYPE_NULL; } @@ -1760,15 +1679,11 @@ debug_make_undefined_tagged_type (handle, name, kind) The fourth argument is whether this is a virtual class. The fifth argument is the visibility of the base class. */ -/*ARGSUSED*/ debug_baseclass -debug_make_baseclass (handle, type, bitpos, virtual, visibility) - PTR handle; - debug_type type; - bfd_vma bitpos; - boolean virtual; - enum debug_visibility visibility; -{ +debug_make_baseclass (void *handle ATTRIBUTE_UNUSED, debug_type type, + bfd_vma bitpos, bfd_boolean virtual, + enum debug_visibility visibility) +{ struct debug_baseclass *b; b = (struct debug_baseclass *) xmalloc (sizeof *b); @@ -1788,15 +1703,10 @@ debug_make_baseclass (handle, type, bitpos, virtual, visibility) the field (it may be zero). The sixth argument is the visibility of the field. */ -/*ARGSUSED*/ debug_field -debug_make_field (handle, name, type, bitpos, bitsize, visibility) - PTR handle; - const char *name; - debug_type type; - bfd_vma bitpos; - bfd_vma bitsize; - enum debug_visibility visibility; +debug_make_field (void *handle ATTRIBUTE_UNUSED, const char *name, + debug_type type, bfd_vma bitpos, bfd_vma bitsize, + enum debug_visibility visibility) { struct debug_field *f; @@ -1805,7 +1715,7 @@ debug_make_field (handle, name, type, bitpos, bitsize, visibility) f->name = name; f->type = type; - f->static_member = false; + f->static_member = FALSE; f->u.f.bitpos = bitpos; f->u.f.bitsize = bitsize; f->visibility = visibility; @@ -1819,14 +1729,10 @@ debug_make_field (handle, name, type, bitpos, bitsize, visibility) global variable). The fifth argument is the visibility of the member. */ -/*ARGSUSED*/ debug_field -debug_make_static_member (handle, name, type, physname, visibility) - PTR handle; - const char *name; - debug_type type; - const char *physname; - enum debug_visibility visibility; +debug_make_static_member (void *handle ATTRIBUTE_UNUSED, const char *name, + debug_type type, const char *physname, + enum debug_visibility visibility) { struct debug_field *f; @@ -1835,7 +1741,7 @@ debug_make_static_member (handle, name, type, physname, visibility) f->name = name; f->type = type; - f->static_member = true; + f->static_member = TRUE; f->u.s.physname = physname; f->visibility = visibility; @@ -1845,12 +1751,9 @@ debug_make_static_member (handle, name, type, physname, visibility) /* Make a method. The second argument is the name, and the third argument is a NULL terminated array of method variants. */ -/*ARGSUSED*/ debug_method -debug_make_method (handle, name, variants) - PTR handle; - const char *name; - debug_method_variant *variants; +debug_make_method (void *handle ATTRIBUTE_UNUSED, const char *name, + debug_method_variant *variants) { struct debug_method *m; @@ -1872,18 +1775,12 @@ debug_make_method (handle, name, variants) function context. FIXME: Are the const and volatile arguments necessary? Could we just use debug_make_const_type? */ -/*ARGSUSED*/ debug_method_variant -debug_make_method_variant (handle, physname, type, visibility, constp, - volatilep, voffset, context) - PTR handle; - const char *physname; - debug_type type; - enum debug_visibility visibility; - boolean constp; - boolean volatilep; - bfd_vma voffset; - debug_type context; +debug_make_method_variant (void *handle ATTRIBUTE_UNUSED, + const char *physname, debug_type type, + enum debug_visibility visibility, + bfd_boolean constp, bfd_boolean volatilep, + bfd_vma voffset, debug_type context) { struct debug_method_variant *m; @@ -1906,14 +1803,10 @@ debug_make_method_variant (handle, physname, type, visibility, constp, since a static method can not also be virtual. */ debug_method_variant -debug_make_static_method_variant (handle, physname, type, visibility, - constp, volatilep) - PTR handle; - const char *physname; - debug_type type; - enum debug_visibility visibility; - boolean constp; - boolean volatilep; +debug_make_static_method_variant (void *handle ATTRIBUTE_UNUSED, + const char *physname, debug_type type, + enum debug_visibility visibility, + bfd_boolean constp, bfd_boolean volatilep) { struct debug_method_variant *m; @@ -1933,10 +1826,7 @@ debug_make_static_method_variant (handle, physname, type, visibility, /* Name a type. */ debug_type -debug_name_type (handle, name, type) - PTR handle; - const char *name; - debug_type type; +debug_name_type (void *handle, const char *name, debug_type type) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1949,8 +1839,8 @@ debug_name_type (handle, name, type) if (info->current_unit == NULL || info->current_file == NULL) { - debug_error ("debug_record_variable: no current file"); - return false; + debug_error (_("debug_name_type: no current file")); + return DEBUG_TYPE_NULL; } t = debug_make_type (info, DEBUG_KIND_NAMED, 0); @@ -1970,7 +1860,7 @@ debug_name_type (handle, name, type) nm = debug_add_to_namespace (info, &info->current_file->globals, name, DEBUG_OBJECT_TYPE, DEBUG_LINKAGE_NONE); if (nm == NULL) - return false; + return DEBUG_TYPE_NULL; nm->u.type = t; @@ -1982,10 +1872,7 @@ debug_name_type (handle, name, type) /* Tag a type. */ debug_type -debug_tag_type (handle, name, type) - PTR handle; - const char *name; - debug_type type; +debug_tag_type (void *handle, const char *name, debug_type type) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_type *t; @@ -1997,7 +1884,7 @@ debug_tag_type (handle, name, type) if (info->current_file == NULL) { - debug_error ("debug_tag_type: no current file"); + debug_error (_("debug_tag_type: no current file")); return DEBUG_TYPE_NULL; } @@ -2005,7 +1892,7 @@ debug_tag_type (handle, name, type) { if (strcmp (type->u.knamed->name->name, name) == 0) return type; - debug_error ("debug_tag_type: extra tag attempted"); + debug_error (_("debug_tag_type: extra tag attempted")); return DEBUG_TYPE_NULL; } @@ -2026,7 +1913,7 @@ debug_tag_type (handle, name, type) nm = debug_add_to_namespace (info, &info->current_file->globals, name, DEBUG_OBJECT_TAG, DEBUG_LINKAGE_NONE); if (nm == NULL) - return false; + return DEBUG_TYPE_NULL; nm->u.tag = t; @@ -2037,28 +1924,23 @@ debug_tag_type (handle, name, type) /* Record the size of a given type. */ -/*ARGSUSED*/ -boolean -debug_record_type_size (handle, type, size) - PTR handle; - debug_type type; - unsigned int size; +bfd_boolean +debug_record_type_size (void *handle ATTRIBUTE_UNUSED, debug_type type, + unsigned int size) { if (type->size != 0 && type->size != size) - fprintf (stderr, "Warning: changing type size from %d to %d\n", + fprintf (stderr, _("Warning: changing type size from %d to %d\n"), type->size, size); type->size = size; - return true; + return TRUE; } /* Find a named type. */ debug_type -debug_find_named_type (handle, name) - PTR handle; - const char *name; +debug_find_named_type (void *handle, const char *name) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_block *b; @@ -2069,7 +1951,7 @@ debug_find_named_type (handle, name) if (info->current_unit == NULL) { - debug_error ("debug_find_named_type: no current compilation unit"); + debug_error (_("debug_find_named_type: no current compilation unit")); return DEBUG_TYPE_NULL; } @@ -2105,16 +1987,14 @@ debug_find_named_type (handle, name) } } - return DEBUG_TYPE_NULL; + return DEBUG_TYPE_NULL; } /* Find a tagged type. */ debug_type -debug_find_tagged_type (handle, name, kind) - PTR handle; - const char *name; - enum debug_type_kind kind; +debug_find_tagged_type (void *handle, const char *name, + enum debug_type_kind kind) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_unit *u; @@ -2148,24 +2028,52 @@ debug_find_tagged_type (handle, name, kind) return DEBUG_TYPE_NULL; } -/* Get a base type. */ +/* Get a base type. We build a linked list on the stack to avoid + crashing if the type is defined circularly. */ static struct debug_type * -debug_get_real_type (handle, type) - PTR handle; - debug_type type; +debug_get_real_type (void *handle, debug_type type, + struct debug_type_real_list *list) { + struct debug_type_real_list *l; + struct debug_type_real_list rl; + switch (type->kind) { default: return type; + + case DEBUG_KIND_INDIRECT: + case DEBUG_KIND_NAMED: + case DEBUG_KIND_TAGGED: + break; + } + + for (l = list; l != NULL; l = l->next) + { + if (l->t == type || l == l->next) + { + fprintf (stderr, + _("debug_get_real_type: circular debug information for %s\n"), + debug_get_type_name (handle, type)); + return NULL; + } + } + + rl.next = list; + rl.t = type; + + switch (type->kind) + { + /* The default case is just here to avoid warnings. */ + default: case DEBUG_KIND_INDIRECT: if (*type->u.kindirect->slot != NULL) - return debug_get_real_type (handle, *type->u.kindirect->slot); + return debug_get_real_type (handle, *type->u.kindirect->slot, &rl); return type; case DEBUG_KIND_NAMED: case DEBUG_KIND_TAGGED: - return debug_get_real_type (handle, type->u.knamed->type); + return debug_get_real_type (handle, type->u.knamed->type, &rl); } /*NOTREACHED*/ } @@ -2173,22 +2081,20 @@ debug_get_real_type (handle, type) /* Get the kind of a type. */ enum debug_type_kind -debug_get_type_kind (handle, type) - PTR handle; - debug_type type; +debug_get_type_kind (void *handle, debug_type type) { if (type == NULL) return DEBUG_KIND_ILLEGAL; - type = debug_get_real_type (handle, type); + type = debug_get_real_type (handle, type, NULL); + if (type == NULL) + return DEBUG_KIND_ILLEGAL; return type->kind; } /* Get the name of a type. */ const char * -debug_get_type_name (handle, type) - PTR handle; - debug_type type; +debug_get_type_name (void *handle, debug_type type) { if (type->kind == DEBUG_KIND_INDIRECT) { @@ -2205,9 +2111,7 @@ debug_get_type_name (handle, type) /* Get the size of a type. */ bfd_vma -debug_get_type_size (handle, type) - PTR handle; - debug_type type; +debug_get_type_size (void *handle, debug_type type) { if (type == NULL) return 0; @@ -2236,13 +2140,15 @@ debug_get_type_size (handle, type) /* Get the return type of a function or method type. */ debug_type -debug_get_return_type (handle, type) - PTR handle; - debug_type type; +debug_get_return_type (void *handle, debug_type type) { if (type == NULL) return DEBUG_TYPE_NULL; - type = debug_get_real_type (handle, type); + + type = debug_get_real_type (handle, type, NULL); + if (type == NULL) + return DEBUG_TYPE_NULL; + switch (type->kind) { default: @@ -2252,21 +2158,23 @@ debug_get_return_type (handle, type) case DEBUG_KIND_METHOD: return type->u.kmethod->return_type; } - /*NOTREACHED*/ + /*NOTREACHED*/ } /* Get the parameter types of a function or method type (except that we don't currently store the parameter types of a function). */ const debug_type * -debug_get_parameter_types (handle, type, pvarargs) - PTR handle; - debug_type type; - boolean *pvarargs; +debug_get_parameter_types (void *handle, debug_type type, + bfd_boolean *pvarargs) { if (type == NULL) return NULL; - type = debug_get_real_type (handle, type); + + type = debug_get_real_type (handle, type, NULL); + if (type == NULL) + return NULL; + switch (type->kind) { default: @@ -2284,13 +2192,15 @@ debug_get_parameter_types (handle, type, pvarargs) /* Get the target type of a type. */ debug_type -debug_get_target_type (handle, type) - PTR handle; - debug_type type; +debug_get_target_type (void *handle, debug_type type) { if (type == NULL) return NULL; - type = debug_get_real_type (handle, type); + + type = debug_get_real_type (handle, type, NULL); + if (type == NULL) + return NULL; + switch (type->kind) { default: @@ -2311,13 +2221,15 @@ debug_get_target_type (handle, type) class. */ const debug_field * -debug_get_fields (handle, type) - PTR handle; - debug_type type; +debug_get_fields (void *handle, debug_type type) { if (type == NULL) return NULL; - type = debug_get_real_type (handle, type); + + type = debug_get_real_type (handle, type, NULL); + if (type == NULL) + return NULL; + switch (type->kind) { default: @@ -2333,11 +2245,8 @@ debug_get_fields (handle, type) /* Get the type of a field. */ -/*ARGSUSED*/ debug_type -debug_get_field_type (handle, field) - PTR handle; - debug_field field; +debug_get_field_type (void *handle ATTRIBUTE_UNUSED, debug_field field) { if (field == NULL) return NULL; @@ -2346,11 +2255,8 @@ debug_get_field_type (handle, field) /* Get the name of a field. */ -/*ARGSUSED*/ const char * -debug_get_field_name (handle, field) - PTR handle; - debug_field field; +debug_get_field_name (void *handle ATTRIBUTE_UNUSED, debug_field field) { if (field == NULL) return NULL; @@ -2359,11 +2265,8 @@ debug_get_field_name (handle, field) /* Get the bit position of a field. */ -/*ARGSUSED*/ bfd_vma -debug_get_field_bitpos (handle, field) - PTR handle; - debug_field field; +debug_get_field_bitpos (void *handle ATTRIBUTE_UNUSED, debug_field field) { if (field == NULL || field->static_member) return (bfd_vma) -1; @@ -2372,11 +2275,8 @@ debug_get_field_bitpos (handle, field) /* Get the bit size of a field. */ -/*ARGSUSED*/ bfd_vma -debug_get_field_bitsize (handle, field) - PTR handle; - debug_field field; +debug_get_field_bitsize (void *handle ATTRIBUTE_UNUSED, debug_field field) { if (field == NULL || field->static_member) return (bfd_vma) -1; @@ -2385,11 +2285,8 @@ debug_get_field_bitsize (handle, field) /* Get the visibility of a field. */ -/*ARGSUSED*/ enum debug_visibility -debug_get_field_visibility (handle, field) - PTR handle; - debug_field field; +debug_get_field_visibility (void *handle ATTRIBUTE_UNUSED, debug_field field) { if (field == NULL) return DEBUG_VISIBILITY_IGNORE; @@ -2399,9 +2296,7 @@ debug_get_field_visibility (handle, field) /* Get the physical name of a field. */ const char * -debug_get_field_physname (handle, field) - PTR handle; - debug_field field; +debug_get_field_physname (void *handle ATTRIBUTE_UNUSED, debug_field field) { if (field == NULL || ! field->static_member) return NULL; @@ -2411,11 +2306,8 @@ debug_get_field_physname (handle, field) /* Write out the debugging information. This is given a handle to debugging information, and a set of function pointers to call. */ -boolean -debug_write (handle, fns, fhandle) - PTR handle; - const struct debug_write_fns *fns; - PTR fhandle; +bfd_boolean +debug_write (void *handle, const struct debug_write_fns *fns, void *fhandle) { struct debug_handle *info = (struct debug_handle *) handle; struct debug_unit *u; @@ -2438,77 +2330,61 @@ debug_write (handle, fns, fhandle) for (u = info->units; u != NULL; u = u->next) { struct debug_file *f; - boolean first_file; - struct debug_lineno *l; + bfd_boolean first_file; + + info->current_write_lineno = u->linenos; + info->current_write_lineno_index = 0; if (! (*fns->start_compilation_unit) (fhandle, u->files->filename)) - return false; + return FALSE; - first_file = true; + first_file = TRUE; for (f = u->files; f != NULL; f = f->next) { struct debug_name *n; if (first_file) - first_file = false; - else - { - if (! (*fns->start_source) (fhandle, f->filename)) - return false; - } + first_file = FALSE; + else if (! (*fns->start_source) (fhandle, f->filename)) + return FALSE; if (f->globals != NULL) - { - for (n = f->globals->list; n != NULL; n = n->next) - { - if (! debug_write_name (info, fns, fhandle, n)) - return false; - } - } + for (n = f->globals->list; n != NULL; n = n->next) + if (! debug_write_name (info, fns, fhandle, n)) + return FALSE; } - for (l = u->linenos; l != NULL; l = l->next) - { - unsigned int i; - - for (i = 0; i < DEBUG_LINENO_COUNT; i++) - { - if (l->linenos[i] == (unsigned long) -1) - break; - if (! (*fns->lineno) (fhandle, l->file->filename, l->linenos[i], - l->addrs[i])) - return false; - } - } + /* Output any line number information which hasn't already been + handled. */ + if (! debug_write_linenos (info, fns, fhandle, (bfd_vma) -1)) + return FALSE; } - return true; + return TRUE; } /* Write out an element in a namespace. */ -static boolean -debug_write_name (info, fns, fhandle, n) - struct debug_handle *info; - const struct debug_write_fns *fns; - PTR fhandle; - struct debug_name *n; +static bfd_boolean +debug_write_name (struct debug_handle *info, + const struct debug_write_fns *fns, void *fhandle, + struct debug_name *n) { switch (n->kind) { case DEBUG_OBJECT_TYPE: if (! debug_write_type (info, fns, fhandle, n->u.type, n) || ! (*fns->typdef) (fhandle, n->name)) - return false; - return true; + return FALSE; + return TRUE; case DEBUG_OBJECT_TAG: if (! debug_write_type (info, fns, fhandle, n->u.tag, n)) - return false; + return FALSE; return (*fns->tag) (fhandle, n->name); case DEBUG_OBJECT_VARIABLE: if (! debug_write_type (info, fns, fhandle, n->u.variable->type, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->variable) (fhandle, n->name, n->u.variable->kind, n->u.variable->val); case DEBUG_OBJECT_FUNCTION: @@ -2521,12 +2397,12 @@ debug_write_name (info, fns, fhandle, n) case DEBUG_OBJECT_TYPED_CONSTANT: if (! debug_write_type (info, fns, fhandle, n->u.typed_constant->type, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->typed_constant) (fhandle, n->name, n->u.typed_constant->val); default: abort (); - return false; + return FALSE; } /*NOTREACHED*/ } @@ -2537,17 +2413,14 @@ debug_write_name (info, fns, fhandle, n) then the name argument is a tag from a DEBUG_KIND_TAGGED type which points to this one. */ -static boolean -debug_write_type (info, fns, fhandle, type, name) - struct debug_handle *info; - const struct debug_write_fns *fns; - PTR fhandle; - struct debug_type *type; - struct debug_name *name; +static bfd_boolean +debug_write_type (struct debug_handle *info, + const struct debug_write_fns *fns, void *fhandle, + struct debug_type *type, struct debug_name *name) { unsigned int i; int is; - const char *tag; + const char *tag = NULL; /* If we have a name for this type, just output it. We only output typedef names after they have been defined. We output type tags @@ -2565,7 +2438,9 @@ debug_write_type (info, fns, fhandle, type, name) struct debug_type *real; unsigned int id; - real = debug_get_real_type ((PTR) info, type); + real = debug_get_real_type ((void *) info, type, NULL); + if (real == NULL) + return (*fns->empty_type) (fhandle); id = 0; if ((real->kind == DEBUG_KIND_STRUCT || real->kind == DEBUG_KIND_UNION @@ -2578,7 +2453,7 @@ debug_write_type (info, fns, fhandle, type, name) if (! debug_set_class_id (info, type->u.knamed->name->name, real)) - return false; + return FALSE; } id = real->u.kclass->id; } @@ -2595,7 +2470,6 @@ debug_write_type (info, fns, fhandle, type, name) if (name != NULL) name->mark = info->mark; - tag = NULL; if (name != NULL && type->kind != DEBUG_KIND_NAMED && type->kind != DEBUG_KIND_TAGGED) @@ -2607,8 +2481,8 @@ debug_write_type (info, fns, fhandle, type, name) switch (type->kind) { case DEBUG_KIND_ILLEGAL: - debug_error ("debug_write_type: illegal type encountered"); - return false; + debug_error (_("debug_write_type: illegal type encountered")); + return FALSE; case DEBUG_KIND_INDIRECT: if (*type->u.kindirect->slot == DEBUG_TYPE_NULL) return (*fns->empty_type) (fhandle); @@ -2631,7 +2505,7 @@ debug_write_type (info, fns, fhandle, type, name) if (type->u.kclass->id <= info->base_id) { if (! debug_set_class_id (info, tag, type)) - return false; + return FALSE; } if (info->mark == type->u.kclass->mark) @@ -2652,7 +2526,7 @@ debug_write_type (info, fns, fhandle, type, name) : 0), type->kind == DEBUG_KIND_STRUCT, type->size)) - return false; + return FALSE; if (type->u.kclass != NULL && type->u.kclass->fields != NULL) { @@ -2665,7 +2539,7 @@ debug_write_type (info, fns, fhandle, type, name) (struct debug_name *) NULL) || ! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos, f->u.f.bitsize, f->visibility)) - return false; + return FALSE; } } return (*fns->end_struct_type) (fhandle); @@ -2681,9 +2555,13 @@ debug_write_type (info, fns, fhandle, type, name) case DEBUG_KIND_POINTER: if (! debug_write_type (info, fns, fhandle, type->u.kpointer, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->pointer_type) (fhandle); case DEBUG_KIND_FUNCTION: + if (! debug_write_type (info, fns, fhandle, + type->u.kfunction->return_type, + (struct debug_name *) NULL)) + return FALSE; if (type->u.kfunction->arg_types == NULL) is = -1; else @@ -2692,23 +2570,19 @@ debug_write_type (info, fns, fhandle, type, name) if (! debug_write_type (info, fns, fhandle, type->u.kfunction->arg_types[is], (struct debug_name *) NULL)) - return false; + return FALSE; } - if (! debug_write_type (info, fns, fhandle, - type->u.kfunction->return_type, - (struct debug_name *) NULL)) - return false; return (*fns->function_type) (fhandle, is, type->u.kfunction->varargs); case DEBUG_KIND_REFERENCE: if (! debug_write_type (info, fns, fhandle, type->u.kreference, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->reference_type) (fhandle); case DEBUG_KIND_RANGE: if (! debug_write_type (info, fns, fhandle, type->u.krange->type, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->range_type) (fhandle, type->u.krange->lower, type->u.krange->upper); case DEBUG_KIND_ARRAY: @@ -2717,14 +2591,14 @@ debug_write_type (info, fns, fhandle, type, name) || ! debug_write_type (info, fns, fhandle, type->u.karray->range_type, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->array_type) (fhandle, type->u.karray->lower, type->u.karray->upper, type->u.karray->stringp); case DEBUG_KIND_SET: if (! debug_write_type (info, fns, fhandle, type->u.kset->type, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->set_type) (fhandle, type->u.kset->bitstringp); case DEBUG_KIND_OFFSET: if (! debug_write_type (info, fns, fhandle, type->u.koffset->base_type, @@ -2732,13 +2606,13 @@ debug_write_type (info, fns, fhandle, type, name) || ! debug_write_type (info, fns, fhandle, type->u.koffset->target_type, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->offset_type) (fhandle); case DEBUG_KIND_METHOD: if (! debug_write_type (info, fns, fhandle, type->u.kmethod->return_type, (struct debug_name *) NULL)) - return false; + return FALSE; if (type->u.kmethod->arg_types == NULL) is = -1; else @@ -2747,14 +2621,14 @@ debug_write_type (info, fns, fhandle, type, name) if (! debug_write_type (info, fns, fhandle, type->u.kmethod->arg_types[is], (struct debug_name *) NULL)) - return false; + return FALSE; } if (type->u.kmethod->domain_type != NULL) { if (! debug_write_type (info, fns, fhandle, type->u.kmethod->domain_type, (struct debug_name *) NULL)) - return false; + return FALSE; } return (*fns->method_type) (fhandle, type->u.kmethod->domain_type != NULL, @@ -2763,12 +2637,12 @@ debug_write_type (info, fns, fhandle, type, name) case DEBUG_KIND_CONST: if (! debug_write_type (info, fns, fhandle, type->u.kconst, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->const_type) (fhandle); case DEBUG_KIND_VOLATILE: if (! debug_write_type (info, fns, fhandle, type->u.kvolatile, (struct debug_name *) NULL)) - return false; + return FALSE; return (*fns->volatile_type) (fhandle); case DEBUG_KIND_NAMED: return debug_write_type (info, fns, fhandle, type->u.knamed->type, @@ -2778,19 +2652,16 @@ debug_write_type (info, fns, fhandle, type, name) type->u.knamed->name); default: abort (); - return false; + return FALSE; } } /* Write out a class type. */ -static boolean -debug_write_class_type (info, fns, fhandle, type, tag) - struct debug_handle *info; - const struct debug_write_fns *fns; - PTR fhandle; - struct debug_type *type; - const char *tag; +static bfd_boolean +debug_write_class_type (struct debug_handle *info, + const struct debug_write_fns *fns, void *fhandle, + struct debug_type *type, const char *tag) { unsigned int i; unsigned int id; @@ -2806,7 +2677,7 @@ debug_write_class_type (info, fns, fhandle, type, tag) if (type->u.kclass->id <= info->base_id) { if (! debug_set_class_id (info, tag, type)) - return false; + return FALSE; } if (info->mark == type->u.kclass->mark) @@ -2826,7 +2697,7 @@ debug_write_class_type (info, fns, fhandle, type, tag) { if (! debug_write_type (info, fns, fhandle, vptrbase, (struct debug_name *) NULL)) - return false; + return FALSE; } } @@ -2835,7 +2706,7 @@ debug_write_class_type (info, fns, fhandle, type, tag) type->size, vptrbase != NULL, vptrbase == type)) - return false; + return FALSE; if (type->u.kclass != NULL) { @@ -2848,19 +2719,19 @@ debug_write_class_type (info, fns, fhandle, type, tag) f = type->u.kclass->fields[i]; if (! debug_write_type (info, fns, fhandle, f->type, (struct debug_name *) NULL)) - return false; + return FALSE; if (f->static_member) { if (! (*fns->class_static_member) (fhandle, f->name, f->u.s.physname, f->visibility)) - return false; + return FALSE; } else { if (! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos, f->u.f.bitsize, f->visibility)) - return false; + return FALSE; } } } @@ -2874,10 +2745,10 @@ debug_write_class_type (info, fns, fhandle, type, tag) b = type->u.kclass->baseclasses[i]; if (! debug_write_type (info, fns, fhandle, b->type, (struct debug_name *) NULL)) - return false; + return FALSE; if (! (*fns->class_baseclass) (fhandle, b->bitpos, b->virtual, b->visibility)) - return false; + return FALSE; } } @@ -2890,7 +2761,7 @@ debug_write_class_type (info, fns, fhandle, type, tag) m = type->u.kclass->methods[i]; if (! (*fns->class_start_method) (fhandle, m->name)) - return false; + return FALSE; for (j = 0; m->variants[j] != NULL; j++) { struct debug_method_variant *v; @@ -2900,11 +2771,11 @@ debug_write_class_type (info, fns, fhandle, type, tag) { if (! debug_write_type (info, fns, fhandle, v->context, (struct debug_name *) NULL)) - return false; + return FALSE; } if (! debug_write_type (info, fns, fhandle, v->type, (struct debug_name *) NULL)) - return false; + return FALSE; if (v->voffset != VOFFSET_STATIC_METHOD) { if (! (*fns->class_method_variant) (fhandle, v->physname, @@ -2913,7 +2784,7 @@ debug_write_class_type (info, fns, fhandle, type, tag) v->volatilep, v->voffset, v->context != NULL)) - return false; + return FALSE; } else { @@ -2922,11 +2793,11 @@ debug_write_class_type (info, fns, fhandle, type, tag) v->visibility, v->constp, v->volatilep)) - return false; + return FALSE; } } if (! (*fns->class_end_method) (fhandle)) - return false; + return FALSE; } } } @@ -2936,38 +2807,38 @@ debug_write_class_type (info, fns, fhandle, type, tag) /* Write out information for a function. */ -static boolean -debug_write_function (info, fns, fhandle, name, linkage, function) - struct debug_handle *info; - const struct debug_write_fns *fns; - PTR fhandle; - const char *name; - enum debug_object_linkage linkage; - struct debug_function *function; +static bfd_boolean +debug_write_function (struct debug_handle *info, + const struct debug_write_fns *fns, void *fhandle, + const char *name, enum debug_object_linkage linkage, + struct debug_function *function) { struct debug_parameter *p; struct debug_block *b; + if (! debug_write_linenos (info, fns, fhandle, function->blocks->start)) + return FALSE; + if (! debug_write_type (info, fns, fhandle, function->return_type, (struct debug_name *) NULL)) - return false; + return FALSE; if (! (*fns->start_function) (fhandle, name, linkage == DEBUG_LINKAGE_GLOBAL)) - return false; + return FALSE; for (p = function->parameters; p != NULL; p = p->next) { if (! debug_write_type (info, fns, fhandle, p->type, (struct debug_name *) NULL) || ! (*fns->function_parameter) (fhandle, p->name, p->kind, p->val)) - return false; + return FALSE; } for (b = function->blocks; b != NULL; b = b->next) { if (! debug_write_block (info, fns, fhandle, b)) - return false; + return FALSE; } return (*fns->end_function) (fhandle); @@ -2975,22 +2846,23 @@ debug_write_function (info, fns, fhandle, name, linkage, function) /* Write out information for a block. */ -static boolean -debug_write_block (info, fns, fhandle, block) - struct debug_handle *info; - const struct debug_write_fns *fns; - PTR fhandle; - struct debug_block *block; +static bfd_boolean +debug_write_block (struct debug_handle *info, + const struct debug_write_fns *fns, void *fhandle, + struct debug_block *block) { struct debug_name *n; struct debug_block *b; + if (! debug_write_linenos (info, fns, fhandle, block->start)) + return FALSE; + /* I can't see any point to writing out a block with no local variables, so we don't bother, except for the top level block. */ if (block->locals != NULL || block->parent == NULL) { if (! (*fns->start_block) (fhandle, block->start)) - return false; + return FALSE; } if (block->locals != NULL) @@ -2998,23 +2870,63 @@ debug_write_block (info, fns, fhandle, block) for (n = block->locals->list; n != NULL; n = n->next) { if (! debug_write_name (info, fns, fhandle, n)) - return false; + return FALSE; } } for (b = block->children; b != NULL; b = b->next) { if (! debug_write_block (info, fns, fhandle, b)) - return false; + return FALSE; } + if (! debug_write_linenos (info, fns, fhandle, block->end)) + return FALSE; + if (block->locals != NULL || block->parent == NULL) { if (! (*fns->end_block) (fhandle, block->end)) - return false; + return FALSE; } - return true; + return TRUE; +} + +/* Write out line number information up to ADDRESS. */ + +static bfd_boolean +debug_write_linenos (struct debug_handle *info, + const struct debug_write_fns *fns, void *fhandle, + bfd_vma address) +{ + while (info->current_write_lineno != NULL) + { + struct debug_lineno *l; + + l = info->current_write_lineno; + + while (info->current_write_lineno_index < DEBUG_LINENO_COUNT) + { + if (l->linenos[info->current_write_lineno_index] + == (unsigned long) -1) + break; + + if (l->addrs[info->current_write_lineno_index] >= address) + return TRUE; + + if (! (*fns->lineno) (fhandle, l->file->filename, + l->linenos[info->current_write_lineno_index], + l->addrs[info->current_write_lineno_index])) + return FALSE; + + ++info->current_write_lineno_index; + } + + info->current_write_lineno = l->next; + info->current_write_lineno_index = 0; + } + + return TRUE; } /* Get the ID number for a class. If during the same call to @@ -3022,11 +2934,9 @@ debug_write_block (info, fns, fhandle, block) name, we use the same ID. This type of things happens because the same struct will be defined by multiple compilation units. */ -static boolean -debug_set_class_id (info, tag, type) - struct debug_handle *info; - const char *tag; - struct debug_type *type; +static bfd_boolean +debug_set_class_id (struct debug_handle *info, const char *tag, + struct debug_type *type) { struct debug_class_type *c; struct debug_class_id *l; @@ -3039,7 +2949,7 @@ debug_set_class_id (info, tag, type) c = type->u.kclass; if (c->id > info->base_id) - return true; + return TRUE; for (l = info->id_list; l != NULL; l = l->next) { @@ -3062,7 +2972,7 @@ debug_set_class_id (info, tag, type) if (debug_type_samep (info, l->type, type)) { c->id = l->type->u.kclass->id; - return true; + return TRUE; } } @@ -3080,37 +2990,40 @@ debug_set_class_id (info, tag, type) l->next = info->id_list; info->id_list = l; - return true; + return TRUE; } /* See if two types are the same. At this point, we don't care about tags and the like. */ -static boolean -debug_type_samep (info, t1, t2) - struct debug_handle *info; - struct debug_type *t1; - struct debug_type *t2; +static bfd_boolean +debug_type_samep (struct debug_handle *info, struct debug_type *t1, + struct debug_type *t2) { struct debug_type_compare_list *l; struct debug_type_compare_list top; - boolean ret; + bfd_boolean ret; + + if (t1 == NULL) + return t2 == NULL; + if (t2 == NULL) + return FALSE; while (t1->kind == DEBUG_KIND_INDIRECT) { t1 = *t1->u.kindirect->slot; if (t1 == NULL) - return false; + return FALSE; } while (t2->kind == DEBUG_KIND_INDIRECT) { t2 = *t2->u.kindirect->slot; if (t2 == NULL) - return false; + return FALSE; } if (t1 == t2) - return true; + return TRUE; /* As a special case, permit a typedef to match a tag, since C++ debugging output will sometimes add a typedef where C debugging @@ -3124,7 +3037,7 @@ debug_type_samep (info, t1, t2) if (t1->kind != t2->kind || t1->size != t2->size) - return false; + return FALSE; /* Get rid of the trivial cases first. */ switch (t1->kind) @@ -3135,7 +3048,7 @@ debug_type_samep (info, t1, t2) case DEBUG_KIND_FLOAT: case DEBUG_KIND_COMPLEX: case DEBUG_KIND_BOOL: - return true; + return TRUE; case DEBUG_KIND_INT: return t1->u.kint == t2->u.kint; } @@ -3147,7 +3060,7 @@ debug_type_samep (info, t1, t2) for (l = info->compare_list; l != NULL; l = l->next) { if (l->t1 == t1 && l->t2 == t2) - return true; + return TRUE; } top.t1 = t1; @@ -3159,7 +3072,7 @@ debug_type_samep (info, t1, t2) { default: abort (); - ret = false; + ret = FALSE; break; case DEBUG_KIND_STRUCT: @@ -3169,10 +3082,10 @@ debug_type_samep (info, t1, t2) if (t1->u.kclass == NULL) ret = t2->u.kclass == NULL; else if (t2->u.kclass == NULL) - ret = false; + ret = FALSE; else if (t1->u.kclass->id > info->base_id && t1->u.kclass->id == t2->u.kclass->id) - ret = true; + ret = TRUE; else ret = debug_class_type_samep (info, t1, t2); break; @@ -3181,7 +3094,7 @@ debug_type_samep (info, t1, t2) if (t1->u.kenum == NULL) ret = t2->u.kenum == NULL; else if (t2->u.kenum == NULL) - ret = false; + ret = FALSE; else { const char **pn1, **pn2; @@ -3209,16 +3122,16 @@ debug_type_samep (info, t1, t2) case DEBUG_KIND_POINTER: ret = debug_type_samep (info, t1->u.kpointer, t2->u.kpointer); break; - + case DEBUG_KIND_FUNCTION: if (t1->u.kfunction->varargs != t2->u.kfunction->varargs || ! debug_type_samep (info, t1->u.kfunction->return_type, t2->u.kfunction->return_type) || ((t1->u.kfunction->arg_types == NULL) != (t2->u.kfunction->arg_types == NULL))) - ret = false; + ret = FALSE; else if (t1->u.kfunction->arg_types == NULL) - ret = true; + ret = TRUE; else { struct debug_type **a1, **a2; @@ -3226,8 +3139,12 @@ debug_type_samep (info, t1, t2) a1 = t1->u.kfunction->arg_types; a2 = t2->u.kfunction->arg_types; while (*a1 != NULL && *a2 != NULL) - if (! debug_type_samep (info, *a1, *a2)) - break; + { + if (! debug_type_samep (info, *a1, *a2)) + break; + ++a1; + ++a2; + } ret = *a1 == NULL && *a2 == NULL; } break; @@ -3270,9 +3187,9 @@ debug_type_samep (info, t1, t2) t2->u.kmethod->domain_type) || ((t1->u.kmethod->arg_types == NULL) != (t2->u.kmethod->arg_types == NULL))) - ret = false; + ret = FALSE; else if (t1->u.kmethod->arg_types == NULL) - ret = true; + ret = TRUE; else { struct debug_type **a1, **a2; @@ -3280,8 +3197,12 @@ debug_type_samep (info, t1, t2) a1 = t1->u.kmethod->arg_types; a2 = t2->u.kmethod->arg_types; while (*a1 != NULL && *a2 != NULL) - if (! debug_type_samep (info, *a1, *a2)) - break; + { + if (! debug_type_samep (info, *a1, *a2)) + break; + ++a1; + ++a2; + } ret = *a1 == NULL && *a2 == NULL; } break; @@ -3310,11 +3231,9 @@ debug_type_samep (info, t1, t2) /* See if two classes are the same. This is a subroutine of debug_type_samep. */ -static boolean -debug_class_type_samep (info, t1, t2) - struct debug_handle *info; - struct debug_type *t1; - struct debug_type *t2; +static bfd_boolean +debug_class_type_samep (struct debug_handle *info, struct debug_type *t1, + struct debug_type *t2) { struct debug_class_type *c1, *c2; @@ -3325,7 +3244,7 @@ debug_class_type_samep (info, t1, t2) || (c1->baseclasses == NULL) != (c2->baseclasses == NULL) || (c1->methods == NULL) != (c2->methods == NULL) || (c1->vptrbase == NULL) != (c2->vptrbase == NULL)) - return false; + return FALSE; if (c1->fields != NULL) { @@ -3342,17 +3261,17 @@ debug_class_type_samep (info, t1, t2) if (f1->name[0] != f2->name[0] || f1->visibility != f2->visibility || f1->static_member != f2->static_member) - return false; + return FALSE; if (f1->static_member) { if (strcmp (f1->u.s.physname, f2->u.s.physname) != 0) - return false; + return FALSE; } else { if (f1->u.f.bitpos != f2->u.f.bitpos || f1->u.f.bitsize != f2->u.f.bitsize) - return false; + return FALSE; } /* We do the checks which require function calls last. We don't require that the types of fields have the same @@ -3360,20 +3279,20 @@ debug_class_type_samep (info, t1, t2) typedefs and we really don't care. */ if (strcmp (f1->name, f2->name) != 0 || ! debug_type_samep (info, - debug_get_real_type ((PTR) info, - f1->type), - debug_get_real_type ((PTR) info, - f2->type))) - return false; + debug_get_real_type ((void *) info, + f1->type, NULL), + debug_get_real_type ((void *) info, + f2->type, NULL))) + return FALSE; } if (*pf1 != NULL || *pf2 != NULL) - return false; + return FALSE; } if (c1->vptrbase != NULL) { if (! debug_type_samep (info, c1->vptrbase, c2->vptrbase)) - return false; + return FALSE; } if (c1->baseclasses != NULL) @@ -3392,10 +3311,10 @@ debug_class_type_samep (info, t1, t2) || b1->virtual != b2->virtual || b1->visibility != b2->visibility || ! debug_type_samep (info, b1->type, b2->type)) - return false; + return FALSE; } if (*pb1 != NULL || *pb2 != NULL) - return false; + return FALSE; } if (c1->methods != NULL) @@ -3413,7 +3332,7 @@ debug_class_type_samep (info, t1, t2) if (m1->name[0] != m2->name[0] || strcmp (m1->name, m2->name) != 0 || (m1->variants == NULL) != (m2->variants == NULL)) - return false; + return FALSE; if (m1->variants == NULL) { struct debug_method_variant **pv1, **pv2; @@ -3434,21 +3353,21 @@ debug_class_type_samep (info, t1, t2) || (v1->context == NULL) != (v2->context == NULL) || strcmp (v1->physname, v2->physname) != 0 || ! debug_type_samep (info, v1->type, v2->type)) - return false; + return FALSE; if (v1->context != NULL) { if (! debug_type_samep (info, v1->context, v2->context)) - return false; + return FALSE; } } if (*pv1 != NULL || *pv2 != NULL) - return false; + return FALSE; } } if (*pm1 != NULL || *pm2 != NULL) - return false; + return FALSE; } - return true; + return TRUE; }