X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gas%2Fecoff.c;h=27cfd6e730db3517044fe2cd1651770e9f53a790;hb=834ddcc491ace97284f1ec0edd55a863e9485e95;hp=310d6672efe92199ac079ed1c1dba1584eab84fb;hpb=49309057b4c45a2586735182830793c77633f51d;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/ecoff.c b/gas/ecoff.c index 310d6672ef..27cfd6e730 100644 --- a/gas/ecoff.c +++ b/gas/ecoff.c @@ -1,5 +1,6 @@ /* ECOFF debugging support. - Copyright (C) 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc. + Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. Contributed by Cygnus Support. This file was put together by Ian Lance Taylor . A good deal of it comes directly from mips-tfile.c, by Michael @@ -28,14 +29,15 @@ ECOFF debugging information (e.g., MIPS ECOFF, MIPS ELF, Alpha ECOFF). */ +#include "ecoff.h" + #ifdef ECOFF_DEBUGGING #include "coff/internal.h" #include "coff/symconst.h" -#include "ecoff.h" #include "aout/stab_gnu.h" -#include +#include "safe-ctype.h" /* Why isn't this in coff/sym.h? */ #define ST_RFDESCAPE 0xfff @@ -160,7 +162,6 @@ tqFar -- 8086 far pointers tqVol -- volatile - The dense number table is used in the front ends, and disappears by the time the .o is created. @@ -255,8 +256,6 @@ 5) index: pointer to a local symbol or aux. entry. - - For the following program: #include @@ -726,9 +725,9 @@ typedef enum bt { /* States for whether to hash type or not. */ typedef enum hash_state { - hash_no = 0, /* don't hash type */ - hash_yes = 1, /* ok to hash type, or use previous hash */ - hash_record = 2 /* ok to record hash, but don't use prev. */ + hash_no = 0, /* Don't hash type */ + hash_yes = 1, /* OK to hash type, or use previous hash */ + hash_record = 2 /* OK to record hash, but don't use prev. */ } hash_state_t; /* Types of different sized allocation requests. */ @@ -769,7 +768,7 @@ enum aux_type { can't be represented (assuming there are strings > 4096 bytes). */ /* FIXME: Yes, there can be such strings while emitting C++ class debug - info. Templates are the offender here, the test case in question + info. Templates are the offender here, the test case in question having a mangled class name of t7rb_tree4Z4xkeyZt4pair2ZC4xkeyZt7xsocket1Z4UserZt9select1st2Zt4pair\ @@ -798,7 +797,6 @@ typedef struct vlinks { unsigned long start_index; /* starting index # of page */ } vlinks_t; - /* Virtual array header. */ typedef struct varray { vlinks_t *first; /* first page link */ @@ -824,11 +822,9 @@ typedef struct varray { OBJECTS_PER_PAGE (type), /* objects_last_page */ \ } - -/* Master type for indexes within the symbol table. */ +/* Master type for indexes within the symbol table. */ typedef unsigned long symint_t; - /* Linked list support for nested scopes (file, block, structure, etc.). */ typedef struct scope { struct scope *prev; /* previous scope level */ @@ -837,7 +833,6 @@ typedef struct scope { st_t type; /* type of the node */ } scope_t; - /* For a local symbol we store a gas symbol as well as the debugging information we generate. The gas symbol will be NULL if this is only a debugging symbol. */ @@ -854,7 +849,6 @@ typedef struct localsym { EXTR ecoff_sym; /* ECOFF debugging symbol */ } localsym_t; - /* For aux information we keep the type and the data. */ typedef struct ecoff_aux { enum aux_type type; /* aux type */ @@ -871,7 +865,6 @@ typedef struct ecoff_proc { /* Number of proc_t structures allocated. */ static unsigned long proc_cnt; - /* Forward reference list for tags referenced, but not yet defined. */ typedef struct forward { struct forward *next; /* next forward reference */ @@ -880,7 +873,6 @@ typedef struct forward { aux_t *index_ptr; /* pointer to store symbol index */ } forward_t; - /* Linked list support for tags. The first tag in the list is always the current tag for that block. */ typedef struct tag { @@ -894,7 +886,6 @@ typedef struct tag { localsym_t *sym; /* file's local symbols */ } tag_t; - /* Head of a block's linked list of tags. */ typedef struct thead { struct thead *prev; /* previous block */ @@ -902,7 +893,6 @@ typedef struct thead { struct tag *first_tag; /* first tag in block defined */ } thead_t; - /* Union containing pointers to each the small structures which are freed up. */ typedef union small_free { scope_t *f_scope; /* scope structure */ @@ -911,7 +901,6 @@ typedef union small_free { forward_t *f_forward; /* forward tag reference */ } small_free_t; - /* String hash table entry. */ typedef struct shash { @@ -924,7 +913,6 @@ typedef struct shash { proc_t *proc_ptr; /* procedure descriptor pointer */ } shash_t; - /* Type hash table support. The size of the hash table must fit within a page with the other extended file descriptor information. Because unique types which are hashed are fewer in number than @@ -942,7 +930,6 @@ typedef struct thash { symint_t indx; /* index within string table */ } thash_t; - /* Extended file descriptor that contains all of the support necessary to add things to each file separately. */ typedef struct efdr { @@ -966,8 +953,7 @@ typedef struct efdr { } efdr_t; /* Pre-initialized extended file structure. */ -static const efdr_t init_file = -{ +static const efdr_t init_file = { { /* FDR structure */ 0, /* adr: memory address of beginning of file */ 0, /* rss: file name (of source, if known) */ @@ -1014,11 +1000,9 @@ static const efdr_t init_file = { 0 }, /* thash_head: type hash table */ }; - static efdr_t *first_file; /* first file descriptor */ static efdr_t **last_file_ptr = &first_file; /* file descriptor tail */ - /* Line number information is kept in a list until the assembly is finished. */ typedef struct lineno_list { @@ -1059,7 +1043,6 @@ typedef union page { lineno_list_t lineno [ PAGE_SIZE / sizeof (lineno_list_t) ]; } page_type; - /* Structure holding allocation information for small sized structures. */ typedef struct alloc_info { char *alloc_name; /* name of this allocation type (must be first) */ @@ -1071,7 +1054,6 @@ typedef struct alloc_info { int total_pages; /* total number of pages allocated */ } alloc_info_t; - /* Type information collected together. */ typedef struct type_info { bt_t basic_type; /* basic type */ @@ -1129,7 +1111,7 @@ static const type_info_t type_info_init = { /* Global hash table for the tags table and global table for file descriptors. */ -static varray_t file_desc = INIT_VARRAY (efdr_t); +static varray_t file_desc = INIT_VARRAY (efdr_t); static struct hash_control *tag_hash; @@ -1142,7 +1124,6 @@ static type_info_t void_type_info; static type_info_t last_func_type_info; static symbolS *last_func_sym_value; - /* Convert COFF basic type to ECOFF basic type. The T_NULL type really should use bt_Void, but this causes the current ecoff GDB to issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS @@ -1398,9 +1379,8 @@ static const st_t map_coff_sym_type[] = { st_Nil, /* 106: C_HIDDEN ??? */ }; - /* Keep track of different sized allocation requests. */ -static alloc_info_t alloc_counts[ (int)alloc_type_last ]; +static alloc_info_t alloc_counts[(int) alloc_type_last]; /* Record whether we have seen any debugging information. */ int ecoff_debugging_seen = 0; @@ -1428,76 +1408,74 @@ static char stabs_symbol[] = STABS_SYMBOL; /* Prototypes for functions defined in this file. */ -static void add_varray_page PARAMS ((varray_t *vp)); -static symint_t add_string PARAMS ((varray_t *vp, - struct hash_control *hash_tbl, - const char *str, - shash_t **ret_hash)); -static localsym_t *add_ecoff_symbol PARAMS ((const char *str, st_t type, - sc_t storage, symbolS *sym, - bfd_vma addend, symint_t value, - symint_t indx)); -static symint_t add_aux_sym_symint PARAMS ((symint_t aux_word)); -static symint_t add_aux_sym_rndx PARAMS ((int file_index, - symint_t sym_index)); -static symint_t add_aux_sym_tir PARAMS ((type_info_t *t, - hash_state_t state, - thash_t **hash_tbl)); -static tag_t *get_tag PARAMS ((const char *tag, localsym_t *sym, - bt_t basic_type)); -static void add_unknown_tag PARAMS ((tag_t *ptag)); -static void add_procedure PARAMS ((char *func)); -static void add_file PARAMS ((const char *file_name, int indx, int fake)); +static void add_varray_page (varray_t *vp); +static symint_t add_string (varray_t *vp, + struct hash_control *hash_tbl, + const char *str, + shash_t **ret_hash); +static localsym_t *add_ecoff_symbol (const char *str, st_t type, + sc_t storage, symbolS *sym, + bfd_vma addend, symint_t value, + symint_t indx); +static symint_t add_aux_sym_symint (symint_t aux_word); +static symint_t add_aux_sym_rndx (int file_index, symint_t sym_index); +static symint_t add_aux_sym_tir (type_info_t *t, + hash_state_t state, + thash_t **hash_tbl); +static tag_t *get_tag (const char *tag, localsym_t *sym, bt_t basic_type); +static void add_unknown_tag (tag_t *ptag); +static void add_procedure (char *func); +static void add_file (const char *file_name, int indx, int fake); #ifdef ECOFF_DEBUG -static char *sc_to_string PARAMS ((sc_t storage_class)); -static char *st_to_string PARAMS ((st_t symbol_type)); +static char *sc_to_string (sc_t storage_class); +static char *st_to_string (st_t symbol_type); #endif -static void mark_stabs PARAMS ((int)); -static char *ecoff_add_bytes PARAMS ((char **buf, char **bufend, - char *bufptr, unsigned long need)); +static void mark_stabs (int); +static char *ecoff_add_bytes (char **buf, char **bufend, + char *bufptr, unsigned long need); static unsigned long ecoff_padding_adjust - PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend, - unsigned long offset, char **bufptrptr)); + (const struct ecoff_debug_swap *backend, char **buf, char **bufend, + unsigned long offset, char **bufptrptr); static unsigned long ecoff_build_lineno - PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend, - unsigned long offset, long *linecntptr)); + (const struct ecoff_debug_swap *backend, char **buf, char **bufend, + unsigned long offset, long *linecntptr); static unsigned long ecoff_build_symbols - PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend, - unsigned long offset)); + (const struct ecoff_debug_swap *backend, char **buf, char **bufend, + unsigned long offset); static unsigned long ecoff_build_procs - PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend, - unsigned long offset)); + (const struct ecoff_debug_swap *backend, char **buf, char **bufend, + unsigned long offset); static unsigned long ecoff_build_aux - PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend, - unsigned long offset)); -static unsigned long ecoff_build_strings PARAMS ((char **buf, char **bufend, - unsigned long offset, - varray_t *vp)); + (const struct ecoff_debug_swap *backend, char **buf, char **bufend, + unsigned long offset); +static unsigned long ecoff_build_strings (char **buf, char **bufend, + unsigned long offset, + varray_t *vp); static unsigned long ecoff_build_ss - PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend, - unsigned long offset)); + (const struct ecoff_debug_swap *backend, char **buf, char **bufend, + unsigned long offset); static unsigned long ecoff_build_fdr - PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend, - unsigned long offset)); -static void ecoff_setup_ext PARAMS ((void)); -static page_type *allocate_cluster PARAMS ((unsigned long npages)); -static page_type *allocate_page PARAMS ((void)); -static scope_t *allocate_scope PARAMS ((void)); -static void free_scope PARAMS ((scope_t *ptr)); -static vlinks_t *allocate_vlinks PARAMS ((void)); -static shash_t *allocate_shash PARAMS ((void)); -static thash_t *allocate_thash PARAMS ((void)); -static tag_t *allocate_tag PARAMS ((void)); -static void free_tag PARAMS ((tag_t *ptr)); -static forward_t *allocate_forward PARAMS ((void)); -static thead_t *allocate_thead PARAMS ((void)); -static void free_thead PARAMS ((thead_t *ptr)); -static lineno_list_t *allocate_lineno_list PARAMS ((void)); + (const struct ecoff_debug_swap *backend, char **buf, char **bufend, + unsigned long offset); +static void ecoff_setup_ext (void); +static page_type *allocate_cluster (unsigned long npages); +static page_type *allocate_page (void); +static scope_t *allocate_scope (void); +static void free_scope (scope_t *ptr); +static vlinks_t *allocate_vlinks (void); +static shash_t *allocate_shash (void); +static thash_t *allocate_thash (void); +static tag_t *allocate_tag (void); +static void free_tag (tag_t *ptr); +static forward_t *allocate_forward (void); +static thead_t *allocate_thead (void); +static void free_thead (thead_t *ptr); +static lineno_list_t *allocate_lineno_list (void); /* This function should be called when the assembler starts up. */ void -ecoff_read_begin_hook () +ecoff_read_begin_hook (void) { tag_hash = hash_new (); top_tag_head = allocate_thead (); @@ -1510,8 +1488,7 @@ ecoff_read_begin_hook () /* This function should be called when a symbol is created. */ void -ecoff_symbol_new_hook (symbolP) - symbolS *symbolP; +ecoff_symbol_new_hook (symbolS *symbolP) { OBJ_SYMFIELD_TYPE *obj; @@ -1532,8 +1509,7 @@ ecoff_symbol_new_hook (symbolP) /* Add a page to a varray object. */ static void -add_varray_page (vp) - varray_t *vp; /* varray to add page to */ +add_varray_page (varray_t *vp /* varray to add page to */) { vlinks_t *new_links = allocate_vlinks (); @@ -1544,8 +1520,8 @@ add_varray_page (vp) #endif new_links->datum = allocate_page (); - alloc_counts[(int)alloc_type_varray].total_alloc++; - alloc_counts[(int)alloc_type_varray].total_pages++; + alloc_counts[(int) alloc_type_varray].total_alloc++; + alloc_counts[(int) alloc_type_varray].total_pages++; new_links->start_index = vp->num_allocated; vp->objects_last_page = 0; @@ -1563,17 +1539,16 @@ add_varray_page (vp) /* Add a string (and null pad) to one of the string tables. */ static symint_t -add_string (vp, hash_tbl, str, ret_hash) - varray_t *vp; /* string obstack */ - struct hash_control *hash_tbl; /* ptr to hash table */ - const char *str; /* string */ - shash_t **ret_hash; /* return hash pointer */ +add_string (varray_t *vp, /* string obstack */ + struct hash_control *hash_tbl, /* ptr to hash table */ + const char *str, /* string */ + shash_t **ret_hash /* return hash pointer */) { register unsigned long len = strlen (str); register shash_t *hash_ptr; if (len >= PAGE_USIZE) - as_fatal (_("String too big (%lu bytes)"), len); + as_fatal (_("string too big (%lu bytes)"), len); hash_ptr = (shash_t *) hash_find (hash_tbl, str); if (hash_ptr == (shash_t *) NULL) @@ -1581,11 +1556,11 @@ add_string (vp, hash_tbl, str, ret_hash) register const char *err; if (vp->objects_last_page + len >= PAGE_USIZE) - { - vp->num_allocated = - ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE; - add_varray_page (vp); - } + { + vp->num_allocated = + ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE; + add_varray_page (vp); + } hash_ptr = allocate_shash (); hash_ptr->indx = vp->num_allocated; @@ -1599,7 +1574,7 @@ add_string (vp, hash_tbl, str, ret_hash) err = hash_insert (hash_tbl, str, (char *) hash_ptr); if (err) - as_fatal (_("Inserting \"%s\" into string hash table: %s"), + as_fatal (_("inserting \"%s\" into string hash table: %s"), str, err); } @@ -1612,14 +1587,13 @@ add_string (vp, hash_tbl, str, ret_hash) /* Add debugging information for a symbol. */ static localsym_t * -add_ecoff_symbol (str, type, storage, sym_value, addend, value, indx) - const char *str; /* symbol name */ - st_t type; /* symbol type */ - sc_t storage; /* storage class */ - symbolS *sym_value; /* associated symbol. */ - bfd_vma addend; /* addend to sym_value. */ - symint_t value; /* value of symbol */ - symint_t indx; /* index to local/aux. syms */ +add_ecoff_symbol (const char *str, /* symbol name */ + st_t type, /* symbol type */ + sc_t storage, /* storage class */ + symbolS *sym_value, /* associated symbol. */ + bfd_vma addend, /* addend to sym_value. */ + symint_t value, /* value of symbol */ + symint_t indx /* index to local/aux. syms */) { localsym_t *psym; register scope_t *pscope; @@ -1635,10 +1609,10 @@ add_ecoff_symbol (str, type, storage, sym_value, addend, value, indx) vp = &cur_file_ptr->symbols; - if (vp->objects_last_page == vp->objects_per_page) + if (vp->objects_last_page == vp->objects_per_page) add_varray_page (vp); - psym = &vp->last->datum->sym[ vp->objects_last_page++ ]; + psym = &vp->last->datum->sym[vp->objects_last_page++]; if (str == (const char *) NULL && sym_value != (symbolS *) NULL) psym->name = S_GET_NAME (sym_value); @@ -1704,8 +1678,8 @@ add_ecoff_symbol (str, type, storage, sym_value, addend, value, indx) scope_delta = 1; /* For every block type except file, struct, union, or - enumeration blocks, push a level on the tag stack. We omit - file types, so that tags can span file boundaries. */ + enumeration blocks, push a level on the tag stack. We omit + file types, so that tags can span file boundaries. */ if (type != st_File && storage != sc_Info) { ptag_head = allocate_thead (); @@ -1801,11 +1775,12 @@ add_ecoff_symbol (str, type, storage, sym_value, addend, value, indx) value, depth, sc_str); if (str_start && str_end_p1 - str_start > 0) - fprintf (stderr, " st= %-11s name= %.*s\n", st_str, str_end_p1 - str_start, str_start); + fprintf (stderr, " st= %-11s name= %.*s\n", + st_str, str_end_p1 - str_start, str_start); else { unsigned long len = strlen (st_str); - fprintf (stderr, " st= %.*s\n", len-1, st_str); + fprintf (stderr, " st= %.*s\n", len - 1, st_str); } } #endif @@ -1817,8 +1792,7 @@ add_ecoff_symbol (str, type, storage, sym_value, addend, value, indx) for integral aux types, not just symints. */ static symint_t -add_aux_sym_symint (aux_word) - symint_t aux_word; /* auxiliary information word */ +add_aux_sym_symint (symint_t aux_word /* auxiliary information word */) { register varray_t *vp; register aux_t *aux_ptr; @@ -1838,13 +1812,10 @@ add_aux_sym_symint (aux_word) return vp->num_allocated++; } - /* Add an auxiliary symbol (passing a file/symbol index combo). */ static symint_t -add_aux_sym_rndx (file_index, sym_index) - int file_index; - symint_t sym_index; +add_aux_sym_rndx (int file_index, symint_t sym_index) { register varray_t *vp; register aux_t *aux_ptr; @@ -1869,10 +1840,9 @@ add_aux_sym_rndx (file_index, sym_index) type qualifiers). */ static symint_t -add_aux_sym_tir (t, state, hash_tbl) - type_info_t *t; /* current type information */ - hash_state_t state; /* whether to hash type or not */ - thash_t **hash_tbl; /* pointer to hash table to use */ +add_aux_sym_tir (type_info_t *t, /* current type information */ + hash_state_t state, /* whether to hash type or not */ + thash_t **hash_tbl /* pointer to hash table to use */) { register varray_t *vp; register aux_t *aux_ptr; @@ -1898,9 +1868,8 @@ add_aux_sym_tir (t, state, hash_tbl) aux.ti.tq4 = (int) t->type_qualifiers[4]; aux.ti.tq5 = (int) t->type_qualifiers[5]; - /* For anything that adds additional information, we must not hash, - so check here, and reset our state. */ + so check here, and reset our state. */ if (state != hash_no && (t->type_qualifiers[0] == tq_Array @@ -1950,11 +1919,11 @@ add_aux_sym_tir (t, state, hash_tbl) } } - /* Everything is set up, add the aux symbol. */ + /* Everything is set up, add the aux symbol. */ if (vp->objects_last_page == vp->objects_per_page) add_varray_page (vp); - aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ]; + aux_ptr = &vp->last->datum->aux[vp->objects_last_page++]; aux_ptr->type = aux_tir; aux_ptr->data = aux; @@ -1970,8 +1939,7 @@ add_aux_sym_tir (t, state, hash_tbl) for an enum bitfield. */ if (t->bitfield) - (void) add_aux_sym_symint ((symint_t)t->sizes[t->num_sizes-1]); - + (void) add_aux_sym_symint ((symint_t) t->sizes[t->num_sizes - 1]); /* Add tag information if needed. Structure, union, and enum references add 2 aux symbols: a [file index, symbol index] @@ -1982,7 +1950,7 @@ add_aux_sym_tir (t, state, hash_tbl) || t->basic_type == bt_Enum) { register symint_t file_index = t->tag_ptr->ifd; - register localsym_t *sym = t->tag_ptr->sym; + register localsym_t *sym = t->tag_ptr->sym; register forward_t *forward_ref = allocate_forward (); if (sym != (localsym_t *) NULL) @@ -1998,11 +1966,11 @@ add_aux_sym_tir (t, state, hash_tbl) (void) add_aux_sym_rndx (ST_RFDESCAPE, indexNil); forward_ref->index_ptr - = &vp->last->datum->aux[ vp->objects_last_page - 1]; + = &vp->last->datum->aux[vp->objects_last_page - 1]; (void) add_aux_sym_symint (file_index); forward_ref->ifd_ptr - = &vp->last->datum->aux[ vp->objects_last_page - 1]; + = &vp->last->datum->aux[vp->objects_last_page - 1]; } /* Add information about array bounds if they exist. */ @@ -2020,7 +1988,7 @@ add_aux_sym_tir (t, state, hash_tbl) }; /* NOTE: Mips documentation claims that the bitfield width goes here. - But it needs to be emitted earlier. */ + But it needs to be emitted earlier. */ return ret; } @@ -2028,10 +1996,9 @@ add_aux_sym_tir (t, state, hash_tbl) /* Add a tag to the tag table (unless it already exists). */ static tag_t * -get_tag (tag, sym, basic_type) - const char *tag; /* tag name */ - localsym_t *sym; /* tag start block */ - bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */ +get_tag (const char *tag, /* tag name */ + localsym_t *sym, /* tag start block */ + bt_t basic_type /* bt_Struct, bt_Union, or bt_Enum */) { shash_t *hash_ptr; const char *err; @@ -2044,27 +2011,26 @@ get_tag (tag, sym, basic_type) if (hash_ptr != (shash_t *) NULL && hash_ptr->tag_ptr != (tag_t *) NULL) - { - tag_ptr = hash_ptr->tag_ptr; - if (sym != (localsym_t *) NULL) - { - tag_ptr->basic_type = basic_type; - tag_ptr->ifd = cur_file_ptr->file_index; - tag_ptr->sym = sym; - } - return tag_ptr; - } + { + tag_ptr = hash_ptr->tag_ptr; + if (sym != (localsym_t *) NULL) + { + tag_ptr->basic_type = basic_type; + tag_ptr->ifd = cur_file_ptr->file_index; + tag_ptr->sym = sym; + } + return tag_ptr; + } if (hash_ptr == (shash_t *) NULL) { char *perm; - perm = xmalloc ((unsigned long) (strlen (tag) + 1)); - strcpy (perm, tag); + perm = xstrdup (tag); hash_ptr = allocate_shash (); err = hash_insert (tag_hash, perm, (char *) hash_ptr); if (err) - as_fatal (_("Inserting \"%s\" into tag hash table: %s"), + as_fatal (_("inserting \"%s\" into tag hash table: %s"), tag, err); hash_ptr->string = perm; } @@ -2089,8 +2055,7 @@ get_tag (tag, sym, basic_type) /* Add an unknown {struct, union, enum} tag. */ static void -add_unknown_tag (ptag) - tag_t *ptag; /* pointer to tag information */ +add_unknown_tag (tag_t *ptag /* pointer to tag information */) { shash_t *hash_ptr = ptag->hash_ptr; char *name = hash_ptr->string; @@ -2100,7 +2065,7 @@ add_unknown_tag (ptag) #ifdef ECOFF_DEBUG if (debug > 1) { - char *agg_type = "{unknown aggregate type}"; + char *agg_type = "{unknown aggregate type}"; switch (ptag->basic_type) { case bt_Struct: agg_type = "struct"; break; @@ -2139,8 +2104,7 @@ add_unknown_tag (ptag) this is the current procedure. */ static void -add_procedure (func) - char *func; /* func name */ +add_procedure (char *func /* func name */) { register varray_t *vp; register proc_t *new_proc_ptr; @@ -2200,7 +2164,7 @@ add_procedure (func) } symbolS * -ecoff_get_cur_proc_sym () +ecoff_get_cur_proc_sym (void) { return (cur_proc_ptr ? cur_proc_ptr->sym->as_sym : NULL); } @@ -2210,10 +2174,7 @@ ecoff_get_cur_proc_sym () where the current file structure lives. */ static void -add_file (file_name, indx, fake) - const char *file_name; /* file name */ - int indx; - int fake; +add_file (const char *file_name, int indx ATTRIBUTE_UNUSED, int fake) { register int first_ch; register efdr_t *fil_ptr; @@ -2239,9 +2200,11 @@ add_file (file_name, indx, fake) this if we see a .file directive with a string, since that implies that some sort of debugging information is being provided. */ - if (! symbol_table_frozen && debug_type == DEBUG_NONE) + if (! symbol_table_frozen && debug_type == DEBUG_UNSPECIFIED) debug_type = DEBUG_ECOFF; } + else if (debug_type == DEBUG_UNSPECIFIED) + debug_type = DEBUG_NONE; #ifndef NO_LISTING if (listing) @@ -2293,7 +2256,7 @@ add_file (file_name, indx, fake) } } - /* If this is a new file, create it. */ + /* If this is a new file, create it. */ if (fil_ptr == (efdr_t *) NULL) { if (file_desc.objects_last_page == file_desc.objects_per_page) @@ -2318,7 +2281,7 @@ add_file (file_name, indx, fake) (shash_t **)0); if (strlen (file_name) > PAGE_USIZE - 2) - as_fatal (_("Filename goes over one page boundary.")); + as_fatal (_("filename goes over one page boundary")); /* Push the start of the filename. We assume that the filename will be stored at string offset 1. */ @@ -2333,7 +2296,7 @@ add_file (file_name, indx, fake) last_file_ptr = &fil_ptr->next_file; /* Add void & int types to the file (void should be first to catch - errant 0's within the index fields). */ + errant 0's within the index fields). */ fil_ptr->void_type = add_aux_sym_tir (&void_type_info, hash_yes, &cur_file_ptr->thash_head[0]); @@ -2349,8 +2312,7 @@ add_file (file_name, indx, fake) compiler output, only in hand coded assembler. */ void -ecoff_new_file (name) - const char *name; +ecoff_new_file (const char *name) { if (cur_file_ptr != NULL && strcmp (cur_file_ptr->name, name) == 0) return; @@ -2358,7 +2320,7 @@ ecoff_new_file (name) /* This is a hand coded assembler file, so automatically turn on debugging information. */ - if (debug_type == DEBUG_NONE) + if (debug_type == DEBUG_UNSPECIFIED) debug_type = DEBUG_ECOFF; } @@ -2367,10 +2329,10 @@ ecoff_new_file (name) /* Convert storage class to string. */ static char * -sc_to_string(storage_class) +sc_to_string (storage_class) sc_t storage_class; { - switch(storage_class) + switch (storage_class) { case sc_Nil: return "Nil,"; case sc_Text: return "Text,"; @@ -2408,10 +2370,10 @@ sc_to_string(storage_class) /* Convert symbol type to string. */ static char * -st_to_string(symbol_type) +st_to_string (symbol_type) st_t symbol_type; { - switch(symbol_type) + switch (symbol_type) { case st_Nil: return "Nil,"; case st_Global: return "Global,"; @@ -2445,8 +2407,7 @@ st_to_string(symbol_type) which gives the location of the start of the block. */ void -ecoff_directive_begin (ignore) - int ignore; +ecoff_directive_begin (int ignore ATTRIBUTE_UNUSED) { char *name; char name_end; @@ -2483,8 +2444,7 @@ ecoff_directive_begin (ignore) which gives the location of the end of the block. */ void -ecoff_directive_bend (ignore) - int ignore; +ecoff_directive_bend (int ignore ATTRIBUTE_UNUSED) { char *name; char name_end; @@ -2542,8 +2502,7 @@ static int coff_inside_enumeration; /* Handle a .def directive: start defining a symbol. */ void -ecoff_directive_def (ignore) - int ignore; +ecoff_directive_def (int ignore ATTRIBUTE_UNUSED) { char *name; char name_end; @@ -2558,15 +2517,15 @@ ecoff_directive_def (ignore) if (coff_sym_name != (char *) NULL) as_warn (_(".def pseudo-op used inside of .def/.endef; ignored")); else if (*name == '\0') - as_warn (_("Empty symbol name in .def; ignored")); + as_warn (_("empty symbol name in .def; ignored")); else { if (coff_sym_name != (char *) NULL) free (coff_sym_name); if (coff_tag != (char *) NULL) free (coff_tag); - coff_sym_name = (char *) xmalloc ((unsigned long) (strlen (name) + 1)); - strcpy (coff_sym_name, name); + + coff_sym_name = xstrdup (name); coff_type = type_info_init; coff_storage_class = sc_Nil; coff_symbol_typ = st_Nil; @@ -2588,8 +2547,7 @@ ecoff_directive_def (ignore) more than that anyhow, so I will also make that assumption. */ void -ecoff_directive_dim (ignore) - int ignore; +ecoff_directive_dim (int ignore ATTRIBUTE_UNUSED) { int dimens[N_TQ]; int i; @@ -2611,7 +2569,7 @@ ecoff_directive_dim (ignore) { if (*input_line_pointer != '\n' && *input_line_pointer != ';') - as_warn (_("Badly formed .dim directive")); + as_warn (_("badly formed .dim directive")); break; } } @@ -2624,7 +2582,7 @@ ecoff_directive_dim (ignore) { if (coff_type.num_dims >= N_TQ) { - as_warn (_("Too many .dim entries")); + as_warn (_("too many .dim entries")); break; } coff_type.dimensions[coff_type.num_dims] = dimens[i]; @@ -2638,8 +2596,7 @@ ecoff_directive_dim (ignore) symbol. */ void -ecoff_directive_scl (ignore) - int ignore; +ecoff_directive_scl (int ignore ATTRIBUTE_UNUSED) { long val; @@ -2663,8 +2620,7 @@ ecoff_directive_scl (ignore) never generate more than one argument. */ void -ecoff_directive_size (ignore) - int ignore; +ecoff_directive_size (int ignore ATTRIBUTE_UNUSED) { int sizes[N_TQ]; int i; @@ -2686,7 +2642,7 @@ ecoff_directive_size (ignore) { if (*input_line_pointer != '\n' && *input_line_pointer != ';') - as_warn (_("Badly formed .size directive")); + as_warn (_("badly formed .size directive")); break; } } @@ -2699,7 +2655,7 @@ ecoff_directive_size (ignore) { if (coff_type.num_sizes >= N_TQ) { - as_warn (_("Too many .size entries")); + as_warn (_("too many .size entries")); break; } coff_type.sizes[coff_type.num_sizes] = sizes[i]; @@ -2713,8 +2669,7 @@ ecoff_directive_size (ignore) symbol. */ void -ecoff_directive_type (ignore) - int ignore; +ecoff_directive_type (int ignore ATTRIBUTE_UNUSED) { long val; tq_t *tq_ptr; @@ -2733,14 +2688,14 @@ ecoff_directive_type (ignore) coff_type.basic_type = map_coff_types[coff_type.orig_type]; tq_ptr = &coff_type.type_qualifiers[N_TQ]; - while (val &~ N_BTMASK) + while (val & ~N_BTMASK) { if (tq_ptr == &coff_type.type_qualifiers[0]) { /* FIXME: We could handle this by setting the continued bit. - There would still be a limit: the .type argument can not - be infinite. */ - as_warn (_("The type of %s is too complex; it will be simplified"), + There would still be a limit: the .type argument can not + be infinite. */ + as_warn (_("the type of %s is too complex; it will be simplified"), coff_sym_name); break; } @@ -2763,11 +2718,11 @@ ecoff_directive_type (ignore) if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc) { /* If this is a function, ignore it, so that we don't get two - entries (one from the .ent, and one for the .def that - precedes it). Save the type information so that the end - block can properly add it after the begin block index. For - MIPS knows what reason, we must strip off the function type - at this point. */ + entries (one from the .ent, and one for the .def that + precedes it). Save the type information so that the end + block can properly add it after the begin block index. For + MIPS knows what reason, we must strip off the function type + at this point. */ coff_is_function = 1; tq_shft[-1] = tq_Nil; } @@ -2782,8 +2737,7 @@ ecoff_directive_type (ignore) union or enum. */ void -ecoff_directive_tag (ignore) - int ignore; +ecoff_directive_tag (int ignore ATTRIBUTE_UNUSED) { char *name; char name_end; @@ -2798,8 +2752,7 @@ ecoff_directive_tag (ignore) name = input_line_pointer; name_end = get_symbol_end (); - coff_tag = (char *) xmalloc ((unsigned long) (strlen (name) + 1)); - strcpy (coff_tag, name); + coff_tag = xstrdup (name); *input_line_pointer = name_end; @@ -2810,8 +2763,7 @@ ecoff_directive_tag (ignore) may be the name of a static or global symbol. */ void -ecoff_directive_val (ignore) - int ignore; +ecoff_directive_val (int ignore ATTRIBUTE_UNUSED) { expressionS exp; @@ -2845,8 +2797,7 @@ ecoff_directive_val (ignore) debugging information for a symbol. */ void -ecoff_directive_endef (ignore) - int ignore; +ecoff_directive_endef (int ignore ATTRIBUTE_UNUSED) { char *name; symint_t indx; @@ -2882,13 +2833,13 @@ ecoff_directive_endef (ignore) if (coff_type.num_sizes != 1 || diff < 0) { - as_warn (_("Bad COFF debugging info")); + as_warn (_("bad COFF debugging information")); return; } /* If this is an array, make sure the same number of dimensions - and sizes were passed, creating extra sizes for multiply - dimensioned arrays if not passed. */ + and sizes were passed, creating extra sizes for multiply + dimensioned arrays if not passed. */ coff_type.extra_sizes = 0; if (diff) { @@ -2913,7 +2864,7 @@ ecoff_directive_endef (ignore) && coff_type.num_sizes - coff_type.extra_sizes == 1) { /* Is this a bitfield? This is indicated by a structure memeber - having a size field that isn't an array. */ + having a size field that isn't an array. */ coff_type.bitfield = 1; } @@ -2931,7 +2882,7 @@ ecoff_directive_endef (ignore) { if (coff_tag == (char *) NULL) { - as_warn (_("No tag specified for %s"), name); + as_warn (_("no tag specified for %s"), name); return; } @@ -2958,12 +2909,12 @@ ecoff_directive_endef (ignore) break; /* For the beginning of structs, unions, and enumerations, the - size info needs to be passed in the value field. */ + size info needs to be passed in the value field. */ case st_Block: if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes != 1) { - as_warn (_("Bad COFF debugging information")); + as_warn (_("bad COFF debugging information")); return; } else @@ -2973,8 +2924,8 @@ ecoff_directive_endef (ignore) break; /* For the end of structs, unions, and enumerations, omit the - name which is always ".eos". This needs to be done last, so - that any error reporting above gives the correct name. */ + name which is always ".eos". This needs to be done last, so + that any error reporting above gives the correct name. */ case st_End: free (name); name = (char *) NULL; @@ -2983,10 +2934,10 @@ ecoff_directive_endef (ignore) break; /* Members of structures and unions that aren't bitfields, need - to adjust the value from a byte offset to a bit offset. - Members of enumerations do not have the value adjusted, and - can be distinguished by indx == indexNil. For enumerations, - update the maximum enumeration value. */ + to adjust the value from a byte offset to a bit offset. + Members of enumerations do not have the value adjusted, and + can be distinguished by indx == indexNil. For enumerations, + update the maximum enumeration value. */ case st_Member: if (! coff_type.bitfield && ! coff_inside_enumeration) coff_value *= 8; @@ -3025,12 +2976,10 @@ ecoff_directive_endef (ignore) /* Parse .end directives. */ void -ecoff_directive_end (ignore) - int ignore; +ecoff_directive_end (int ignore ATTRIBUTE_UNUSED) { char *name; char name_end; - register int ch; symbolS *ent; if (cur_file_ptr == (efdr_t *) NULL) @@ -3050,8 +2999,7 @@ ecoff_directive_end (ignore) name = input_line_pointer; name_end = get_symbol_end (); - ch = *name; - if (! is_name_beginner (ch)) + if (name == input_line_pointer) { as_warn (_(".end directive has no name")); *input_line_pointer = name_end; @@ -3082,12 +3030,10 @@ ecoff_directive_end (ignore) /* Parse .ent directives. */ void -ecoff_directive_ent (ignore) - int ignore; +ecoff_directive_ent (int ignore ATTRIBUTE_UNUSED) { char *name; char name_end; - register int ch; if (cur_file_ptr == (efdr_t *) NULL) add_file ((const char *) NULL, 0, 1); @@ -3102,8 +3048,7 @@ ecoff_directive_ent (ignore) name = input_line_pointer; name_end = get_symbol_end (); - ch = *name; - if (! is_name_beginner (ch)) + if (name == input_line_pointer) { as_warn (_(".ent directive has no name")); *input_line_pointer = name_end; @@ -3125,7 +3070,7 @@ ecoff_directive_ent (ignore) ++input_line_pointer; SKIP_WHITESPACE (); } - if (isdigit ((unsigned char) *input_line_pointer) + if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-') (void) get_absolute_expression (); @@ -3135,8 +3080,7 @@ ecoff_directive_ent (ignore) /* Parse .extern directives. */ void -ecoff_directive_extern (ignore) - int ignore; +ecoff_directive_extern (int ignore ATTRIBUTE_UNUSED) { char *name; int c; @@ -3160,8 +3104,7 @@ ecoff_directive_extern (ignore) /* Parse .file directives. */ void -ecoff_directive_file (ignore) - int ignore; +ecoff_directive_file (int ignore ATTRIBUTE_UNUSED) { int indx; char *name; @@ -3169,7 +3112,7 @@ ecoff_directive_file (ignore) if (cur_proc_ptr != (proc_t *) NULL) { - as_warn (_("No way to handle .file within .ent/.end section")); + as_warn (_("no way to handle .file within .ent/.end section")); demand_empty_rest_of_line (); return; } @@ -3187,8 +3130,7 @@ ecoff_directive_file (ignore) /* Parse .fmask directives. */ void -ecoff_directive_fmask (ignore) - int ignore; +ecoff_directive_fmask (int ignore ATTRIBUTE_UNUSED) { long val; @@ -3201,7 +3143,7 @@ ecoff_directive_fmask (ignore) if (get_absolute_expression_and_terminator (&val) != ',') { - as_warn (_("Bad .fmask directive")); + as_warn (_("bad .fmask directive")); --input_line_pointer; demand_empty_rest_of_line (); return; @@ -3216,8 +3158,7 @@ ecoff_directive_fmask (ignore) /* Parse .frame directives. */ void -ecoff_directive_frame (ignore) - int ignore; +ecoff_directive_frame (int ignore ATTRIBUTE_UNUSED) { long val; @@ -3234,7 +3175,7 @@ ecoff_directive_frame (ignore) if (*input_line_pointer++ != ',' || get_absolute_expression_and_terminator (&val) != ',') { - as_warn (_("Bad .frame directive")); + as_warn (_("bad .frame directive")); --input_line_pointer; demand_empty_rest_of_line (); return; @@ -3244,9 +3185,10 @@ ecoff_directive_frame (ignore) cur_proc_ptr->pdr.pcreg = tc_get_register (0); -#if 0 /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according - to Sandro. I don't yet know where this value should be stored, if - anywhere. */ +#if 0 + /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to + Sandro. I don't yet know where this value should be stored, if + anywhere. */ demand_empty_rest_of_line (); #else s_ignore (42); @@ -3256,8 +3198,7 @@ ecoff_directive_frame (ignore) /* Parse .mask directives. */ void -ecoff_directive_mask (ignore) - int ignore; +ecoff_directive_mask (int ignore ATTRIBUTE_UNUSED) { long val; @@ -3270,7 +3211,7 @@ ecoff_directive_mask (ignore) if (get_absolute_expression_and_terminator (&val) != ',') { - as_warn (_("Bad .mask directive")); + as_warn (_("bad .mask directive")); --input_line_pointer; demand_empty_rest_of_line (); return; @@ -3285,8 +3226,7 @@ ecoff_directive_mask (ignore) /* Parse .loc directives. */ void -ecoff_directive_loc (ignore) - int ignore; +ecoff_directive_loc (int ignore ATTRIBUTE_UNUSED) { lineno_list_t *list; symint_t lineno; @@ -3366,9 +3306,7 @@ ecoff_directive_loc (ignore) information so that it points to the instruction after the nop. */ void -ecoff_fix_loc (old_frag, old_frag_offset) - fragS *old_frag; - unsigned long old_frag_offset; +ecoff_fix_loc (fragS *old_frag, unsigned long old_frag_offset) { if (last_lineno != NULL && last_lineno->frag == old_frag @@ -3382,12 +3320,11 @@ ecoff_fix_loc (old_frag, old_frag_offset) /* Make sure the @stabs symbol is emitted. */ static void -mark_stabs (ignore) - int ignore; +mark_stabs (int ignore ATTRIBUTE_UNUSED) { if (! stabs_seen) { - /* Add a dummy @stabs dymbol. */ + /* Add a dummy @stabs dymbol. */ stabs_seen = 1; (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo, (symbolS *) NULL, @@ -3398,10 +3335,9 @@ mark_stabs (ignore) /* Parse .weakext directives. */ #ifndef TC_MIPS -/* For TC_MIPS use the version in tc-mips.c. */ +/* For TC_MIPS use the version in tc-mips.c. */ void -ecoff_directive_weakext (ignore) - int ignore; +ecoff_directive_weakext (int ignore ATTRIBUTE_UNUSED) { char *name; int c; @@ -3419,7 +3355,7 @@ ecoff_directive_weakext (ignore) { if (S_IS_DEFINED (symbolP)) { - as_bad (_("Ignoring attempt to redefine symbol `%s'."), + as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP)); ignore_rest_of_line (); return; @@ -3433,7 +3369,7 @@ ecoff_directive_weakext (ignore) if (exp.X_op != O_symbol) { as_bad (_("bad .weakext directive")); - ignore_rest_of_line(); + ignore_rest_of_line (); return; } symbol_set_value_expression (symbolP, &exp); @@ -3479,13 +3415,12 @@ ecoff_directive_weakext (ignore) value a numeric value or an address. */ void -ecoff_stab (sec, what, string, type, other, desc) - segT sec; - int what; - const char *string; - int type; - int other; - int desc; +ecoff_stab (segT sec ATTRIBUTE_UNUSED, + int what, + const char *string, + int type, + int other, + int desc) { efdr_t *save_file_ptr = cur_file_ptr; symbolS *sym; @@ -3545,7 +3480,7 @@ ecoff_stab (sec, what, string, type, other, desc) dummy_symr.index = desc; if (dummy_symr.index != desc) { - as_warn (_("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)"), + as_warn (_("line number (%d) for .stab%c directive cannot fit in index field (20 bits)"), desc, what); return; } @@ -3569,7 +3504,7 @@ ecoff_stab (sec, what, string, type, other, desc) listing_source_file (string); #endif - if (isdigit ((unsigned char) *input_line_pointer) + if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-' || *input_line_pointer == '+') { @@ -3581,7 +3516,7 @@ ecoff_stab (sec, what, string, type, other, desc) } else if (! is_name_beginner ((unsigned char) *input_line_pointer)) { - as_warn (_("Illegal .stab%c directive, bad character"), what); + as_warn (_("illegal .stab%c directive, bad character"), what); return; } else @@ -3634,8 +3569,7 @@ ecoff_stab (sec, what, string, type, other, desc) .scommon section rather than bfd_com_section. */ void -ecoff_frob_symbol (sym) - symbolS *sym; +ecoff_frob_symbol (symbolS *sym) { if (S_IS_COMMON (sym) && S_GET_VALUE (sym) > 0 @@ -3645,7 +3579,7 @@ ecoff_frob_symbol (sym) static asymbol scom_symbol; /* We must construct a fake section similar to bfd_com_section - but with the name .scommon. */ + but with the name .scommon. */ if (scom_section.name == NULL) { scom_section = bfd_com_section; @@ -3664,7 +3598,7 @@ ecoff_frob_symbol (sym) if (S_IS_WEAK (sym)) { if (S_IS_COMMON (sym)) - as_bad (_("Symbol `%s' can not be both weak and common"), + as_bad (_("symbol `%s' can not be both weak and common"), S_GET_NAME (sym)); } } @@ -3672,11 +3606,10 @@ ecoff_frob_symbol (sym) /* Add bytes to the symbolic information buffer. */ static char * -ecoff_add_bytes (buf, bufend, bufptr, need) - char **buf; - char **bufend; - char *bufptr; - unsigned long need; +ecoff_add_bytes (char **buf, + char **bufend, + char *bufptr, + unsigned long need) { unsigned long at; unsigned long want; @@ -3695,12 +3628,11 @@ ecoff_add_bytes (buf, bufend, bufptr, need) for the ECOFF target debugging information. */ static unsigned long -ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr) - const struct ecoff_debug_swap *backend; - char **buf; - char **bufend; - unsigned long offset; - char **bufptrptr; +ecoff_padding_adjust (const struct ecoff_debug_swap *backend, + char **buf, + char **bufend, + unsigned long offset, + char **bufptrptr) { bfd_size_type align; @@ -3710,7 +3642,7 @@ ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr) unsigned long add; add = align - (offset & (align - 1)); - if (*bufend - (*buf + offset) < add) + if ((unsigned long) (*bufend - (*buf + offset)) < add) (void) ecoff_add_bytes (buf, bufend, *buf + offset, add); memset (*buf + offset, 0, add); offset += add; @@ -3724,12 +3656,11 @@ ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr) /* Build the line number information. */ static unsigned long -ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) - const struct ecoff_debug_swap *backend; - char **buf; - char **bufend; - unsigned long offset; - long *linecntptr; +ecoff_build_lineno (const struct ecoff_debug_swap *backend, + char **buf, + char **bufend, + unsigned long offset, + long *linecntptr) { char *bufptr; register lineno_list_t *l; @@ -3760,7 +3691,7 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) embedded PIC code, it will put strings in the .text section before the first procedure. We cope by inserting a dummy line if the address of the first procedure is not 0. Hopefully this - won't screw things up too badly. + won't screw things up too badly. Don't do this for ECOFF assembly source line numbers. They work without this extra attention. */ @@ -3788,8 +3719,8 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) long delta; /* Get the offset to the memory address of the next line number - (in words). Do this first, so that we can skip ahead to the - next useful line number entry. */ + (in words). Do this first, so that we can skip ahead to the + next useful line number entry. */ if (l->next == (lineno_list_t *) NULL) { /* We want a count of zero, but it will be decremented @@ -3954,14 +3885,13 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) /* Build and swap out the symbols. */ static unsigned long -ecoff_build_symbols (backend, buf, bufend, offset) - const struct ecoff_debug_swap *backend; - char **buf; - char **bufend; - unsigned long offset; +ecoff_build_symbols (const struct ecoff_debug_swap *backend, + char **buf, + char **bufend, + unsigned long offset) { const bfd_size_type external_sym_size = backend->external_sym_size; - void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR)) + void (* const swap_sym_out) (bfd *, const SYMR *, PTR) = backend->swap_sym_out; char *sym_out; long isym; @@ -4029,11 +3959,11 @@ ecoff_build_symbols (backend, buf, bufend, offset) symint_t indx; /* The value of a block start symbol is the - offset from the start of the procedure. For - other symbols we just use the gas value (but - we must offset it by the vma of the section, - just as BFD does, because BFD will not see - this value). */ + offset from the start of the procedure. For + other symbols we just use the gas value (but + we must offset it by the vma of the section, + just as BFD does, because BFD will not see + this value). */ if (sym_ptr->ecoff_sym.asym.st == (int) st_Block && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text) { @@ -4065,8 +3995,8 @@ ecoff_build_symbols (backend, buf, bufend, offset) sym_ptr->ecoff_sym.asym.st = st_StaticProc; /* Get the type and storage class based on where - the symbol actually wound up. Traditionally, - N_LBRAC and N_RBRAC are *not* relocated. */ + the symbol actually wound up. Traditionally, + N_LBRAC and N_RBRAC are *not* relocated. */ indx = sym_ptr->ecoff_sym.asym.index; if (sym_ptr->ecoff_sym.asym.st == st_Nil && sym_ptr->ecoff_sym.asym.sc == sc_Nil @@ -4142,8 +4072,8 @@ ecoff_build_symbols (backend, buf, bufend, offset) else { /* This must be a user named section. - This is not possible in ECOFF, but it - is in ELF. */ + This is not possible in ECOFF, but it + is in ELF. */ sc = sc_Data; } @@ -4152,11 +4082,11 @@ ecoff_build_symbols (backend, buf, bufend, offset) } /* This is just an external symbol if it is - outside a procedure and it has a type. - FIXME: g++ will generate symbols which have - different names in the debugging information - than the actual symbol. Should we handle - them here? */ + outside a procedure and it has a type. + FIXME: g++ will generate symbols which have + different names in the debugging information + than the actual symbol. Should we handle + them here? */ if ((S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym) || ! S_IS_DEFINED (as_sym)) @@ -4166,14 +4096,14 @@ ecoff_build_symbols (backend, buf, bufend, offset) local = 0; /* This is just an external symbol if it is a - common symbol. */ + common symbol. */ if (S_IS_COMMON (as_sym)) local = 0; /* If an st_end symbol has an associated gas - symbol, then it is a local label created for - a .bend or .end directive. Stabs line - numbers will have \001 in the names. */ + symbol, then it is a local label created for + a .bend or .end directive. Stabs line + numbers will have \001 in the names. */ if (local && sym_ptr->ecoff_sym.asym.st != st_End && strchr (sym_ptr->name, '\001') == 0) @@ -4221,10 +4151,10 @@ ecoff_build_symbols (backend, buf, bufend, offset) } /* The value of the symbol marking the end of a - procedure is the size of the procedure. The - value of the symbol marking the end of a - block is the offset from the start of the - procedure to the block. */ + procedure is the size of the procedure. The + value of the symbol marking the end of a + block is the offset from the start of the + procedure to the block. */ if (begin_type == st_Proc || begin_type == st_StaticProc) { @@ -4238,7 +4168,7 @@ ecoff_build_symbols (backend, buf, bufend, offset) - S_GET_VALUE (begin_ptr->as_sym)); /* If the size is odd, this is probably a - mips16 function; force it to be even. */ + mips16 function; force it to be even. */ if ((sym_ptr->ecoff_sym.asym.value & 1) != 0) ++sym_ptr->ecoff_sym.asym.value; @@ -4274,7 +4204,7 @@ ecoff_build_symbols (backend, buf, bufend, offset) if (local) { - if (*bufend - sym_out < external_sym_size) + if ((bfd_size_type)(*bufend - sym_out) < external_sym_size) sym_out = ecoff_add_bytes (buf, bufend, sym_out, external_sym_size); @@ -4304,7 +4234,7 @@ ecoff_build_symbols (backend, buf, bufend, offset) sym_ptr->ecoff_sym.ifd = fil_ptr->file_index; /* Don't try to merge an FDR which has an - external symbol attached to it. */ + external symbol attached to it. */ if (S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym)) fil_ptr->fdr.fMerge = 0; } @@ -4320,14 +4250,13 @@ ecoff_build_symbols (backend, buf, bufend, offset) /* Swap out the procedure information. */ static unsigned long -ecoff_build_procs (backend, buf, bufend, offset) - const struct ecoff_debug_swap *backend; - char **buf; - char **bufend; - unsigned long offset; +ecoff_build_procs (const struct ecoff_debug_swap *backend, + char **buf, + char **bufend, + unsigned long offset) { const bfd_size_type external_pdr_size = backend->external_pdr_size; - void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR)) + void (* const swap_pdr_out) (bfd *, const PDR *, PTR) = backend->swap_pdr_out; char *pdr_out; long iproc; @@ -4385,14 +4314,14 @@ ecoff_build_procs (backend, buf, bufend, offset) if (first) { /* This code used to force the adr of the very - first fdr to be 0. However, the native tools - don't do that, and I can't remember why it - used to work that way, so I took it out. */ + first fdr to be 0. However, the native tools + don't do that, and I can't remember why it + used to work that way, so I took it out. */ fil_ptr->fdr.adr = adr; first = 0; } proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr; - if (*bufend - pdr_out < external_pdr_size) + if ((bfd_size_type)(*bufend - pdr_out) < external_pdr_size) pdr_out = ecoff_add_bytes (buf, bufend, pdr_out, external_pdr_size); @@ -4411,11 +4340,10 @@ ecoff_build_procs (backend, buf, bufend, offset) /* Swap out the aux information. */ static unsigned long -ecoff_build_aux (backend, buf, bufend, offset) - const struct ecoff_debug_swap *backend; - char **buf; - char **bufend; - unsigned long offset; +ecoff_build_aux (const struct ecoff_debug_swap *backend, + char **buf, + char **bufend, + unsigned long offset) { int bigendian; union aux_ext *aux_out; @@ -4465,7 +4393,8 @@ ecoff_build_aux (backend, buf, bufend, offset) aux_end = aux_ptr + aux_cnt; for (; aux_ptr < aux_end; aux_ptr++) { - if (*bufend - (char *) aux_out < sizeof (union aux_ext)) + if ((unsigned long) (*bufend - (char *) aux_out) + < sizeof (union aux_ext)) aux_out = ((union aux_ext *) ecoff_add_bytes (buf, bufend, (char *) aux_out, @@ -4525,11 +4454,10 @@ ecoff_build_aux (backend, buf, bufend, offset) bytes copied, rather than the new offset. */ static unsigned long -ecoff_build_strings (buf, bufend, offset, vp) - char **buf; - char **bufend; - unsigned long offset; - varray_t *vp; +ecoff_build_strings (char **buf, + char **bufend, + unsigned long offset, + varray_t *vp) { unsigned long istr; char *str_out; @@ -4550,7 +4478,7 @@ ecoff_build_strings (buf, bufend, offset, vp) else str_cnt = vp->objects_per_page; - if (*bufend - str_out < str_cnt) + if ((unsigned long)(*bufend - str_out) < str_cnt) str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt); memcpy (str_out, str_link->datum->byte, str_cnt); @@ -4564,11 +4492,10 @@ ecoff_build_strings (buf, bufend, offset, vp) /* Dump out the local strings. */ static unsigned long -ecoff_build_ss (backend, buf, bufend, offset) - const struct ecoff_debug_swap *backend; - char **buf; - char **bufend; - unsigned long offset; +ecoff_build_ss (const struct ecoff_debug_swap *backend, + char **buf, + char **bufend, + unsigned long offset) { long iss; vlinks_t *file_link; @@ -4608,14 +4535,13 @@ ecoff_build_ss (backend, buf, bufend, offset) /* Swap out the file descriptors. */ static unsigned long -ecoff_build_fdr (backend, buf, bufend, offset) - const struct ecoff_debug_swap *backend; - char **buf; - char **bufend; - unsigned long offset; +ecoff_build_fdr (const struct ecoff_debug_swap *backend, + char **buf, + char **bufend, + unsigned long offset) { const bfd_size_type external_fdr_size = backend->external_fdr_size; - void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR)) + void (* const swap_fdr_out) (bfd *, const FDR *, PTR) = backend->swap_fdr_out; long ifile; char *fdr_out; @@ -4641,7 +4567,7 @@ ecoff_build_fdr (backend, buf, bufend, offset) fil_end = fil_ptr + fil_cnt; for (; fil_ptr < fil_end; fil_ptr++) { - if (*bufend - fdr_out < external_fdr_size) + if ((bfd_size_type)(*bufend - fdr_out) < external_fdr_size) fdr_out = ecoff_add_bytes (buf, bufend, fdr_out, external_fdr_size); (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out); @@ -4658,7 +4584,7 @@ ecoff_build_fdr (backend, buf, bufend, offset) calls a backend function to deal with it. */ static void -ecoff_setup_ext () +ecoff_setup_ext (void) { register symbolS *sym; @@ -4688,10 +4614,9 @@ ecoff_setup_ext () /* Build the ECOFF debugging information. */ unsigned long -ecoff_build_debug (hdr, bufp, backend) - HDRR *hdr; - char **bufp; - const struct ecoff_debug_swap *backend; +ecoff_build_debug (HDRR *hdr, + char **bufp, + const struct ecoff_debug_swap *backend) { const bfd_size_type external_pdr_size = backend->external_pdr_size; tag_t *ptag; @@ -4699,7 +4624,7 @@ ecoff_build_debug (hdr, bufp, backend) efdr_t *fil_ptr; int end_warning; efdr_t *hold_file_ptr; - proc_t * hold_proc_ptr; + proc_t *hold_proc_ptr; symbolS *sym; char *buf; char *bufend; @@ -4758,7 +4683,7 @@ ecoff_build_debug (hdr, bufp, backend) cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev; if (! end_warning && ! cur_file_ptr->fake) { - as_warn (_("Missing .end or .bend at end of file")); + as_warn (_("missing .end or .bend at end of file")); end_warning = 1; } } @@ -4791,7 +4716,7 @@ ecoff_build_debug (hdr, bufp, backend) space at this point. */ hdr->ipdMax = proc_cnt; hdr->cbPdOffset = offset; - if (bufend - (buf + offset) < proc_cnt * external_pdr_size) + if ((bfd_size_type)(bufend - (buf + offset)) < proc_cnt * external_pdr_size) (void) ecoff_add_bytes (&buf, &bufend, buf + offset, proc_cnt * external_pdr_size); offset += proc_cnt * external_pdr_size; @@ -4855,8 +4780,7 @@ ecoff_build_debug (hdr, bufp, backend) #ifndef MALLOC_CHECK static page_type * -allocate_cluster (npages) - unsigned long npages; +allocate_cluster (unsigned long npages) { register page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE); @@ -4870,7 +4794,6 @@ allocate_cluster (npages) return value; } - static page_type *cluster_ptr = NULL; static unsigned long pages_left = 0; @@ -4879,7 +4802,7 @@ static unsigned long pages_left = 0; /* Allocate one page (which is initialized to 0). */ static page_type * -allocate_page () +allocate_page (void) { #ifndef MALLOC_CHECK @@ -4892,7 +4815,7 @@ allocate_page () pages_left--; return cluster_ptr++; -#else /* MALLOC_CHECK */ +#else /* MALLOC_CHECK */ page_type *ptr; @@ -4900,36 +4823,36 @@ allocate_page () memset (ptr, 0, PAGE_USIZE); return ptr; -#endif /* MALLOC_CHECK */ +#endif /* MALLOC_CHECK */ } /* Allocate scoping information. */ static scope_t * -allocate_scope () +allocate_scope (void) { register scope_t *ptr; static scope_t initial_scope; #ifndef MALLOC_CHECK - ptr = alloc_counts[(int)alloc_type_scope].free_list.f_scope; + ptr = alloc_counts[(int) alloc_type_scope].free_list.f_scope; if (ptr != (scope_t *) NULL) - alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr->free; + alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr->free; else { - register int unallocated = alloc_counts[(int)alloc_type_scope].unallocated; - register page_type *cur_page = alloc_counts[(int)alloc_type_scope].cur_page; + register int unallocated = alloc_counts[(int) alloc_type_scope].unallocated; + register page_type *cur_page = alloc_counts[(int) alloc_type_scope].cur_page; if (unallocated == 0) { unallocated = PAGE_SIZE / sizeof (scope_t); - alloc_counts[(int)alloc_type_scope].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_scope].total_pages++; + alloc_counts[(int) alloc_type_scope].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_scope].total_pages++; } ptr = &cur_page->scope[--unallocated]; - alloc_counts[(int)alloc_type_scope].unallocated = unallocated; + alloc_counts[(int) alloc_type_scope].unallocated = unallocated; } #else @@ -4938,7 +4861,7 @@ allocate_scope () #endif - alloc_counts[(int)alloc_type_scope].total_alloc++; + alloc_counts[(int) alloc_type_scope].total_alloc++; *ptr = initial_scope; return ptr; } @@ -4946,14 +4869,13 @@ allocate_scope () /* Free scoping information. */ static void -free_scope (ptr) - scope_t *ptr; +free_scope (scope_t *ptr) { - alloc_counts[(int)alloc_type_scope].total_free++; + alloc_counts[(int) alloc_type_scope].total_free++; #ifndef MALLOC_CHECK - ptr->free = alloc_counts[(int)alloc_type_scope].free_list.f_scope; - alloc_counts[(int)alloc_type_scope].free_list.f_scope = ptr; + ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope; + alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr; #else free ((PTR) ptr); #endif @@ -4962,25 +4884,25 @@ free_scope (ptr) /* Allocate links for pages in a virtual array. */ static vlinks_t * -allocate_vlinks () +allocate_vlinks (void) { register vlinks_t *ptr; static vlinks_t initial_vlinks; #ifndef MALLOC_CHECK - register int unallocated = alloc_counts[(int)alloc_type_vlinks].unallocated; - register page_type *cur_page = alloc_counts[(int)alloc_type_vlinks].cur_page; + register int unallocated = alloc_counts[(int) alloc_type_vlinks].unallocated; + register page_type *cur_page = alloc_counts[(int) alloc_type_vlinks].cur_page; if (unallocated == 0) { unallocated = PAGE_SIZE / sizeof (vlinks_t); - alloc_counts[(int)alloc_type_vlinks].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_vlinks].total_pages++; + alloc_counts[(int) alloc_type_vlinks].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_vlinks].total_pages++; } ptr = &cur_page->vlinks[--unallocated]; - alloc_counts[(int)alloc_type_vlinks].unallocated = unallocated; + alloc_counts[(int) alloc_type_vlinks].unallocated = unallocated; #else @@ -4988,7 +4910,7 @@ allocate_vlinks () #endif - alloc_counts[(int)alloc_type_vlinks].total_alloc++; + alloc_counts[(int) alloc_type_vlinks].total_alloc++; *ptr = initial_vlinks; return ptr; } @@ -4996,25 +4918,25 @@ allocate_vlinks () /* Allocate string hash buckets. */ static shash_t * -allocate_shash () +allocate_shash (void) { register shash_t *ptr; static shash_t initial_shash; #ifndef MALLOC_CHECK - register int unallocated = alloc_counts[(int)alloc_type_shash].unallocated; - register page_type *cur_page = alloc_counts[(int)alloc_type_shash].cur_page; + register int unallocated = alloc_counts[(int) alloc_type_shash].unallocated; + register page_type *cur_page = alloc_counts[(int) alloc_type_shash].cur_page; if (unallocated == 0) { unallocated = PAGE_SIZE / sizeof (shash_t); - alloc_counts[(int)alloc_type_shash].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_shash].total_pages++; + alloc_counts[(int) alloc_type_shash].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_shash].total_pages++; } ptr = &cur_page->shash[--unallocated]; - alloc_counts[(int)alloc_type_shash].unallocated = unallocated; + alloc_counts[(int) alloc_type_shash].unallocated = unallocated; #else @@ -5022,7 +4944,7 @@ allocate_shash () #endif - alloc_counts[(int)alloc_type_shash].total_alloc++; + alloc_counts[(int) alloc_type_shash].total_alloc++; *ptr = initial_shash; return ptr; } @@ -5030,25 +4952,25 @@ allocate_shash () /* Allocate type hash buckets. */ static thash_t * -allocate_thash () +allocate_thash (void) { register thash_t *ptr; static thash_t initial_thash; #ifndef MALLOC_CHECK - register int unallocated = alloc_counts[(int)alloc_type_thash].unallocated; - register page_type *cur_page = alloc_counts[(int)alloc_type_thash].cur_page; + register int unallocated = alloc_counts[(int) alloc_type_thash].unallocated; + register page_type *cur_page = alloc_counts[(int) alloc_type_thash].cur_page; if (unallocated == 0) { unallocated = PAGE_SIZE / sizeof (thash_t); - alloc_counts[(int)alloc_type_thash].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_thash].total_pages++; + alloc_counts[(int) alloc_type_thash].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_thash].total_pages++; } ptr = &cur_page->thash[--unallocated]; - alloc_counts[(int)alloc_type_thash].unallocated = unallocated; + alloc_counts[(int) alloc_type_thash].unallocated = unallocated; #else @@ -5056,7 +4978,7 @@ allocate_thash () #endif - alloc_counts[(int)alloc_type_thash].total_alloc++; + alloc_counts[(int) alloc_type_thash].total_alloc++; *ptr = initial_thash; return ptr; } @@ -5064,30 +4986,30 @@ allocate_thash () /* Allocate structure, union, or enum tag information. */ static tag_t * -allocate_tag () +allocate_tag (void) { register tag_t *ptr; static tag_t initial_tag; #ifndef MALLOC_CHECK - ptr = alloc_counts[(int)alloc_type_tag].free_list.f_tag; + ptr = alloc_counts[(int) alloc_type_tag].free_list.f_tag; if (ptr != (tag_t *) NULL) - alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr->free; + alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr->free; else { - register int unallocated = alloc_counts[(int)alloc_type_tag].unallocated; - register page_type *cur_page = alloc_counts[(int)alloc_type_tag].cur_page; + register int unallocated = alloc_counts[(int) alloc_type_tag].unallocated; + register page_type *cur_page = alloc_counts[(int) alloc_type_tag].cur_page; if (unallocated == 0) { unallocated = PAGE_SIZE / sizeof (tag_t); - alloc_counts[(int)alloc_type_tag].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_tag].total_pages++; + alloc_counts[(int) alloc_type_tag].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_tag].total_pages++; } ptr = &cur_page->tag[--unallocated]; - alloc_counts[(int)alloc_type_tag].unallocated = unallocated; + alloc_counts[(int) alloc_type_tag].unallocated = unallocated; } #else @@ -5096,7 +5018,7 @@ allocate_tag () #endif - alloc_counts[(int)alloc_type_tag].total_alloc++; + alloc_counts[(int) alloc_type_tag].total_alloc++; *ptr = initial_tag; return ptr; } @@ -5104,14 +5026,13 @@ allocate_tag () /* Free scoping information. */ static void -free_tag (ptr) - tag_t *ptr; +free_tag (tag_t *ptr) { - alloc_counts[(int)alloc_type_tag].total_free++; + alloc_counts[(int) alloc_type_tag].total_free++; #ifndef MALLOC_CHECK - ptr->free = alloc_counts[(int)alloc_type_tag].free_list.f_tag; - alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr; + ptr->free = alloc_counts[(int) alloc_type_tag].free_list.f_tag; + alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr; #else free ((PTR_T) ptr); #endif @@ -5120,25 +5041,25 @@ free_tag (ptr) /* Allocate forward reference to a yet unknown tag. */ static forward_t * -allocate_forward () +allocate_forward (void) { register forward_t *ptr; static forward_t initial_forward; #ifndef MALLOC_CHECK - register int unallocated = alloc_counts[(int)alloc_type_forward].unallocated; - register page_type *cur_page = alloc_counts[(int)alloc_type_forward].cur_page; + register int unallocated = alloc_counts[(int) alloc_type_forward].unallocated; + register page_type *cur_page = alloc_counts[(int) alloc_type_forward].cur_page; if (unallocated == 0) { unallocated = PAGE_SIZE / sizeof (forward_t); - alloc_counts[(int)alloc_type_forward].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_forward].total_pages++; + alloc_counts[(int) alloc_type_forward].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_forward].total_pages++; } ptr = &cur_page->forward[--unallocated]; - alloc_counts[(int)alloc_type_forward].unallocated = unallocated; + alloc_counts[(int) alloc_type_forward].unallocated = unallocated; #else @@ -5146,7 +5067,7 @@ allocate_forward () #endif - alloc_counts[(int)alloc_type_forward].total_alloc++; + alloc_counts[(int) alloc_type_forward].total_alloc++; *ptr = initial_forward; return ptr; } @@ -5154,30 +5075,30 @@ allocate_forward () /* Allocate head of type hash list. */ static thead_t * -allocate_thead () +allocate_thead (void) { register thead_t *ptr; static thead_t initial_thead; #ifndef MALLOC_CHECK - ptr = alloc_counts[(int)alloc_type_thead].free_list.f_thead; + ptr = alloc_counts[(int) alloc_type_thead].free_list.f_thead; if (ptr != (thead_t *) NULL) - alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr->free; + alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr->free; else { - register int unallocated = alloc_counts[(int)alloc_type_thead].unallocated; - register page_type *cur_page = alloc_counts[(int)alloc_type_thead].cur_page; + register int unallocated = alloc_counts[(int) alloc_type_thead].unallocated; + register page_type *cur_page = alloc_counts[(int) alloc_type_thead].cur_page; if (unallocated == 0) { unallocated = PAGE_SIZE / sizeof (thead_t); - alloc_counts[(int)alloc_type_thead].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_thead].total_pages++; + alloc_counts[(int) alloc_type_thead].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_thead].total_pages++; } ptr = &cur_page->thead[--unallocated]; - alloc_counts[(int)alloc_type_thead].unallocated = unallocated; + alloc_counts[(int) alloc_type_thead].unallocated = unallocated; } #else @@ -5186,7 +5107,7 @@ allocate_thead () #endif - alloc_counts[(int)alloc_type_thead].total_alloc++; + alloc_counts[(int) alloc_type_thead].total_alloc++; *ptr = initial_thead; return ptr; } @@ -5194,39 +5115,38 @@ allocate_thead () /* Free scoping information. */ static void -free_thead (ptr) - thead_t *ptr; +free_thead (thead_t *ptr) { - alloc_counts[(int)alloc_type_thead].total_free++; + alloc_counts[(int) alloc_type_thead].total_free++; #ifndef MALLOC_CHECK - ptr->free = (thead_t *) alloc_counts[(int)alloc_type_thead].free_list.f_thead; - alloc_counts[(int)alloc_type_thead].free_list.f_thead = ptr; + ptr->free = (thead_t *) alloc_counts[(int) alloc_type_thead].free_list.f_thead; + alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr; #else free ((PTR_T) ptr); #endif } static lineno_list_t * -allocate_lineno_list () +allocate_lineno_list (void) { register lineno_list_t *ptr; static lineno_list_t initial_lineno_list; #ifndef MALLOC_CHECK - register int unallocated = alloc_counts[(int)alloc_type_lineno].unallocated; - register page_type *cur_page = alloc_counts[(int)alloc_type_lineno].cur_page; + register int unallocated = alloc_counts[(int) alloc_type_lineno].unallocated; + register page_type *cur_page = alloc_counts[(int) alloc_type_lineno].cur_page; if (unallocated == 0) { unallocated = PAGE_SIZE / sizeof (lineno_list_t); - alloc_counts[(int)alloc_type_lineno].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_lineno].total_pages++; + alloc_counts[(int) alloc_type_lineno].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_lineno].total_pages++; } ptr = &cur_page->lineno[--unallocated]; - alloc_counts[(int)alloc_type_lineno].unallocated = unallocated; + alloc_counts[(int) alloc_type_lineno].unallocated = unallocated; #else @@ -5234,14 +5154,13 @@ allocate_lineno_list () #endif - alloc_counts[(int)alloc_type_lineno].total_alloc++; + alloc_counts[(int) alloc_type_lineno].total_alloc++; *ptr = initial_lineno_list; return ptr; } void -ecoff_set_gp_prolog_size (sz) - int sz; +ecoff_set_gp_prolog_size (int sz) { if (cur_proc_ptr == 0) return; @@ -5256,14 +5175,14 @@ ecoff_set_gp_prolog_size (sz) cur_proc_ptr->pdr.gp_used = 1; } -int -ecoff_no_current_file () +int +ecoff_no_current_file (void) { return cur_file_ptr == (efdr_t *) NULL; } void -ecoff_generate_asm_lineno () +ecoff_generate_asm_lineno (void) { unsigned int lineno; char *filename; @@ -5271,7 +5190,7 @@ ecoff_generate_asm_lineno () as_where (&filename, &lineno); - if (current_stabs_filename == (char *)NULL + if (current_stabs_filename == (char *) NULL || strcmp (current_stabs_filename, filename)) add_file (filename, 0, 1); @@ -5296,7 +5215,7 @@ ecoff_generate_asm_lineno () pl = &noproc_lineno; while (*pl != (lineno_list_t *) NULL) - pl = &(*pl)->next; + pl = &(*pl)->next; *pl = list; } else @@ -5310,7 +5229,7 @@ ecoff_generate_asm_lineno () #else void -ecoff_generate_asm_lineno () +ecoff_generate_asm_lineno (void) { }