X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=binutils%2Fwrstabs.c;h=3e941dcefd5816fa3a54ce9fe4fb8544b06d0a6a;hb=260bcd09bfb98ebc5d8f0eb564edca21872e9f7f;hp=c74af2ee72abbc9c2be9cb55aa884e687e5c0461;hpb=d0352a18a504a4e7b761f6b3264cf11347d8d056;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/wrstabs.c b/binutils/wrstabs.c index c74af2ee72..3e941dcefd 100644 --- a/binutils/wrstabs.c +++ b/binutils/wrstabs.c @@ -1,12 +1,12 @@ /* wrstabs.c -- Output stabs debugging information - Copyright (C) 1996, 97, 98, 99, 2000 Free Software Foundation, Inc. + Copyright (C) 1996-2019 Free Software Foundation, Inc. Written by Ian Lance Taylor . This file is part of GNU Binutils. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,25 +16,21 @@ 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 contains code which writes out stabs debugging information. */ -#include -#include +#include "sysdep.h" #include - #include "bfd.h" -#include "bucomm.h" #include "libiberty.h" +#include "filenames.h" +#include "safe-ctype.h" +#include "bucomm.h" #include "debug.h" #include "budbg.h" - -/* Meaningless definition needs by aout64.h. FIXME. */ -#define BYTES_IN_WORD 4 - #include "aout/aout64.h" #include "aout/stab_gnu.h" @@ -75,7 +71,7 @@ struct stab_type_stack /* The size of the type. */ unsigned int size; /* Whether type string defines a new type. */ - boolean definition; + bfd_boolean definition; /* String defining struct fields. */ char *fields; /* NULL terminated array of strings defining base classes for a @@ -176,83 +172,80 @@ struct stab_write_handle }; static struct bfd_hash_entry *string_hash_newfunc - PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); -static boolean stab_write_symbol - PARAMS ((struct stab_write_handle *, int, int, bfd_vma, const char *)); -static boolean stab_push_string - PARAMS ((struct stab_write_handle *, const char *, long, boolean, - unsigned int)); -static boolean stab_push_defined_type - PARAMS ((struct stab_write_handle *, long, unsigned int)); -static char *stab_pop_type PARAMS ((struct stab_write_handle *)); -static boolean stab_modify_type - PARAMS ((struct stab_write_handle *, int, unsigned int, long **, size_t *)); + (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); +static bfd_boolean stab_write_symbol + (struct stab_write_handle *, int, int, bfd_vma, const char *); +static bfd_boolean stab_push_string + (struct stab_write_handle *, const char *, long, bfd_boolean, unsigned int); +static bfd_boolean stab_push_defined_type + (struct stab_write_handle *, long, unsigned int); +static char *stab_pop_type (struct stab_write_handle *); +static bfd_boolean stab_modify_type + (struct stab_write_handle *, int, unsigned int, long **, size_t *); static long stab_get_struct_index - PARAMS ((struct stab_write_handle *, const char *, unsigned int, - enum debug_type_kind, unsigned int *)); -static boolean stab_class_method_var - PARAMS ((struct stab_write_handle *, const char *, enum debug_visibility, - boolean, boolean, boolean, bfd_vma, boolean)); - -static boolean stab_start_compilation_unit PARAMS ((PTR, const char *)); -static boolean stab_start_source PARAMS ((PTR, const char *)); -static boolean stab_empty_type PARAMS ((PTR)); -static boolean stab_void_type PARAMS ((PTR)); -static boolean stab_int_type PARAMS ((PTR, unsigned int, boolean)); -static boolean stab_float_type PARAMS ((PTR, unsigned int)); -static boolean stab_complex_type PARAMS ((PTR, unsigned int)); -static boolean stab_bool_type PARAMS ((PTR, unsigned int)); -static boolean stab_enum_type - PARAMS ((PTR, const char *, const char **, bfd_signed_vma *)); -static boolean stab_pointer_type PARAMS ((PTR)); -static boolean stab_function_type PARAMS ((PTR, int, boolean)); -static boolean stab_reference_type PARAMS ((PTR)); -static boolean stab_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma)); -static boolean stab_array_type - PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean)); -static boolean stab_set_type PARAMS ((PTR, boolean)); -static boolean stab_offset_type PARAMS ((PTR)); -static boolean stab_method_type PARAMS ((PTR, boolean, int, boolean)); -static boolean stab_const_type PARAMS ((PTR)); -static boolean stab_volatile_type PARAMS ((PTR)); -static boolean stab_start_struct_type - PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int)); -static boolean stab_struct_field - PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility)); -static boolean stab_end_struct_type PARAMS ((PTR)); -static boolean stab_start_class_type - PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean, - boolean)); -static boolean stab_class_static_member - PARAMS ((PTR, const char *, const char *, enum debug_visibility)); -static boolean stab_class_baseclass - PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility)); -static boolean stab_class_start_method PARAMS ((PTR, const char *)); -static boolean stab_class_method_variant - PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean, - bfd_vma, boolean)); -static boolean stab_class_static_method_variant - PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean)); -static boolean stab_class_end_method PARAMS ((PTR)); -static boolean stab_end_class_type PARAMS ((PTR)); -static boolean stab_typedef_type PARAMS ((PTR, const char *)); -static boolean stab_tag_type - PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind)); -static boolean stab_typdef PARAMS ((PTR, const char *)); -static boolean stab_tag PARAMS ((PTR, const char *)); -static boolean stab_int_constant PARAMS ((PTR, const char *, bfd_vma)); -static boolean stab_float_constant PARAMS ((PTR, const char *, double)); -static boolean stab_typed_constant PARAMS ((PTR, const char *, bfd_vma)); -static boolean stab_variable - PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma)); -static boolean stab_start_function PARAMS ((PTR, const char *, boolean)); -static boolean stab_function_parameter - PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma)); -static boolean stab_start_block PARAMS ((PTR, bfd_vma)); -static boolean stab_end_block PARAMS ((PTR, bfd_vma)); -static boolean stab_end_function PARAMS ((PTR)); -static boolean stab_lineno - PARAMS ((PTR, const char *, unsigned long, bfd_vma)); + (struct stab_write_handle *, const char *, unsigned int, + enum debug_type_kind, unsigned int *); +static bfd_boolean stab_class_method_var + (struct stab_write_handle *, const char *, enum debug_visibility, + bfd_boolean, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean); +static bfd_boolean stab_start_compilation_unit (void *, const char *); +static bfd_boolean stab_start_source (void *, const char *); +static bfd_boolean stab_empty_type (void *); +static bfd_boolean stab_void_type (void *); +static bfd_boolean stab_int_type (void *, unsigned int, bfd_boolean); +static bfd_boolean stab_float_type (void *, unsigned int); +static bfd_boolean stab_complex_type (void *, unsigned int); +static bfd_boolean stab_bool_type (void *, unsigned int); +static bfd_boolean stab_enum_type + (void *, const char *, const char **, bfd_signed_vma *); +static bfd_boolean stab_pointer_type (void *); +static bfd_boolean stab_function_type (void *, int, bfd_boolean); +static bfd_boolean stab_reference_type (void *); +static bfd_boolean stab_range_type (void *, bfd_signed_vma, bfd_signed_vma); +static bfd_boolean stab_array_type + (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean); +static bfd_boolean stab_set_type (void *, bfd_boolean); +static bfd_boolean stab_offset_type (void *); +static bfd_boolean stab_method_type (void *, bfd_boolean, int, bfd_boolean); +static bfd_boolean stab_const_type (void *); +static bfd_boolean stab_volatile_type (void *); +static bfd_boolean stab_start_struct_type + (void *, const char *, unsigned int, bfd_boolean, unsigned int); +static bfd_boolean stab_struct_field + (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility); +static bfd_boolean stab_end_struct_type (void *); +static bfd_boolean stab_start_class_type + (void *, const char *, unsigned int, bfd_boolean, unsigned int, + bfd_boolean, bfd_boolean); +static bfd_boolean stab_class_static_member + (void *, const char *, const char *, enum debug_visibility); +static bfd_boolean stab_class_baseclass + (void *, bfd_vma, bfd_boolean, enum debug_visibility); +static bfd_boolean stab_class_start_method (void *, const char *); +static bfd_boolean stab_class_method_variant + (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, + bfd_vma, bfd_boolean); +static bfd_boolean stab_class_static_method_variant + (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean); +static bfd_boolean stab_class_end_method (void *); +static bfd_boolean stab_end_class_type (void *); +static bfd_boolean stab_typedef_type (void *, const char *); +static bfd_boolean stab_tag_type + (void *, const char *, unsigned int, enum debug_type_kind); +static bfd_boolean stab_typdef (void *, const char *); +static bfd_boolean stab_tag (void *, const char *); +static bfd_boolean stab_int_constant (void *, const char *, bfd_vma); +static bfd_boolean stab_float_constant (void *, const char *, double); +static bfd_boolean stab_typed_constant (void *, const char *, bfd_vma); +static bfd_boolean stab_variable + (void *, const char *, enum debug_var_kind, bfd_vma); +static bfd_boolean stab_start_function (void *, const char *, bfd_boolean); +static bfd_boolean stab_function_parameter + (void *, const char *, enum debug_parm_kind, bfd_vma); +static bfd_boolean stab_start_block (void *, bfd_vma); +static bfd_boolean stab_end_block (void *, bfd_vma); +static bfd_boolean stab_end_function (void *); +static bfd_boolean stab_lineno (void *, const char *, unsigned long, bfd_vma); static const struct debug_write_fns stab_fns = { @@ -305,10 +298,8 @@ static const struct debug_write_fns stab_fns = /* Routine to create an entry in a string hash table. */ static struct bfd_hash_entry * -string_hash_newfunc (entry, table, string) - struct bfd_hash_entry *entry; - struct bfd_hash_table *table; - const char *string; +string_hash_newfunc (struct bfd_hash_entry *entry, + struct bfd_hash_table *table, const char *string) { struct string_hash_entry *ret = (struct string_hash_entry *) entry; @@ -343,13 +334,9 @@ string_hash_newfunc (entry, table, string) /* Add a symbol to the stabs debugging information we are building. */ -static boolean -stab_write_symbol (info, type, desc, value, string) - struct stab_write_handle *info; - int type; - int desc; - bfd_vma value; - const char *string; +static bfd_boolean +stab_write_symbol (struct stab_write_handle *info, int type, int desc, + bfd_vma value, const char *string) { bfd_size_type strx; bfd_byte sym[STAB_SYMBOL_SIZE]; @@ -360,12 +347,12 @@ stab_write_symbol (info, type, desc, value, string) { struct string_hash_entry *h; - h = string_hash_lookup (&info->strhash, string, true, true); + h = string_hash_lookup (&info->strhash, string, TRUE, TRUE); if (h == NULL) { non_fatal (_("string_hash_lookup failed: %s"), bfd_errmsg (bfd_get_error ())); - return false; + return FALSE; } if (h->index != -1) strx = h->index; @@ -400,24 +387,20 @@ stab_write_symbol (info, type, desc, value, string) info->symbols_size += STAB_SYMBOL_SIZE; - return true; + return TRUE; } /* Push a string on to the type stack. */ -static boolean -stab_push_string (info, string, index, definition, size) - struct stab_write_handle *info; - const char *string; - long index; - boolean definition; - unsigned int size; +static bfd_boolean +stab_push_string (struct stab_write_handle *info, const char *string, + long tindex, bfd_boolean definition, unsigned int size) { struct stab_type_stack *s; s = (struct stab_type_stack *) xmalloc (sizeof *s); s->string = xstrdup (string); - s->index = index; + s->index = tindex; s->definition = definition; s->size = size; @@ -429,29 +412,26 @@ stab_push_string (info, string, index, definition, size) s->next = info->type_stack; info->type_stack = s; - return true; + return TRUE; } /* Push a type index which has already been defined. */ -static boolean -stab_push_defined_type (info, index, size) - struct stab_write_handle *info; - long index; - unsigned int size; +static bfd_boolean +stab_push_defined_type (struct stab_write_handle *info, long tindex, + unsigned int size) { char buf[20]; - sprintf (buf, "%ld", index); - return stab_push_string (info, buf, index, false, size); + sprintf (buf, "%ld", tindex); + return stab_push_string (info, buf, tindex, FALSE, size); } /* Pop a type off the type stack. The caller is responsible for freeing the string. */ static char * -stab_pop_type (info) - struct stab_write_handle *info; +stab_pop_type (struct stab_write_handle *info) { struct stab_type_stack *s; char *ret; @@ -477,15 +457,12 @@ stab_pop_type (info) the symbols, *PSYMSIZE the size of the symbols, *PSTRINGS to the strings, and *PSTRINGSIZE to the size of the strings. */ -boolean -write_stabs_in_sections_debugging_info (abfd, dhandle, psyms, psymsize, - pstrings, pstringsize) - bfd *abfd; - PTR dhandle; - bfd_byte **psyms; - bfd_size_type *psymsize; - bfd_byte **pstrings; - bfd_size_type *pstringsize; +bfd_boolean +write_stabs_in_sections_debugging_info (bfd *abfd, void *dhandle, + bfd_byte **psyms, + bfd_size_type *psymsize, + bfd_byte **pstrings, + bfd_size_type *pstringsize) { struct stab_write_handle info; struct string_hash_entry *h; @@ -502,12 +479,14 @@ write_stabs_in_sections_debugging_info (abfd, dhandle, psyms, psymsize, /* Reserve 1 byte for a null byte. */ info.strings_size = 1; - if (! bfd_hash_table_init (&info.strhash.table, string_hash_newfunc) - || ! bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc)) + if (!bfd_hash_table_init (&info.strhash.table, string_hash_newfunc, + sizeof (struct string_hash_entry)) + || !bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc, + sizeof (struct string_hash_entry))) { non_fatal ("bfd_hash_table_init_failed: %s", bfd_errmsg (bfd_get_error ())); - return false; + return FALSE; } info.type_stack = NULL; @@ -522,22 +501,22 @@ write_stabs_in_sections_debugging_info (abfd, dhandle, psyms, psymsize, /* The initial symbol holds the string size. */ if (! stab_write_symbol (&info, 0, 0, 0, (const char *) NULL)) - return false; + return FALSE; /* Output an initial N_SO symbol. */ info.so_offset = info.symbols_size; if (! stab_write_symbol (&info, N_SO, 0, 0, bfd_get_filename (abfd))) - return false; + return FALSE; - if (! debug_write (dhandle, &stab_fns, (PTR) &info)) - return false; + if (! debug_write (dhandle, &stab_fns, (void *) &info)) + return FALSE; assert (info.pending_lbrac == (bfd_vma) -1); /* Output a trailing N_SO. */ if (! stab_write_symbol (&info, N_SO, 0, info.last_text_address, (const char *) NULL)) - return false; + return FALSE; /* Put the string size in the initial symbol. */ bfd_put_32 (abfd, info.strings_size, info.symbols + 8); @@ -556,15 +535,13 @@ write_stabs_in_sections_debugging_info (abfd, dhandle, psyms, psymsize, p += strlen ((char *) p) + 1; } - return true; + return TRUE; } /* Start writing out information for a compilation unit. */ -static boolean -stab_start_compilation_unit (p, filename) - PTR p; - const char *filename; +static bfd_boolean +stab_start_compilation_unit (void *p, const char *filename) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -580,10 +557,8 @@ stab_start_compilation_unit (p, filename) /* Start writing out information for a particular source file. */ -static boolean -stab_start_source (p, filename) - PTR p; - const char *filename; +static bfd_boolean +stab_start_source (void *p, const char *filename) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -599,9 +574,8 @@ stab_start_source (p, filename) /* Push an empty type. This shouldn't normally happen. We just use a void type. */ -static boolean -stab_empty_type (p) - PTR p; +static bfd_boolean +stab_empty_type (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -612,23 +586,22 @@ stab_empty_type (p) return stab_push_defined_type (info, info->type_cache.void_type, 0); else { - long index; + long tindex; char buf[40]; - index = info->type_index; + tindex = info->type_index; ++info->type_index; - sprintf (buf, "%ld=%ld", index, index); + sprintf (buf, "%ld=%ld", tindex, tindex); - return stab_push_string (info, buf, index, false, 0); + return stab_push_string (info, buf, tindex, FALSE, 0); } } /* Push a void type. */ -static boolean -stab_void_type (p) - PTR p; +static bfd_boolean +stab_void_type (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -636,27 +609,24 @@ stab_void_type (p) return stab_push_defined_type (info, info->type_cache.void_type, 0); else { - long index; + long tindex; char buf[40]; - index = info->type_index; + tindex = info->type_index; ++info->type_index; - info->type_cache.void_type = index; + info->type_cache.void_type = tindex; - sprintf (buf, "%ld=%ld", index, index); + sprintf (buf, "%ld=%ld", tindex, tindex); - return stab_push_string (info, buf, index, true, 0); + return stab_push_string (info, buf, tindex, TRUE, 0); } } /* Push an integer type. */ -static boolean -stab_int_type (p, size, unsignedp) - PTR p; - unsigned int size; - boolean unsignedp; +static bfd_boolean +stab_int_type (void *p, unsigned int size, bfd_boolean unsignedp) { struct stab_write_handle *info = (struct stab_write_handle *) p; long *cache; @@ -664,7 +634,7 @@ stab_int_type (p, size, unsignedp) if (size <= 0 || (size > sizeof (long) && size != 8)) { non_fatal (_("stab_int_type: bad size %u"), size); - return false; + return FALSE; } if (unsignedp) @@ -676,15 +646,15 @@ stab_int_type (p, size, unsignedp) return stab_push_defined_type (info, cache[size - 1], size); else { - long index; + long tindex; char buf[100]; - index = info->type_index; + tindex = info->type_index; ++info->type_index; - cache[size - 1] = index; + cache[size - 1] = tindex; - sprintf (buf, "%ld=r%ld;", index, index); + sprintf (buf, "%ld=r%ld;", tindex, tindex); if (unsignedp) { strcat (buf, "0;"); @@ -709,16 +679,14 @@ stab_int_type (p, size, unsignedp) abort (); } - return stab_push_string (info, buf, index, true, size); + return stab_push_string (info, buf, tindex, TRUE, size); } } /* Push a floating point type. */ -static boolean -stab_float_type (p, size) - PTR p; - unsigned int size; +static bfd_boolean +stab_float_type (void *p, unsigned int size) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -731,98 +699,91 @@ stab_float_type (p, size) size); else { - long index; + long tindex; char *int_type; char buf[50]; /* Floats are defined as a subrange of int. */ - if (! stab_int_type (info, 4, false)) - return false; + if (! stab_int_type (info, 4, FALSE)) + return FALSE; int_type = stab_pop_type (info); - index = info->type_index; + tindex = info->type_index; ++info->type_index; if (size > 0 && size - 1 < (sizeof info->type_cache.float_types / sizeof info->type_cache.float_types[0])) - info->type_cache.float_types[size - 1] = index; + info->type_cache.float_types[size - 1] = tindex; - sprintf (buf, "%ld=r%s;%u;0;", index, int_type, size); + sprintf (buf, "%ld=r%s;%u;0;", tindex, int_type, size); free (int_type); - return stab_push_string (info, buf, index, true, size); + return stab_push_string (info, buf, tindex, TRUE, size); } } /* Push a complex type. */ -static boolean -stab_complex_type (p, size) - PTR p; - unsigned int size; +static bfd_boolean +stab_complex_type (void *p, unsigned int size) { struct stab_write_handle *info = (struct stab_write_handle *) p; char buf[50]; - long index; + long tindex; - index = info->type_index; + tindex = info->type_index; ++info->type_index; - sprintf (buf, "%ld=r%ld;%u;0;", index, index, size); + sprintf (buf, "%ld=r%ld;%u;0;", tindex, tindex, size); - return stab_push_string (info, buf, index, true, size * 2); + return stab_push_string (info, buf, tindex, TRUE, size * 2); } -/* Push a boolean type. We use an XCOFF predefined type, since gdb +/* Push a bfd_boolean type. We use an XCOFF predefined type, since gdb always recognizes them. */ -static boolean -stab_bool_type (p, size) - PTR p; - unsigned int size; +static bfd_boolean +stab_bool_type (void *p, unsigned int size) { struct stab_write_handle *info = (struct stab_write_handle *) p; - long index; + long tindex; switch (size) { case 1: - index = -21; + tindex = -21; break; case 2: - index = -22; + tindex = -22; break; - + default: case 4: - index = -16; + tindex = -16; break; case 8: - index = -33; + tindex = -33; break; } - return stab_push_defined_type (info, index, size); + return stab_push_defined_type (info, tindex, size); } /* Push an enum type. */ -static boolean -stab_enum_type (p, tag, names, vals) - PTR p; - const char *tag; - const char **names; - bfd_signed_vma *vals; +static bfd_boolean +stab_enum_type (void *p, const char *tag, const char **names, + bfd_signed_vma *vals) { struct stab_write_handle *info = (struct stab_write_handle *) p; size_t len; const char **pn; char *buf; - long index = 0; + long tindex = 0; bfd_signed_vma *pv; if (names == NULL) @@ -832,10 +793,10 @@ stab_enum_type (p, tag, names, vals) buf = (char *) xmalloc (10 + strlen (tag)); sprintf (buf, "xe%s:", tag); /* FIXME: The size is just a guess. */ - if (! stab_push_string (info, buf, 0, false, 4)) - return false; + if (! stab_push_string (info, buf, 0, FALSE, 4)) + return FALSE; free (buf); - return true; + return TRUE; } len = 10; @@ -850,9 +811,9 @@ stab_enum_type (p, tag, names, vals) strcpy (buf, "e"); else { - index = info->type_index; + tindex = info->type_index; ++info->type_index; - sprintf (buf, "%s:T%ld=e", tag, index); + sprintf (buf, "%s:T%ld=e", tag, tindex); } for (pn = names, pv = vals; *pn != NULL; pn++, pv++) @@ -862,35 +823,31 @@ stab_enum_type (p, tag, names, vals) if (tag == NULL) { /* FIXME: The size is just a guess. */ - if (! stab_push_string (info, buf, 0, false, 4)) - return false; + if (! stab_push_string (info, buf, 0, FALSE, 4)) + return FALSE; } else { /* FIXME: The size is just a guess. */ if (! stab_write_symbol (info, N_LSYM, 0, 0, buf) - || ! stab_push_defined_type (info, index, 4)) - return false; + || ! stab_push_defined_type (info, tindex, 4)) + return FALSE; } free (buf); - return true; + return TRUE; } /* Push a modification of the top type on the stack. Cache the results in CACHE and CACHE_ALLOC. */ -static boolean -stab_modify_type (info, mod, size, cache, cache_alloc) - struct stab_write_handle *info; - int mod; - unsigned int size; - long **cache; - size_t *cache_alloc; +static bfd_boolean +stab_modify_type (struct stab_write_handle *info, int mod, + unsigned int size, long **cache, size_t *cache_alloc) { long targindex; - long index; + long tindex; char *s, *buf; assert (info->type_stack != NULL); @@ -899,7 +856,7 @@ stab_modify_type (info, mod, size, cache, cache_alloc) if (targindex <= 0 || cache == NULL) { - boolean definition; + bfd_boolean definition; /* Either the target type has no index, or we aren't caching this modifier. Either way we have no way of recording the @@ -910,7 +867,7 @@ stab_modify_type (info, mod, size, cache, cache_alloc) sprintf (buf, "%c%s", mod, s); free (s); if (! stab_push_string (info, buf, 0, definition, size)) - return false; + return FALSE; free (buf); } else @@ -930,8 +887,8 @@ stab_modify_type (info, mod, size, cache, cache_alloc) *cache_alloc = alloc; } - index = (*cache)[targindex]; - if (index != 0 && ! info->type_stack->definition) + tindex = (*cache)[targindex]; + if (tindex != 0 && ! info->type_stack->definition) { /* We have already defined a modification of this type, and the entry on the type stack is not a definition, so we @@ -940,36 +897,35 @@ stab_modify_type (info, mod, size, cache, cache_alloc) is a struct which we did not define at the time it was referenced). */ free (stab_pop_type (info)); - if (! stab_push_defined_type (info, index, size)) - return false; + if (! stab_push_defined_type (info, tindex, size)) + return FALSE; } else { - index = info->type_index; + tindex = info->type_index; ++info->type_index; s = stab_pop_type (info); buf = (char *) xmalloc (strlen (s) + 20); - sprintf (buf, "%ld=%c%s", index, mod, s); + sprintf (buf, "%ld=%c%s", tindex, mod, s); free (s); - (*cache)[targindex] = index; + (*cache)[targindex] = tindex; - if (! stab_push_string (info, buf, index, true, size)) - return false; + if (! stab_push_string (info, buf, tindex, TRUE, size)) + return FALSE; free (buf); } } - return true; -} + return TRUE; +} /* Push a pointer type. */ -static boolean -stab_pointer_type (p) - PTR p; +static bfd_boolean +stab_pointer_type (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -980,11 +936,9 @@ stab_pointer_type (p) /* Push a function type. */ -static boolean -stab_function_type (p, argcount, varargs) - PTR p; - int argcount; - boolean varargs ATTRIBUTE_UNUSED; +static bfd_boolean +stab_function_type (void *p, int argcount, + bfd_boolean varargs ATTRIBUTE_UNUSED) { struct stab_write_handle *info = (struct stab_write_handle *) p; int i; @@ -1007,7 +961,7 @@ stab_function_type (p, argcount, varargs) free (s); if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) - return false; + return FALSE; free (buf); } @@ -1019,9 +973,8 @@ stab_function_type (p, argcount, varargs) /* Push a reference type. */ -static boolean -stab_reference_type (p) - PTR p; +static bfd_boolean +stab_reference_type (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -1032,14 +985,11 @@ stab_reference_type (p) /* Push a range type. */ -static boolean -stab_range_type (p, low, high) - PTR p; - bfd_signed_vma low; - bfd_signed_vma high; +static bfd_boolean +stab_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; + bfd_boolean definition; unsigned int size; char *s, *buf; @@ -1052,27 +1002,24 @@ stab_range_type (p, low, high) free (s); if (! stab_push_string (info, buf, 0, definition, size)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Push an array type. */ -static boolean -stab_array_type (p, low, high, stringp) - PTR p; - bfd_signed_vma low; - bfd_signed_vma high; - boolean stringp; +static bfd_boolean +stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high, + bfd_boolean stringp) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; + bfd_boolean definition; unsigned int element_size; char *range, *element, *buf; - long index; + long tindex; unsigned int size; definition = info->type_stack->definition; @@ -1086,17 +1033,17 @@ stab_array_type (p, low, high, stringp) if (! stringp) { - index = 0; + tindex = 0; *buf = '\0'; } else { /* We need to define a type in order to include the string attribute. */ - index = info->type_index; + tindex = info->type_index; ++info->type_index; - definition = true; - sprintf (buf, "%ld=@S;", index); + definition = TRUE; + sprintf (buf, "%ld=@S;", tindex); } sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s", @@ -1108,25 +1055,23 @@ stab_array_type (p, low, high, stringp) size = 0; else size = element_size * ((high - low) + 1); - if (! stab_push_string (info, buf, index, definition, size)) - return false; + if (! stab_push_string (info, buf, tindex, definition, size)) + return FALSE; free (buf); - return true; + return TRUE; } /* Push a set type. */ -static boolean -stab_set_type (p, bitstringp) - PTR p; - boolean bitstringp; +static bfd_boolean +stab_set_type (void *p, bfd_boolean bitstringp) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; + bfd_boolean definition; char *s, *buf; - long index; + long tindex; definition = info->type_stack->definition; @@ -1136,37 +1081,36 @@ stab_set_type (p, bitstringp) if (! bitstringp) { *buf = '\0'; - index = 0; + tindex = 0; } else { /* We need to define a type in order to include the string attribute. */ - index = info->type_index; + tindex = info->type_index; ++info->type_index; - definition = true; - sprintf (buf, "%ld=@S;", index); + definition = TRUE; + sprintf (buf, "%ld=@S;", tindex); } sprintf (buf + strlen (buf), "S%s", s); free (s); - if (! stab_push_string (info, buf, index, definition, 0)) - return false; + if (! stab_push_string (info, buf, tindex, definition, 0)) + return FALSE; free (buf); - return true; + return TRUE; } /* Push an offset type. */ -static boolean -stab_offset_type (p) - PTR p; +static bfd_boolean +stab_offset_type (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; + bfd_boolean definition; char *target, *base, *buf; definition = info->type_stack->definition; @@ -1181,24 +1125,21 @@ stab_offset_type (p) free (target); if (! stab_push_string (info, buf, 0, definition, 0)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Push a method type. */ -static boolean -stab_method_type (p, domainp, argcount, varargs) - PTR p; - boolean domainp; - int argcount; - boolean varargs; +static bfd_boolean +stab_method_type (void *p, bfd_boolean domainp, int argcount, + bfd_boolean varargs) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; + bfd_boolean definition; char *domain, *return_type, *buf; char **args; int i; @@ -1213,7 +1154,7 @@ stab_method_type (p, domainp, argcount, varargs) if (! domainp) { if (! stab_empty_type (p)) - return false; + return FALSE; } definition = info->type_stack->definition; @@ -1235,7 +1176,7 @@ stab_method_type (p, domainp, argcount, varargs) { args = (char **) xmalloc (1 * sizeof (*args)); if (! stab_empty_type (p)) - return false; + return FALSE; definition = definition || info->type_stack->definition; args[0] = stab_pop_type (info); argcount = 1; @@ -1252,7 +1193,7 @@ stab_method_type (p, domainp, argcount, varargs) if (! varargs) { if (! stab_empty_type (p)) - return false; + return FALSE; definition = definition || info->type_stack->definition; args[argcount] = stab_pop_type (info); ++argcount; @@ -1283,18 +1224,17 @@ stab_method_type (p, domainp, argcount, varargs) free (args); if (! stab_push_string (info, buf, 0, definition, 0)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Push a const version of a type. */ -static boolean -stab_const_type (p) - PTR p; +static bfd_boolean +stab_const_type (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -1304,9 +1244,8 @@ stab_const_type (p) /* Push a volatile version of a type. */ -static boolean -stab_volatile_type (p) - PTR p; +static bfd_boolean +stab_volatile_type (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -1318,12 +1257,9 @@ stab_volatile_type (p) return -1 if it fails. */ static long -stab_get_struct_index (info, tag, id, kind, psize) - struct stab_write_handle *info; - const char *tag; - unsigned int id; - enum debug_type_kind kind; - unsigned int *psize; +stab_get_struct_index (struct stab_write_handle *info, const char *tag, + unsigned int id, enum debug_type_kind kind, + unsigned int *psize) { if (id >= info->type_cache.struct_types_alloc) { @@ -1368,63 +1304,52 @@ stab_get_struct_index (info, tag, id, kind, psize) /* Start outputting a struct. We ignore the tag, and handle it in stab_tag. */ -/*ARGSUSED*/ -static boolean -stab_start_struct_type (p, tag, id, structp, size) - PTR p; - const char *tag; - unsigned int id; - boolean structp; - unsigned int size; +static bfd_boolean +stab_start_struct_type (void *p, const char *tag, unsigned int id, + bfd_boolean structp, unsigned int size) { struct stab_write_handle *info = (struct stab_write_handle *) p; - long index; - boolean definition; - char *buf; - - buf = (char *) xmalloc (40); + long tindex; + bfd_boolean definition; + char buf[40]; if (id == 0) { - index = 0; + tindex = 0; *buf = '\0'; - definition = false; + definition = FALSE; } else { - index = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL, + tindex = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL, &size); - if (index < 0) - return false; - sprintf (buf, "%ld=", index); - definition = true; + if (tindex < 0) + return FALSE; + sprintf (buf, "%ld=", tindex); + definition = TRUE; } sprintf (buf + strlen (buf), "%c%u", structp ? 's' : 'u', size); - if (! stab_push_string (info, buf, index, definition, size)) - return false; + if (! stab_push_string (info, buf, tindex, definition, size)) + return FALSE; info->type_stack->fields = (char *) xmalloc (1); info->type_stack->fields[0] = '\0'; - return true; + return TRUE; } /* Add a field to a struct. */ -static boolean -stab_struct_field (p, name, bitpos, bitsize, visibility) - PTR p; - const char *name; - bfd_vma bitpos; - bfd_vma bitsize; - enum debug_visibility visibility; +static bfd_boolean +stab_struct_field (void *p, const char *name, bfd_vma bitpos, + bfd_vma bitsize, enum debug_visibility visibility) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; + bfd_boolean definition; unsigned int size; char *s, *n; const char *vis; @@ -1475,27 +1400,26 @@ stab_struct_field (p, name, bitpos, bitsize, visibility) info->type_stack->fields = n; if (definition) - info->type_stack->definition = true; + info->type_stack->definition = TRUE; - return true; + return TRUE; } /* Finish up a struct. */ -static boolean -stab_end_struct_type (p) - PTR p; +static bfd_boolean +stab_end_struct_type (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; - long index; + bfd_boolean definition; + long tindex; unsigned int size; char *fields, *first, *buf; assert (info->type_stack != NULL && info->type_stack->fields != NULL); definition = info->type_stack->definition; - index = info->type_stack->index; + tindex = info->type_stack->index; size = info->type_stack->size; fields = info->type_stack->fields; first = stab_pop_type (info); @@ -1505,43 +1429,33 @@ stab_end_struct_type (p) free (first); free (fields); - if (! stab_push_string (info, buf, index, definition, size)) - return false; + if (! stab_push_string (info, buf, tindex, definition, size)) + return FALSE; free (buf); - return true; + return TRUE; } /* Start outputting a class. */ -static boolean -stab_start_class_type (p, tag, id, structp, size, vptr, ownvptr) - PTR p; - const char *tag; - unsigned int id; - boolean structp; - unsigned int size; - boolean vptr; - boolean ownvptr; +static bfd_boolean +stab_start_class_type (void *p, const char *tag, unsigned int id, + bfd_boolean structp, unsigned int size, + bfd_boolean vptr, bfd_boolean ownvptr) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; - char *vstring; + bfd_boolean definition = FALSE; + char *vstring = NULL; - if (! vptr || ownvptr) - { - definition = false; - vstring = NULL; - } - else + if (vptr && !ownvptr) { definition = info->type_stack->definition; vstring = stab_pop_type (info); } if (! stab_start_struct_type (p, tag, id, structp, size)) - return false; + return FALSE; if (vptr) { @@ -1555,31 +1469,27 @@ stab_start_class_type (p, tag, id, structp, size, vptr, ownvptr) } else { + assert (vstring); vtable = (char *) xmalloc (strlen (vstring) + 3); sprintf (vtable, "~%%%s", vstring); free (vstring); + if (definition) + info->type_stack->definition = TRUE; } - info->type_stack->vtable = vtable; } - if (definition) - info->type_stack->definition = true; - - return true; + return TRUE; } /* Add a static member to the class on the type stack. */ -static boolean -stab_class_static_member (p, name, physname, visibility) - PTR p; - const char *name; - const char *physname; - enum debug_visibility visibility; +static bfd_boolean +stab_class_static_member (void *p, const char *name, const char *physname, + enum debug_visibility visibility) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; + bfd_boolean definition; char *s, *n; const char *vis; @@ -1621,22 +1531,19 @@ stab_class_static_member (p, name, physname, visibility) info->type_stack->fields = n; if (definition) - info->type_stack->definition = true; + info->type_stack->definition = TRUE; - return true; + return TRUE; } /* Add a base class to the class on the type stack. */ -static boolean -stab_class_baseclass (p, bitpos, virtual, visibility) - PTR p; - bfd_vma bitpos; - boolean virtual; - enum debug_visibility visibility; +static bfd_boolean +stab_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual, + enum debug_visibility visibility) { struct stab_write_handle *info = (struct stab_write_handle *) p; - boolean definition; + bfd_boolean definition; char *s; char *buf; unsigned int c; @@ -1648,7 +1555,7 @@ stab_class_baseclass (p, bitpos, virtual, visibility) /* Build the base class specifier. */ buf = (char *) xmalloc (strlen (s) + 25); - buf[0] = virtual ? '1' : '0'; + buf[0] = is_virtual ? '1' : '0'; switch (visibility) { default: @@ -1691,17 +1598,15 @@ stab_class_baseclass (p, bitpos, virtual, visibility) info->type_stack->baseclasses = baseclasses; if (definition) - info->type_stack->definition = true; + info->type_stack->definition = TRUE; - return true; + return TRUE; } /* Start adding a method to the class on the type stack. */ -static boolean -stab_class_start_method (p, name) - PTR p; - const char *name; +static bfd_boolean +stab_class_start_method (void *p, const char *name) { struct stab_write_handle *info = (struct stab_write_handle *) p; char *m; @@ -1725,24 +1630,19 @@ stab_class_start_method (p, name) info->type_stack->methods = m; - return true; + return TRUE; } /* Add a variant, either static or not, to the current method. */ -static boolean -stab_class_method_var (info, physname, visibility, staticp, constp, volatilep, - voffset, contextp) - struct stab_write_handle *info; - const char *physname; - enum debug_visibility visibility; - boolean staticp; - boolean constp; - boolean volatilep; - bfd_vma voffset; - boolean contextp; +static bfd_boolean +stab_class_method_var (struct stab_write_handle *info, const char *physname, + enum debug_visibility visibility, + bfd_boolean staticp, bfd_boolean constp, + bfd_boolean volatilep, bfd_vma voffset, + bfd_boolean contextp) { - boolean definition; + bfd_boolean definition; char *type; char *context = NULL; char visc, qualc, typec; @@ -1818,51 +1718,42 @@ stab_class_method_var (info, physname, visibility, staticp, constp, volatilep, } if (definition) - info->type_stack->definition = true; + info->type_stack->definition = TRUE; - return true; + return TRUE; } /* Add a variant to the current method. */ -static boolean -stab_class_method_variant (p, physname, visibility, constp, volatilep, - voffset, contextp) - PTR p; - const char *physname; - enum debug_visibility visibility; - boolean constp; - boolean volatilep; - bfd_vma voffset; - boolean contextp; +static bfd_boolean +stab_class_method_variant (void *p, const char *physname, + enum debug_visibility visibility, + bfd_boolean constp, bfd_boolean volatilep, + bfd_vma voffset, bfd_boolean contextp) { struct stab_write_handle *info = (struct stab_write_handle *) p; - return stab_class_method_var (info, physname, visibility, false, constp, + return stab_class_method_var (info, physname, visibility, FALSE, constp, volatilep, voffset, contextp); } /* Add a static variant to the current method. */ -static boolean -stab_class_static_method_variant (p, physname, visibility, constp, volatilep) - PTR p; - const char *physname; - enum debug_visibility visibility; - boolean constp; - boolean volatilep; +static bfd_boolean +stab_class_static_method_variant (void *p, const char *physname, + enum debug_visibility visibility, + bfd_boolean constp, bfd_boolean volatilep) { struct stab_write_handle *info = (struct stab_write_handle *) p; - return stab_class_method_var (info, physname, visibility, true, constp, - volatilep, 0, false); + return stab_class_method_var (info, physname, visibility, TRUE, constp, + volatilep, 0, FALSE); } /* Finish up a method. */ -static boolean -stab_class_end_method (p) - PTR p; +static bfd_boolean +stab_class_end_method (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -1872,14 +1763,13 @@ stab_class_end_method (p) trailing semicolon. */ strcat (info->type_stack->methods, ";"); - return true; + return TRUE; } /* Finish up a class. */ -static boolean -stab_end_class_type (p) - PTR p; +static bfd_boolean +stab_end_class_type (void *p) { struct stab_write_handle *info = (struct stab_write_handle *) p; size_t len; @@ -1947,20 +1837,18 @@ stab_end_class_type (p) free (info->type_stack->string); info->type_stack->string = buf; - return true; + return TRUE; } /* Push a typedef which was previously defined. */ -static boolean -stab_typedef_type (p, name) - PTR p; - const char *name; +static bfd_boolean +stab_typedef_type (void *p, const char *name) { struct stab_write_handle *info = (struct stab_write_handle *) p; struct string_hash_entry *h; - h = string_hash_lookup (&info->typedef_hash, name, false, false); + h = string_hash_lookup (&info->typedef_hash, name, FALSE, FALSE); assert (h != NULL && h->index > 0); return stab_push_defined_type (info, h->index, h->size); @@ -1968,81 +1856,74 @@ stab_typedef_type (p, name) /* Push a struct, union or class tag. */ -static boolean -stab_tag_type (p, name, id, kind) - PTR p; - const char *name; - unsigned int id; - enum debug_type_kind kind; +static bfd_boolean +stab_tag_type (void *p, const char *name, unsigned int id, + enum debug_type_kind kind) { struct stab_write_handle *info = (struct stab_write_handle *) p; - long index; - unsigned int size; + long tindex; + unsigned int size = 0; - index = stab_get_struct_index (info, name, id, kind, &size); - if (index < 0) - return false; + tindex = stab_get_struct_index (info, name, id, kind, &size); + if (tindex < 0) + return FALSE; - return stab_push_defined_type (info, index, size); + return stab_push_defined_type (info, tindex, size); } /* Define a typedef. */ -static boolean -stab_typdef (p, name) - PTR p; - const char *name; +static bfd_boolean +stab_typdef (void *p, const char *name) { struct stab_write_handle *info = (struct stab_write_handle *) p; - long index; + long tindex; unsigned int size; char *s, *buf; struct string_hash_entry *h; - index = info->type_stack->index; + tindex = info->type_stack->index; size = info->type_stack->size; s = stab_pop_type (info); buf = (char *) xmalloc (strlen (name) + strlen (s) + 20); - if (index > 0) + if (tindex > 0) sprintf (buf, "%s:t%s", name, s); else { - index = info->type_index; + tindex = info->type_index; ++info->type_index; - sprintf (buf, "%s:t%ld=%s", name, index, s); + sprintf (buf, "%s:t%ld=%s", name, tindex, s); } free (s); if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) - return false; + return FALSE; free (buf); - h = string_hash_lookup (&info->typedef_hash, name, true, false); + h = string_hash_lookup (&info->typedef_hash, name, TRUE, FALSE); if (h == NULL) { non_fatal (_("string_hash_lookup failed: %s"), bfd_errmsg (bfd_get_error ())); - return false; + return FALSE; } /* I don't think we care about redefinitions. */ - h->index = index; + h->index = tindex; h->size = size; - return true; + return TRUE; } /* Define a tag. */ -static boolean -stab_tag (p, tag) - PTR p; - const char *tag; +static bfd_boolean +stab_tag (void *p, const char *tag) { struct stab_write_handle *info = (struct stab_write_handle *) p; char *s, *buf; @@ -2055,20 +1936,17 @@ stab_tag (p, tag) free (s); if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Define an integer constant. */ -static boolean -stab_int_constant (p, name, val) - PTR p; - const char *name; - bfd_vma val; +static bfd_boolean +stab_int_constant (void *p, const char *name, bfd_vma val) { struct stab_write_handle *info = (struct stab_write_handle *) p; char *buf; @@ -2077,20 +1955,17 @@ stab_int_constant (p, name, val) sprintf (buf, "%s:c=i%ld", name, (long) val); if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Define a floating point constant. */ -static boolean -stab_float_constant (p, name, val) - PTR p; - const char *name; - double val; +static bfd_boolean +stab_float_constant (void *p, const char *name, double val) { struct stab_write_handle *info = (struct stab_write_handle *) p; char *buf; @@ -2099,20 +1974,17 @@ stab_float_constant (p, name, val) sprintf (buf, "%s:c=f%g", name, val); if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Define a typed constant. */ -static boolean -stab_typed_constant (p, name, val) - PTR p; - const char *name; - bfd_vma val; +static bfd_boolean +stab_typed_constant (void *p, const char *name, bfd_vma val) { struct stab_write_handle *info = (struct stab_write_handle *) p; char *s, *buf; @@ -2124,21 +1996,18 @@ stab_typed_constant (p, name, val) free (s); if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Record a variable. */ -static boolean -stab_variable (p, name, kind, val) - PTR p; - const char *name; - enum debug_var_kind kind; - bfd_vma val; +static bfd_boolean +stab_variable (void *p, const char *name, enum debug_var_kind kind, + bfd_vma val) { struct stab_write_handle *info = (struct stab_write_handle *) p; char *s, *buf; @@ -2172,15 +2041,15 @@ stab_variable (p, name, kind, val) kindstr = ""; /* Make sure that this is a type reference or definition. */ - if (! isdigit ((unsigned char) *s)) + if (! ISDIGIT (*s)) { char *n; - long index; + long tindex; - index = info->type_index; + tindex = info->type_index; ++info->type_index; n = (char *) xmalloc (strlen (s) + 20); - sprintf (n, "%ld=%s", index, s); + sprintf (n, "%ld=%s", tindex, s); free (s); s = n; } @@ -2197,20 +2066,17 @@ stab_variable (p, name, kind, val) free (s); if (! stab_write_symbol (info, stab_type, 0, val, buf)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Start outputting a function. */ -static boolean -stab_start_function (p, name, globalp) - PTR p; - const char *name; - boolean globalp; +static bfd_boolean +stab_start_function (void *p, const char *name, bfd_boolean globalp) { struct stab_write_handle *info = (struct stab_write_handle *) p; char *rettype, *buf; @@ -2228,21 +2094,17 @@ stab_start_function (p, name, globalp) info->fun_offset = info->symbols_size; if (! stab_write_symbol (info, N_FUN, 0, 0, buf)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Output a function parameter. */ -static boolean -stab_function_parameter (p, name, kind, val) - PTR p; - const char *name; - enum debug_parm_kind kind; - bfd_vma val; +static bfd_boolean +stab_function_parameter (void *p, const char *name, enum debug_parm_kind kind, bfd_vma val) { struct stab_write_handle *info = (struct stab_write_handle *) p; char *s, *buf; @@ -2282,19 +2144,17 @@ stab_function_parameter (p, name, kind, val) free (s); if (! stab_write_symbol (info, stab_type, 0, val, buf)) - return false; + return FALSE; free (buf); - return true; + return TRUE; } /* Start a block. */ -static boolean -stab_start_block (p, addr) - PTR p; - bfd_vma addr; +static bfd_boolean +stab_start_block (void *p, bfd_vma addr) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -2322,7 +2182,7 @@ stab_start_block (p, addr) if (info->nesting == 1) { info->fnaddr = addr; - return true; + return TRUE; } /* We have to output the LBRAC symbol after any variables which are @@ -2334,22 +2194,20 @@ stab_start_block (p, addr) { if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac, (const char *) NULL)) - return false; + return FALSE; } /* Remember the address and output it later. */ info->pending_lbrac = addr - info->fnaddr; - return true; + return TRUE; } /* End a block. */ -static boolean -stab_end_block (p, addr) - PTR p; - bfd_vma addr; +static bfd_boolean +stab_end_block (void *p, bfd_vma addr) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -2361,7 +2219,7 @@ stab_end_block (p, addr) { if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac, (const char *) NULL)) - return false; + return FALSE; info->pending_lbrac = (bfd_vma) -1; } @@ -2371,7 +2229,7 @@ stab_end_block (p, addr) /* We ignore the outermost block. */ if (info->nesting == 0) - return true; + return TRUE; return stab_write_symbol (info, N_RBRAC, 0, addr - info->fnaddr, (const char *) NULL); @@ -2379,22 +2237,16 @@ stab_end_block (p, addr) /* End a function. */ -/*ARGSUSED*/ -static boolean -stab_end_function (p) - PTR p ATTRIBUTE_UNUSED; +static bfd_boolean +stab_end_function (void *p ATTRIBUTE_UNUSED) { - return true; + return TRUE; } /* Output a line number. */ -static boolean -stab_lineno (p, file, lineno, addr) - PTR p; - const char *file; - unsigned long lineno; - bfd_vma addr; +static bfd_boolean +stab_lineno (void *p, const char *file, unsigned long lineno, bfd_vma addr) { struct stab_write_handle *info = (struct stab_write_handle *) p; @@ -2403,10 +2255,10 @@ stab_lineno (p, file, lineno, addr) if (addr > info->last_text_address) info->last_text_address = addr; - if (strcmp (file, info->lineno_filename) != 0) + if (filename_cmp (file, info->lineno_filename) != 0) { if (! stab_write_symbol (info, N_SOL, 0, addr, file)) - return false; + return FALSE; info->lineno_filename = file; }