X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fmips-tfile.c;h=7a122a1e88a944d2178cef4a677d8536ca786db4;hp=70f580a76b70e0723d64703d62fb46e0138fb685;hb=40d0b157c55ed92f3e2d8613ea3f2bf193274552;hpb=ebae5c09ae356c87576d6a210b0b84485ef27099 diff --git a/gcc/mips-tfile.c b/gcc/mips-tfile.c index 70f580a76b7..7a122a1e88a 100644 --- a/gcc/mips-tfile.c +++ b/gcc/mips-tfile.c @@ -2,15 +2,15 @@ contain debugging information specified by the GNU compiler in the form of comments (the mips assembler does not support assembly access to debug information). - Copyright (C) 1991, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001 - Free Software Foundation, Inc. + Copyright (C) 1991, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001, + 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. Contributed by Michael Meissner (meissner@cygnus.com). - + This file is part of GCC. GCC 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, or (at your option) any later +Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY @@ -19,9 +19,8 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +along with GCC; see the file COPYING3. If not see +. */ /* Here is a brief description of the MIPS ECOFF symbol table. The @@ -98,31 +97,31 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA array, pointer, function, etc. qualifiers. The current base types that I have documentation for are: - btNil -- undefined + btNil -- undefined btAdr -- address - integer same size as ptr - btChar -- character - btUChar -- unsigned character - btShort -- short - btUShort -- unsigned short - btInt -- int - btUInt -- unsigned int - btLong -- long - btULong -- unsigned long - btFloat -- float (real) - btDouble -- Double (real) - btStruct -- Structure (Record) - btUnion -- Union (variant) - btEnum -- Enumerated - btTypedef -- defined via a typedef isymRef - btRange -- subrange of int - btSet -- pascal sets - btComplex -- fortran complex - btDComplex -- fortran double complex - btIndirect -- forward or unnamed typedef - btFixedDec -- Fixed Decimal - btFloatDec -- Float Decimal - btString -- Varying Length Character String - btBit -- Aligned Bit String + btChar -- character + btUChar -- unsigned character + btShort -- short + btUShort -- unsigned short + btInt -- int + btUInt -- unsigned int + btLong -- long + btULong -- unsigned long + btFloat -- float (real) + btDouble -- Double (real) + btStruct -- Structure (Record) + btUnion -- Union (variant) + btEnum -- Enumerated + btTypedef -- defined via a typedef isymRef + btRange -- subrange of int + btSet -- pascal sets + btComplex -- fortran complex + btDComplex -- fortran double complex + btIndirect -- forward or unnamed typedef + btFixedDec -- Fixed Decimal + btFloatDec -- Float Decimal + btString -- Varying Length Character String + btBit -- Aligned Bit String btPicture -- Picture btVoid -- Void (MIPS cc revision >= 2.00) @@ -130,12 +129,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA current type qualifier fields I have documentation for are: - tqNil -- no more qualifiers - tqPtr -- pointer - tqProc -- procedure - tqArray -- array - tqFar -- 8086 far pointers - tqVol -- volatile + tqNil -- no more qualifiers + tqPtr -- pointer + tqProc -- procedure + tqArray -- array + tqFar -- 8086 far pointers + tqVol -- volatile The dense number table is used in the front ends, and disappears by @@ -163,7 +162,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA Each file table has offsets for where the line numbers, local strings, local symbols, and procedure table starts from within the - global tables, and the indexs are reset to 0 for each of those + global tables, and the indices are reset to 0 for each of those tables for the file. The procedure table contains the binary equivalents of the .ent @@ -244,7 +243,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA } Mips-tdump produces the following information: - + Global file header: magic number 0x162 # sections 2 @@ -253,12 +252,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA symbolic header size 96 optional header 56 flags 0x0 - + Symbolic header, magic number = 0x7009, vstamp = 1.31: - + Info Offset Number Bytes ==== ====== ====== ===== - + Line numbers 380 4 4 [13] Dense numbers 0 0 0 Procedures Tables 384 1 52 @@ -270,14 +269,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA File Tables 1008 2 144 Relative Files 0 0 0 External Symbols 1152 20 320 - + File #0, "hello2.c" - + Name index = 1 Readin = No Merge = No Endian = LITTLE Debug level = G2 Language = C Adr = 0x00000000 - + Info Start Number Size Offset ==== ===== ====== ==== ====== Local strings 0 15 15 784 @@ -287,7 +286,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA Procedures 0 1 52 384 Auxiliary symbols 0 14 56 628 Relative Files 0 0 0 0 - + There are 6 local symbols, starting at 436 Symbol# 0: "hello2.c" @@ -602,6 +601,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "version.h" #include "intl.h" @@ -609,6 +610,9 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define saber_stop() #endif +/* Include getopt.h for the sake of getopt_long. */ +#include "getopt.h" + #ifndef __LINE__ #define __LINE__ 0 #endif @@ -631,13 +635,11 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA /* The following might be called from obstack or malloc, so they can't be static. */ -extern void pfatal_with_name - PARAMS ((const char *)) ATTRIBUTE_NORETURN; -extern void fancy_abort PARAMS ((void)) ATTRIBUTE_NORETURN; - void botch PARAMS ((const char *)) ATTRIBUTE_NORETURN; +extern void pfatal_with_name (const char *) ATTRIBUTE_NORETURN; +extern void botch (const char *) ATTRIBUTE_NORETURN; -extern void fatal PARAMS ((const char *format, ...)) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN; -extern void error PARAMS ((const char *format, ...)) ATTRIBUTE_PRINTF_1; +extern void fatal (const char *format, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN; +extern void error (const char *format, ...) ATTRIBUTE_PRINTF_1; #ifndef MIPS_DEBUGGING_INFO @@ -649,7 +651,7 @@ static const char *progname; static const char *input_name; int -main () +main (void) { fprintf (stderr, "Mips-tfile should only be run on a MIPS computer!\n"); exit (1); @@ -664,11 +666,11 @@ main () #include -#ifndef CROSS_COMPILE +#ifndef CROSS_DIRECTORY_STRUCTURE #include #else #include "mips/a.out.h" -#endif /* CROSS_COMPILE */ +#endif /* CROSS_DIRECTORY_STRUCTURE */ #include "gstab.h" @@ -734,7 +736,7 @@ typedef enum st { st_StaticProc = stStaticProc, /* load time only static procs */ st_Constant = stConstant, /* const */ st_Str = stStr, /* string */ - st_Number = stNumber, /* pure number (ie. 4 NOR 2+2) */ + st_Number = stNumber, /* pure number (i.e. 4 NOR 2+2) */ st_Expr = stExpr, /* 2+2 vs. 4 */ st_Type = stType, /* post-coercion SER */ st_Max = stMax /* max type+1 */ @@ -893,16 +895,13 @@ enum alloc_type { pages. On systems with a BSD malloc that define USE_MALLOC, the MAX_CLUSTER_PAGES should be 1 less than a power of two, since malloc adds its overhead, and rounds up to the next power of 2. Pages are - linked together via a linked list. - - If PAGE_SIZE is > 4096, the string length in the shash_t structure - can't be represented (assuming there are strings > 4096 bytes). */ + linked together via a linked list. */ #ifndef PAGE_SIZE -#define PAGE_SIZE 4096 /* size of varray pages */ +#define PAGE_SIZE 32768 /* size of varray pages */ #endif -#define PAGE_USIZE ((Size_t)PAGE_SIZE) +#define PAGE_USIZE ((Size_t) PAGE_SIZE) #ifndef MAX_CLUSTER_PAGES /* # pages to get from system */ @@ -948,6 +947,13 @@ typedef struct varray { OBJECTS_PER_PAGE (type), /* objects_last_page */ \ } +#define INITIALIZE_VARRAY(x,type) \ +do { \ + (x)->object_size = sizeof (type); \ + (x)->objects_per_page = OBJECTS_PER_PAGE (type); \ + (x)->objects_last_page = OBJECTS_PER_PAGE (type); \ +} while (0) + /* Master type for indexes within the symbol table. */ typedef unsigned long symint_t; @@ -1064,90 +1070,8 @@ typedef struct efdr { } efdr_t; /* Pre-initialized extended file structure. */ -static efdr_t init_file = -{ - { /* FDR structure */ -#ifdef __alpha - 0, /* adr: memory address of beginning of file */ - 0, /* cbLineOffset: byte offset from header for this file ln's */ - 0, /* cbLine: size of lines for this file */ - 0, /* cbSs: number of bytes in the ss */ - 0, /* rss: file name (of source, if known) */ - 0, /* issBase: file's string space */ - 0, /* isymBase: beginning of symbols */ - 0, /* csym: count file's of symbols */ - 0, /* ilineBase: file's line symbols */ - 0, /* cline: count of file's line symbols */ - 0, /* ioptBase: file's optimization entries */ - 0, /* copt: count of file's optimization entries */ - 0, /* ipdFirst: start of procedures for this file */ - 0, /* cpd: count of procedures for this file */ - 0, /* iauxBase: file's auxiliary entries */ - 0, /* caux: count of file's auxiliary entries */ - 0, /* rfdBase: index into the file indirect table */ - 0, /* crfd: count file indirect entries */ - langC, /* lang: language for this file */ - 1, /* fMerge: whether this file can be merged */ - 0, /* fReadin: true if read in (not just created) */ -#ifdef HOST_WORDS_BIG_ENDIAN - 1, /* fBigendian: if 1, compiled on big endian machine */ -#else - 0, /* fBigendian: if 1, compiled on big endian machine */ -#endif - 0, /* fTrim: whether the symbol table was trimmed */ - GLEVEL_2, /* glevel: level this file was compiled with */ - 0, /* reserved: reserved for future use */ -#else - 0, /* adr: memory address of beginning of file */ - 0, /* rss: file name (of source, if known) */ - 0, /* issBase: file's string space */ - 0, /* cbSs: number of bytes in the ss */ - 0, /* isymBase: beginning of symbols */ - 0, /* csym: count file's of symbols */ - 0, /* ilineBase: file's line symbols */ - 0, /* cline: count of file's line symbols */ - 0, /* ioptBase: file's optimization entries */ - 0, /* copt: count of file's optimization entries */ - 0, /* ipdFirst: start of procedures for this file */ - 0, /* cpd: count of procedures for this file */ - 0, /* iauxBase: file's auxiliary entries */ - 0, /* caux: count of file's auxiliary entries */ - 0, /* rfdBase: index into the file indirect table */ - 0, /* crfd: count file indirect entries */ - langC, /* lang: language for this file */ - 1, /* fMerge: whether this file can be merged */ - 0, /* fReadin: true if read in (not just created) */ -#ifdef HOST_WORDS_BIG_ENDIAN - 1, /* fBigendian: if 1, compiled on big endian machine */ -#else - 0, /* fBigendian: if 1, compiled on big endian machine */ -#endif - GLEVEL_2, /* glevel: level this file was compiled with */ - 0, /* reserved: reserved for future use */ - 0, /* cbLineOffset: byte offset from header for this file ln's */ - 0, /* cbLine: size of lines for this file */ -#endif - }, - - (FDR *) 0, /* orig_fdr: original file header pointer */ - (char *) 0, /* name: pointer to filename */ - 0, /* name_len: length of filename */ - 0, /* void_type: ptr to aux node for void type */ - 0, /* int_type: ptr to aux node for int type */ - (scope_t *) 0, /* cur_scope: current scope being processed */ - 0, /* file_index: current file # */ - 0, /* nested_scopes: # nested scopes */ - INIT_VARRAY (char), /* strings: local string varray */ - INIT_VARRAY (SYMR), /* symbols: local symbols varray */ - INIT_VARRAY (PDR), /* procs: procedure varray */ - INIT_VARRAY (AUXU), /* aux_syms: auxiliary symbols varray */ - - (struct efdr *) 0, /* next_file: next file structure */ - - (shash_t **) 0, /* shash_head: string hash table */ - { 0 }, /* thash_head: type hash table */ -}; - +static int init_file_initialized = 0; +static efdr_t init_file; static efdr_t *first_file; /* first file descriptor */ static efdr_t **last_file_ptr = &first_file; /* file descriptor tail */ @@ -1273,7 +1197,7 @@ static EXTR *last_func_eptr; Maybe this will be fixed in 2.10 or 2.20 of the MIPS compiler suite, but for now go with what works. */ -static bt_t map_coff_types[ (int)T_MAX ] = { +static const bt_t map_coff_types[ (int) T_MAX ] = { bt_Nil, /* T_NULL */ bt_Nil, /* T_ARG */ bt_Char, /* T_CHAR */ @@ -1293,7 +1217,7 @@ static bt_t map_coff_types[ (int)T_MAX ] = { }; /* Convert COFF storage class to ECOFF storage class. */ -static sc_t map_coff_storage[ (int)C_MAX ] = { +static const sc_t map_coff_storage[ (int) C_MAX ] = { sc_Nil, /* 0: C_NULL */ sc_Abs, /* 1: C_AUTO auto var */ sc_Undefined, /* 2: C_EXT external */ @@ -1404,7 +1328,7 @@ static sc_t map_coff_storage[ (int)C_MAX ] = { }; /* Convert COFF storage class to ECOFF symbol type. */ -static st_t map_coff_sym_type[ (int)C_MAX ] = { +static const st_t map_coff_sym_type[ (int) C_MAX ] = { st_Nil, /* 0: C_NULL */ st_Local, /* 1: C_AUTO auto var */ st_Global, /* 2: C_EXT external */ @@ -1515,7 +1439,7 @@ static st_t map_coff_sym_type[ (int)C_MAX ] = { }; /* Map COFF derived types to ECOFF type qualifiers. */ -static tq_t map_coff_derived_type[ (int)DT_MAX ] = { +static const tq_t map_coff_derived_type[ (int) DT_MAX ] = { tq_Nil, /* 0: DT_NON no more qualifiers */ tq_Ptr, /* 1: DT_PTR pointer */ tq_Proc, /* 2: DT_FCN function */ @@ -1524,7 +1448,7 @@ static tq_t map_coff_derived_type[ (int)DT_MAX ] = { /* 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 ]; /* Pointers and such to the original symbol table that is read in. */ @@ -1546,7 +1470,7 @@ static EXTR *orig_ext_syms; /* external symbols */ /* Macros to convert an index into a given object within the original symbol table. */ #define CHECK(num,max,str) \ - (((unsigned long)num > (unsigned long)max) ? out_of_bounds (num, max, str, __LINE__) : 0) + (((unsigned long) num > (unsigned long) max) ? out_of_bounds (num, max, str, __LINE__) : 0) #define ORIG_LINENUM(indx) (CHECK ((indx), orig_sym_hdr.cbLine, "line#"), (indx) + orig_linenum) #define ORIG_DENSE(indx) (CHECK ((indx), orig_sym_hdr.idnMax, "dense"), (indx) + orig_dense) @@ -1568,8 +1492,8 @@ static SYMR *cur_oproc_begin = (SYMR *) 0; /* original proc. sym begin info * static SYMR *cur_oproc_end = (SYMR *) 0; /* original proc. sym end info */ static PDR *cur_oproc_ptr = (PDR *) 0; /* current original procedure*/ static thead_t *cur_tag_head = (thead_t *) 0;/* current tag head */ -static long file_offset = 0; /* current file offset */ -static long max_file_offset = 0; /* maximum file offset */ +static unsigned long file_offset = 0; /* current file offset */ +static unsigned long max_file_offset = 0; /* maximum file offset */ static FILE *object_stream = (FILE *) 0; /* file desc. to output .o */ static FILE *obj_in_stream = (FILE *) 0; /* file desc. to input .o */ static char *progname = (char *) 0; /* program name for errors */ @@ -1581,8 +1505,9 @@ static char *cur_line_ptr = (char *) 0; /* ptr within current line */ static unsigned cur_line_nbytes = 0; /* # bytes for current line */ static unsigned cur_line_alloc = 0; /* # bytes total in buffer */ static long line_number = 0; /* current input line number */ -static int debug = 0; /* trace functions */ -static int version = 0; /* print version # */ +static int debug = 0; /* trace functions */ +static int version = 0; /* print version # */ +static int verbose = 0; static int had_errors = 0; /* != 0 if errors were found */ static int rename_output = 0; /* != 0 if rename output file*/ static int delete_input = 0; /* != 0 if delete input after done */ @@ -1594,7 +1519,7 @@ static int stabs_seen = 0; /* != 0 if stabs have been seen */ #define STABS_SYMBOL "@stabs" #endif -static char stabs_symbol[] = STABS_SYMBOL; +static const char stabs_symbol[] = STABS_SYMBOL; /* Forward reference for functions. See the definition for more details. */ @@ -1603,107 +1528,64 @@ static char stabs_symbol[] = STABS_SYMBOL; #define STATIC static #endif -STATIC int out_of_bounds PARAMS ((symint_t, symint_t, const char *, int)); - -STATIC shash_t *hash_string PARAMS ((const char *, - Ptrdiff_t, - shash_t **, - symint_t *)); - -STATIC symint_t add_string PARAMS ((varray_t *, - shash_t **, - const char *, - const char *, - shash_t **)); - -STATIC symint_t add_local_symbol - PARAMS ((const char *, - const char *, - st_t, - sc_t, - symint_t, - symint_t)); - -STATIC symint_t add_ext_symbol PARAMS ((EXTR *, - int)); - -STATIC symint_t add_aux_sym_symint - PARAMS ((symint_t)); - -STATIC symint_t add_aux_sym_rndx - PARAMS ((int, symint_t)); - -STATIC symint_t add_aux_sym_tir PARAMS ((type_info_t *, - hash_state_t, - thash_t **)); - -STATIC tag_t * get_tag PARAMS ((const char *, - const char *, - symint_t, - bt_t)); - -STATIC void add_unknown_tag PARAMS ((tag_t *)); - -STATIC void add_procedure PARAMS ((const char *, - const char *)); - -STATIC void add_file PARAMS ((const char *, - const char *)); - -STATIC void add_bytes PARAMS ((varray_t *, - char *, - Size_t)); - -STATIC void add_varray_page PARAMS ((varray_t *)); - -STATIC void update_headers PARAMS ((void)); - -STATIC void write_varray PARAMS ((varray_t *, off_t, const char *)); -STATIC void write_object PARAMS ((void)); -STATIC const char *st_to_string PARAMS ((st_t)); -STATIC const char *sc_to_string PARAMS ((sc_t)); -STATIC char *read_line PARAMS ((void)); -STATIC void parse_input PARAMS ((void)); -STATIC void mark_stabs PARAMS ((const char *)); -STATIC void parse_begin PARAMS ((const char *)); -STATIC void parse_bend PARAMS ((const char *)); -STATIC void parse_def PARAMS ((const char *)); -STATIC void parse_end PARAMS ((const char *)); -STATIC void parse_ent PARAMS ((const char *)); -STATIC void parse_file PARAMS ((const char *)); -STATIC void parse_stabs_common - PARAMS ((const char *, const char *, const char *)); -STATIC void parse_stabs PARAMS ((const char *)); -STATIC void parse_stabn PARAMS ((const char *)); -STATIC page_t *read_seek PARAMS ((Size_t, off_t, const char *)); -STATIC void copy_object PARAMS ((void)); - -STATIC void catch_signal PARAMS ((int)) ATTRIBUTE_NORETURN; -STATIC page_t *allocate_page PARAMS ((void)); - -STATIC page_t *allocate_multiple_pages - PARAMS ((Size_t)); - -STATIC void free_multiple_pages - PARAMS ((page_t *, Size_t)); +STATIC int out_of_bounds (symint_t, symint_t, const char *, int); +STATIC shash_t *hash_string (const char *, Ptrdiff_t, shash_t **, symint_t *); +STATIC symint_t add_string (varray_t *, shash_t **, const char *, const char *, + shash_t **); +STATIC symint_t add_local_symbol (const char *, const char *, st_t, sc_t, + symint_t, symint_t); +STATIC symint_t add_ext_symbol (EXTR *, int); +STATIC symint_t add_aux_sym_symint (symint_t); +STATIC symint_t add_aux_sym_rndx (int, symint_t); +STATIC symint_t add_aux_sym_tir (type_info_t *, hash_state_t, thash_t **); +STATIC tag_t * get_tag (const char *, const char *, symint_t, bt_t); +STATIC void add_unknown_tag (tag_t *); +STATIC void add_procedure (const char *, const char *); +STATIC void initialize_init_file (void); +STATIC void add_file (const char *, const char *); +STATIC void add_bytes (varray_t *, char *, Size_t); +STATIC void add_varray_page (varray_t *); +STATIC void update_headers (void); +STATIC void write_varray (varray_t *, off_t, const char *); +STATIC void write_object (void); +STATIC const char *st_to_string (st_t); +STATIC const char *sc_to_string (sc_t); +STATIC char *read_line (void); +STATIC void parse_input (void); +STATIC void mark_stabs (const char *); +STATIC void parse_begin (const char *); +STATIC void parse_bend (const char *); +STATIC void parse_def (const char *); +STATIC void parse_end (const char *); +STATIC void parse_ent (const char *); +STATIC void parse_file (const char *); +STATIC void parse_stabs_common (const char *, const char *, const char *); +STATIC void parse_stabs (const char *); +STATIC void parse_stabn (const char *); +STATIC page_t *read_seek (Size_t, off_t, const char *); +STATIC void copy_object (void); + +STATIC void catch_signal (int) ATTRIBUTE_NORETURN; +STATIC page_t *allocate_page (void); +STATIC page_t *allocate_multiple_pages (Size_t); +STATIC void free_multiple_pages (page_t *, Size_t); #ifndef MALLOC_CHECK -STATIC page_t *allocate_cluster - PARAMS ((Size_t)); +STATIC page_t *allocate_cluster (Size_t); #endif -STATIC forward_t *allocate_forward PARAMS ((void)); -STATIC scope_t *allocate_scope PARAMS ((void)); -STATIC shash_t *allocate_shash PARAMS ((void)); -STATIC tag_t *allocate_tag PARAMS ((void)); -STATIC thash_t *allocate_thash PARAMS ((void)); -STATIC thead_t *allocate_thead PARAMS ((void)); -STATIC vlinks_t *allocate_vlinks PARAMS ((void)); +STATIC forward_t *allocate_forward (void); +STATIC scope_t *allocate_scope (void); +STATIC shash_t *allocate_shash (void); +STATIC tag_t *allocate_tag (void); +STATIC thash_t *allocate_thash (void); +STATIC thead_t *allocate_thead (void); +STATIC vlinks_t *allocate_vlinks (void); -STATIC void free_forward PARAMS ((forward_t *)); -STATIC void free_scope PARAMS ((scope_t *)); -STATIC void free_tag PARAMS ((tag_t *)); -STATIC void free_thead PARAMS ((thead_t *)); +STATIC void free_forward (forward_t *); +STATIC void free_scope (scope_t *); +STATIC void free_tag (tag_t *); +STATIC void free_thead (thead_t *); extern char *optarg; extern int optind; @@ -1715,12 +1597,12 @@ extern int opterr; do...... */ typedef struct _pseudo_ops { - const char *name; /* pseudo-op in ascii */ - int len; /* length of name to compare */ - void (*func) PARAMS ((const char *)); /* function to handle line */ + const char *const name; /* pseudo-op in ascii */ + const int len; /* length of name to compare */ + void (*const func) (const char *); /* function to handle line */ } pseudo_ops_t; -static pseudo_ops_t pseudo_ops[] = { +static const pseudo_ops_t pseudo_ops[] = { { "#.def", sizeof("#.def")-1, parse_def }, { "#.begin", sizeof("#.begin")-1, parse_begin }, { "#.bend", sizeof("#.bend")-1, parse_bend }, @@ -1735,23 +1617,31 @@ static pseudo_ops_t pseudo_ops[] = { }; +/* Command line options for getopt_long. */ + +static const struct option options[] = +{ + { "version", 0, 0, 'V' }, + { "verbose", 0, 0, 'v' }, + { 0, 0, 0, 0 } +}; + /* 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) { vlinks_t *new_links = allocate_vlinks (); #ifdef MALLOC_CHECK if (vp->object_size > 1) - new_links->datum = (page_t *) xcalloc (1, vp->object_size); + new_links->datum = xcalloc (1, vp->object_size); else #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; @@ -1772,11 +1662,8 @@ add_varray_page (vp) #define HASHBITS 30 STATIC shash_t * -hash_string (text, hash_len, hash_tbl, ret_hash_index) - const char *text; /* ptr to text to hash */ - Ptrdiff_t hash_len; /* length of the text */ - shash_t **hash_tbl; /* hash table */ - symint_t *ret_hash_index; /* ptr to store hash index */ +hash_string (const char *text, Ptrdiff_t hash_len, shash_t **hash_tbl, + symint_t *ret_hash_index) { unsigned long hi; Ptrdiff_t i; @@ -1804,23 +1691,22 @@ hash_string (text, hash_len, hash_tbl, ret_hash_index) /* Add a string (and null pad) to one of the string tables. A - consequence of hashing strings, is that we don't let strings - cross page boundaries. The extra nulls will be ignored. */ + consequence of hashing strings, is that we don't let strings cross + page boundaries. The extra nulls will be ignored. VP is a string + virtual array, HASH_TBL a pointer to the hash table, the string + starts at START and the position one byte after the string is given + with END_P1, the resulting hash pointer is returned in RET_HASH. */ STATIC symint_t -add_string (vp, hash_tbl, start, end_p1, ret_hash) - varray_t *vp; /* string virtual array */ - shash_t **hash_tbl; /* ptr to hash table */ - const char *start; /* 1st byte in string */ - const char *end_p1; /* 1st byte after string */ - shash_t **ret_hash; /* return hash pointer */ +add_string (varray_t *vp, shash_t **hash_tbl, const char *start, + const char *end_p1, shash_t **ret_hash) { Ptrdiff_t len = end_p1 - start; shash_t *hash_ptr; symint_t hi; if (len >= (Ptrdiff_t) PAGE_USIZE) - fatal ("String too big (%ld bytes)", (long) len); + fatal ("string too big (%ld bytes)", (long) len); hash_ptr = hash_string (start, len, hash_tbl, &hi); if (hash_ptr == (shash_t *) 0) @@ -1858,16 +1744,14 @@ add_string (vp, hash_tbl, start, end_p1, ret_hash) } -/* Add a local symbol. */ +/* Add a local symbol. The symbol string starts at STR_START and the + first byte after it is marked by STR_END_P1. The symbol has type + TYPE and storage class STORAGE and value VALUE. INDX is an index + to local/aux. symbols. */ STATIC symint_t -add_local_symbol (str_start, str_end_p1, type, storage, value, indx) - const char *str_start; /* first byte in string */ - const char *str_end_p1; /* first byte after string */ - st_t type; /* symbol type */ - sc_t storage; /* storage class */ - symint_t value; /* value of symbol */ - symint_t indx; /* index to local/aux. syms */ +add_local_symbol (const char *str_start, const char *str_end_p1, st_t type, + sc_t storage, symint_t value, symint_t indx) { symint_t ret; SYMR *psym; @@ -1898,7 +1782,7 @@ add_local_symbol (str_start, str_end_p1, type, storage, value, indx) ret = vp->num_allocated++; - if (MIPS_IS_STAB(psym)) + if (MIPS_IS_STAB (psym)) return ret; /* Save the symbol within the hash table if this is a static @@ -1942,7 +1826,7 @@ add_local_symbol (str_start, str_end_p1, type, storage, value, indx) case st_End: pscope = cur_file_ptr->cur_scope; - if (pscope == (scope_t *)0) + if (pscope == (scope_t *) 0) error ("internal error, too many st_End's"); else @@ -2036,12 +1920,11 @@ add_local_symbol (str_start, str_end_p1, type, storage, value, indx) } -/* Add an external symbol. */ +/* Add an external symbol with symbol pointer ESYM and file index + IFD. */ STATIC symint_t -add_ext_symbol (esym, ifd) - EXTR *esym; /* symbol pointer */ - int ifd; /* file index */ +add_ext_symbol (EXTR *esym, int ifd) { const char *str_start; /* first byte in string */ const char *str_end_p1; /* first byte after string */ @@ -2050,7 +1933,7 @@ add_ext_symbol (esym, ifd) shash_t *hash_ptr = (shash_t *) 0; str_start = ORIG_ESTRS (esym->asym.iss); - str_end_p1 = str_start + strlen(str_start); + str_end_p1 = str_start + strlen (str_start); if (debug > 1) { @@ -2093,8 +1976,7 @@ add_ext_symbol (esym, ifd) /* Add an auxiliary symbol (passing a symint). */ STATIC symint_t -add_aux_sym_symint (aux_word) - symint_t aux_word; /* auxiliary information word */ +add_aux_sym_symint (symint_t aux_word) { AUXU *aux_ptr; efdr_t *file_ptr = cur_file_ptr; @@ -2113,9 +1995,7 @@ add_aux_sym_symint (aux_word) /* 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) { AUXU *aux_ptr; efdr_t *file_ptr = cur_file_ptr; @@ -2136,10 +2016,7 @@ 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, hash_state_t state, thash_t **hash_tbl) { AUXU *aux_ptr; efdr_t *file_ptr = cur_file_ptr; @@ -2223,7 +2100,7 @@ add_aux_sym_tir (t, state, hash_tbl) ret = vp->num_allocated++; /* Add bitfield length if it exists. - + NOTE: Mips documentation claims bitfield goes at the end of the AUX record, but the DECstation compiler emits it here. (This would only make a difference for enum bitfields.) @@ -2232,7 +2109,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 @@ -2298,11 +2175,11 @@ 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_start, tag_end_p1, indx, basic_type) - const char *tag_start; /* 1st byte of tag name */ - const char *tag_end_p1; /* 1st byte after tag name */ - symint_t indx; /* index of tag start block */ - bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */ +get_tag (const char *tag_start, /* 1st byte of tag name */ + const char *tag_end_p1, /* 1st byte after tag name */ + symint_t indx, /* index of tag start block */ + bt_t basic_type) /* bt_Struct, bt_Union, or bt_Enum */ + { shash_t *hash_ptr; tag_t *tag_ptr; @@ -2350,8 +2227,7 @@ get_tag (tag_start, tag_end_p1, indx, 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) { shash_t *hash_ptr = ptag->hash_ptr; char *name_start = hash_ptr->string; @@ -2410,9 +2286,8 @@ add_unknown_tag (ptag) this procedure, use that to initialize the current PDR. */ STATIC void -add_procedure (func_start, func_end_p1) - const char *func_start; /* 1st byte of func name */ - const char *func_end_p1; /* 1st byte after func name */ +add_procedure (const char *func_start, /* 1st byte of func name */ + const char *func_end_p1) /* 1st byte after func name */ { PDR *new_proc_ptr; efdr_t *file_ptr = cur_file_ptr; @@ -2444,20 +2319,20 @@ add_procedure (func_start, func_end_p1) if (old_proc_ptr != (PDR *) 0 && sym_ptr != (SYMR *) 0 - && ((st_t)sym_ptr->st == st_Proc || (st_t)sym_ptr->st == st_StaticProc)) + && ((st_t) sym_ptr->st == st_Proc || (st_t) sym_ptr->st == st_StaticProc)) { cur_oproc_begin = sym_ptr; cur_oproc_end = shash_ptr->end_ptr; value = sym_ptr->value; cur_oproc_ptr = old_proc_ptr; - proc_type = (st_t)sym_ptr->st; + proc_type = (st_t) sym_ptr->st; *new_proc_ptr = *old_proc_ptr; /* initialize */ } } if (cur_oproc_ptr == (PDR *) 0) - error ("Did not find a PDR block for %.*s", + error ("did not find a PDR block for %.*s", (int) (func_end_p1 - func_start), func_start); /* Determine the start of symbols. */ @@ -2471,14 +2346,49 @@ add_procedure (func_start, func_end_p1) } +/* Initialize the init_file structure. */ + +STATIC void +initialize_init_file (void) +{ + union { + unsigned char c[4]; + int i; + } endian_test; + + memset (&init_file, 0, sizeof (init_file)); + + init_file.fdr.lang = langC; + init_file.fdr.fMerge = 1; + init_file.fdr.glevel = GLEVEL_2; + + /* mips-tfile doesn't attempt to perform byte swapping and always writes + out integers in its native ordering. For cross-compilers, this need + not be the same as either the host or the target. The simplest thing + to do is skip the configury and perform an introspective test. */ + /* ??? Despite the name, mips-tfile is currently only used on alpha/Tru64 + and would/may require significant work to be used in cross-compiler + configurations, so we could simply admit defeat and hard code this as + little-endian, i.e. init_file.fdr.fBigendian = 0. */ + endian_test.i = 1; + if (endian_test.c[3]) + init_file.fdr.fBigendian = 1; + + INITIALIZE_VARRAY (&init_file.strings, char); + INITIALIZE_VARRAY (&init_file.symbols, SYMR); + INITIALIZE_VARRAY (&init_file.procs, PDR); + INITIALIZE_VARRAY (&init_file.aux_syms, AUXU); + + init_file_initialized = 1; +} + /* Add a new filename, and set up all of the file relative virtual arrays (strings, symbols, aux syms, etc.). Record where the current file structure lives. */ STATIC void -add_file (file_start, file_end_p1) - const char *file_start; /* first byte in string */ - const char *file_end_p1; /* first byte after string */ +add_file (const char *file_start, /* first byte in string */ + const char *file_end_p1) /* first byte after string */ { static char zero_bytes[2] = { '\0', '\0' }; @@ -2509,6 +2419,9 @@ add_file (file_start, file_end_p1) if (file_desc.objects_last_page == file_desc.objects_per_page) add_varray_page (&file_desc); + if (! init_file_initialized) + initialize_init_file (); + file_ptr = cur_file_ptr = &file_desc.last->datum->file[ file_desc.objects_last_page++ ]; *file_ptr = init_file; @@ -2526,7 +2439,7 @@ add_file (file_start, file_end_p1) (shash_t **) 0); if (file_end_p1 - file_start > (long) PAGE_USIZE-2) - fatal ("Filename goes over one page boundary"); + 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. */ @@ -2556,10 +2469,9 @@ add_file (file_start, file_end_p1) /* Add a stream of random bytes to a varray. */ STATIC void -add_bytes (vp, input_ptr, nitems) - varray_t *vp; /* virtual array to add too */ - char *input_ptr; /* start of the bytes */ - Size_t nitems; /* # items to move */ +add_bytes (varray_t *vp, /* virtual array to add too */ + char *input_ptr, /* start of the bytes */ + Size_t nitems) /* # items to move */ { Size_t move_items; Size_t move_bytes; @@ -2595,10 +2507,9 @@ add_bytes (vp, input_ptr, nitems) /* Convert storage class to string. */ STATIC const char * -sc_to_string(storage_class) - sc_t storage_class; +sc_to_string (sc_t storage_class) { - switch(storage_class) + switch (storage_class) { case sc_Nil: return "Nil,"; case sc_Text: return "Text,"; @@ -2633,10 +2544,9 @@ sc_to_string(storage_class) /* Convert symbol type to string. */ STATIC const char * -st_to_string(symbol_type) - st_t symbol_type; +st_to_string (st_t symbol_type) { - switch(symbol_type) + switch (symbol_type) { case st_Nil: return "Nil,"; case st_Global: return "Global,"; @@ -2670,7 +2580,7 @@ st_to_string(symbol_type) semi-colon, and return each logical line independently. */ STATIC char * -read_line () +read_line (void) { static int line_split_p = 0; int string_p = 0; @@ -2713,7 +2623,7 @@ read_line () } else if (ch == '\0') - error ("Null character found in input"); + error ("null character found in input"); else if (!comment_p) { @@ -2746,8 +2656,7 @@ read_line () which gives the location of the start of the block. */ STATIC void -parse_begin (start) - const char *start; /* start of directive */ +parse_begin (const char *start) { const char *end_p1; /* end of label */ int ch; @@ -2775,14 +2684,14 @@ parse_begin (start) if (hash_ptr == (shash_t *) 0) { - error ("Label %.*s not found for #.begin", + error ("label %.*s not found for #.begin", (int) (end_p1 - start), start); return; } if (cur_oproc_begin == (SYMR *) 0) { - error ("Procedure table %.*s not found for #.begin", + error ("procedure table %.*s not found for #.begin", (int) (end_p1 - start), start); return; } @@ -2798,8 +2707,7 @@ parse_begin (start) which gives the location of the end of the block. */ STATIC void -parse_bend (start) - const char *start; /* start of directive */ +parse_bend (const char *start) { const char *end_p1; /* end of label */ int ch; @@ -2827,20 +2735,20 @@ parse_bend (start) if (hash_ptr == (shash_t *) 0) { - error ("Label %.*s not found for #.bend", (int) (end_p1 - start), start); + error ("label %.*s not found for #.bend", (int) (end_p1 - start), start); return; } if (cur_oproc_begin == (SYMR *) 0) { - error ("Procedure table %.*s not found for #.bend", + error ("procedure table %.*s not found for #.bend", (int) (end_p1 - start), start); return; } (void) add_local_symbol ((const char *) 0, (const char *) 0, st_End, sc_Text, - (symint_t)hash_ptr->sym_ptr->value - cur_oproc_begin->value, + (symint_t) hash_ptr->sym_ptr->value - cur_oproc_begin->value, (symint_t) 0); } @@ -2857,8 +2765,7 @@ parse_bend (start) .tag specify a tag for a struct, union, or enum. */ STATIC void -parse_def (name_start) - const char *name_start; /* start of directive */ +parse_def (const char *name_start) { const char *dir_start; /* start of current directive*/ const char *dir_end_p1; /* end+1 of current directive*/ @@ -2923,7 +2830,7 @@ parse_def (name_start) && memcmp (dir_start, ".endef", sizeof (".endef")-1) == 0) break; - /* Pick up the subdirective now */ + /* Pick up the subdirective now. */ for (dir_end_p1 = dir_start+1; (ch = *dir_end_p1) != ' ' && ch != '\t'; dir_end_p1++) @@ -2948,7 +2855,7 @@ parse_def (name_start) { int ch2; arg_number = strtol (arg_start, (char **) &arg_end_p1, 0); - if (arg_end_p1 != arg_start || (ch2 = *arg_end_p1 != ';') || ch2 != ',') + if (arg_end_p1 != arg_start || ((ch2 = *arg_end_p1) != ';') || ch2 != ',') arg_was_number++; } @@ -3004,7 +2911,7 @@ parse_def (name_start) { int ch2; arg_number = strtol (arg_start, (char **) &arg_end_p1, 0); - if (arg_end_p1 != arg_start || (ch2 = *arg_end_p1 != ';') || ch2 != ',') + if (arg_end_p1 != arg_start || ((ch2 = *arg_end_p1) != ';') || ch2 != ',') arg_was_number++; if (t_ptr == &temp_array[0]) @@ -3078,7 +2985,7 @@ parse_def (name_start) { int ch2; arg_number = strtol (arg_start, (char **) &arg_end_p1, 0); - if (arg_end_p1 != arg_start || (ch2 = *arg_end_p1 != ';') || ch2 != ',') + if (arg_end_p1 != arg_start || ((ch2 = *arg_end_p1) != ';') || ch2 != ',') arg_was_number++; if (t_ptr == &temp_array[0]) @@ -3123,13 +3030,13 @@ parse_def (name_start) tq_t *tq_ptr = &t.type_qualifiers[0]; t.orig_type = (coff_type_t) (arg_number & N_BTMASK); - t.basic_type = map_coff_types [(int)t.orig_type]; + t.basic_type = map_coff_types [(int) t.orig_type]; for (i = N_TQ-1; i >= 0; i--) { int dt = (arg_number >> ((i * N_TQ_SHIFT) + N_BT_SHIFT) & N_TMASK); - if (dt != (int)DT_NON) + if (dt != (int) DT_NON) *tq_ptr++ = map_coff_derived_type [dt]; } @@ -3177,7 +3084,7 @@ parse_def (name_start) class, symbol type, etc. */ else { - shash_t *orig_hash_ptr; /* hash within orig sym table*/ + shash_t *orig_hash_ptr; /* hash within orig sym table*/ shash_t *ext_hash_ptr; /* hash within ext. sym table*/ ext_hash_ptr = hash_string (arg_start, @@ -3289,13 +3196,13 @@ parse_def (name_start) { if (tag_start == (char *) 0) { - error ("No tag specified for %.*s", + error ("no tag specified for %.*s", (int) (name_end_p1 - name_start), name_start); return; } - t.tag_ptr = get_tag (tag_start, tag_end_p1, (symint_t)indexNil, + t.tag_ptr = get_tag (tag_start, tag_end_p1, (symint_t) indexNil, t.basic_type); } @@ -3376,7 +3283,7 @@ parse_def (name_start) for which the external symbol table is fine enough. */ if (eptr == (EXTR *) 0 - || eptr->asym.st == (int)st_Nil + || eptr->asym.st == (int) st_Nil || cur_proc_ptr != (PDR *) 0) { symint_t isym = add_local_symbol (name_start, name_end_p1, @@ -3384,7 +3291,7 @@ parse_def (name_start) value, indx); - /* deal with struct, union, and enum tags. */ + /* Deal with struct, union, and enum tags. */ if (symbol_type == st_Block) { /* Create or update the tag information. */ @@ -3432,8 +3339,7 @@ bomb_out: /* Parse .end directives. */ STATIC void -parse_end (start) - const char *start; /* start of directive */ +parse_end (const char *start) { const char *start_func, *end_func_p1; int ch; @@ -3476,11 +3382,11 @@ parse_end (start) orig_fdr = cur_file_ptr->orig_fdr; value = 0; - if (orig_fdr != (FDR *)0 && cur_oproc_end != (SYMR *) 0) + if (orig_fdr != (FDR *) 0 && cur_oproc_end != (SYMR *) 0) value = cur_oproc_end->value; else - error ("Cannot find .end block for %.*s", + error ("cannot find .end block for %.*s", (int) (end_func_p1 - start_func), start_func); (void) add_local_symbol (start_func, end_func_p1, @@ -3495,8 +3401,7 @@ parse_end (start) /* Parse .ent directives. */ STATIC void -parse_ent (start) - const char *start; /* start of directive */ +parse_ent (const char *start) { const char *start_func, *end_func_p1; int ch; @@ -3533,8 +3438,7 @@ parse_ent (start) /* Parse .file directives. */ STATIC void -parse_file (start) - const char *start; /* start of directive */ +parse_file (const char *start) { char *p; char *start_name, *end_name_p1; @@ -3544,13 +3448,13 @@ parse_file (start) || (start_name = strchr (p, '"')) == (char *) 0 || (end_name_p1 = strrchr (++start_name, '"')) == (char *) 0) { - error ("Invalid .file directive"); + error ("invalid .file directive"); return; } if (cur_proc_ptr != (PDR *) 0) { - error ("No way to handle .file within .ent/.end section"); + error ("no way to handle .file within .ent/.end section"); return; } @@ -3561,8 +3465,7 @@ parse_file (start) /* Make sure the @stabs symbol is emitted. */ static void -mark_stabs (start) - const char *start ATTRIBUTE_UNUSED; /* Start of directive (ignored) */ +mark_stabs (const char *start ATTRIBUTE_UNUSED) { if (!stabs_seen) { @@ -3570,7 +3473,7 @@ mark_stabs (start) stabs_seen = 1; (void) add_local_symbol (stabs_symbol, stabs_symbol + sizeof (stabs_symbol), - stNil, scInfo, -1, MIPS_MARK_STAB(0)); + stNil, scInfo, -1, MIPS_MARK_STAB (0)); } } @@ -3606,10 +3509,9 @@ mark_stabs (start) value a numeric value or an address. */ STATIC void -parse_stabs_common (string_start, string_end, rest) - const char *string_start; /* start of string or NULL */ - const char *string_end; /* end+1 of string or NULL */ - const char *rest; /* rest of the directive. */ +parse_stabs_common (const char *string_start, /* start of string or NULL */ + const char *string_end, /* end+1 of string or NULL */ + const char *rest) /* rest of the directive. */ { efdr_t *save_file_ptr = cur_file_ptr; symint_t code; @@ -3625,7 +3527,7 @@ parse_stabs_common (string_start, string_end, rest) /* Read code from stabs. */ if (!ISDIGIT (*rest)) { - error ("Invalid .stabs/.stabn directive, code is non-numeric"); + error ("invalid .stabs/.stabn directive, code is non-numeric"); return; } @@ -3637,7 +3539,7 @@ parse_stabs_common (string_start, string_end, rest) address. The symbol type is st_Label, which should be different from the other stabs, so that gdb can recognize it. */ - if (code == (int)N_SLINE) + if (code == (int) N_SLINE) { SYMR *sym_ptr, dummy_symr; shash_t *shash_ptr; @@ -3645,7 +3547,7 @@ parse_stabs_common (string_start, string_end, rest) /* Skip ,0, */ if (p[0] != ',' || p[1] != '0' || p[2] != ',' || !ISDIGIT (p[3])) { - error ("Invalid line number .stabs/.stabn directive"); + error ("invalid line number .stabs/.stabn directive"); return; } @@ -3653,14 +3555,14 @@ parse_stabs_common (string_start, string_end, rest) ch = *++p; if (p[-1] != ',' || ISDIGIT (ch) || !IS_ASM_IDENT (ch)) { - error ("Invalid line number .stabs/.stabn directive"); + error ("invalid line number .stabs/.stabn directive"); return; } dummy_symr.index = code; if (dummy_symr.index != code) { - error ("Line number (%lu) for .stabs/.stabn directive cannot fit in index field (20 bits)", + error ("line number (%lu) for .stabs/.stabn directive cannot fit in index field (20 bits)", code); return; @@ -3674,13 +3576,13 @@ parse_stabs_common (string_start, string_end, rest) if (shash_ptr == (shash_t *) 0 || (sym_ptr = shash_ptr->sym_ptr) == (SYMR *) 0) { - error ("Invalid .stabs/.stabn directive, value not found"); + error ("invalid .stabs/.stabn directive, value not found"); return; } if ((st_t) sym_ptr->st != st_Label) { - error ("Invalid line number .stabs/.stabn directive"); + error ("invalid line number .stabs/.stabn directive"); return; } @@ -3705,7 +3607,7 @@ parse_stabs_common (string_start, string_end, rest) if (!IS_ASM_IDENT (ch) && ch != '-') { failure: - error ("Invalid .stabs/.stabn directive, bad character"); + error ("invalid .stabs/.stabn directive, bad character"); return; } @@ -3716,13 +3618,13 @@ parse_stabs_common (string_start, string_end, rest) value = strtol (p, &p, 0); if (*p != '\n') { - error ("Invalid .stabs/.stabn directive, stuff after numeric value"); + error ("invalid .stabs/.stabn directive, stuff after numeric value"); return; } } else if (!IS_ASM_IDENT (ch)) { - error ("Invalid .stabs/.stabn directive, bad character"); + error ("invalid .stabs/.stabn directive, bad character"); return; } else @@ -3735,7 +3637,7 @@ parse_stabs_common (string_start, string_end, rest) if ((end_p1 = strchr (start, '+')) == (char *) 0) { if ((end_p1 = strchr (start, '-')) == (char *) 0) - end_p1 = start + strlen(start) - 1; + end_p1 = start + strlen (start) - 1; } shash_ptr = hash_string (start, @@ -3754,7 +3656,7 @@ parse_stabs_common (string_start, string_end, rest) if (shash_ptr == (shash_t *) 0 || shash_ptr->esym_ptr == (EXTR *) 0) { - error ("Invalid .stabs/.stabn directive, value not found"); + error ("invalid .stabs/.stabn directive, value not found"); return; } else @@ -3780,7 +3682,7 @@ parse_stabs_common (string_start, string_end, rest) if (((!ISDIGIT (*end_p1)) && (*end_p1 != '-')) || ((ch != '+') && (ch != '-'))) { - error ("Invalid .stabs/.stabn directive, badly formed value"); + error ("invalid .stabs/.stabn directive, badly formed value"); return; } if (ch == '+') @@ -3790,12 +3692,12 @@ parse_stabs_common (string_start, string_end, rest) if (*p != '\n') { - error ("Invalid .stabs/.stabn directive, stuff after numeric value"); + error ("invalid .stabs/.stabn directive, stuff after numeric value"); return; } } } - code = MIPS_MARK_STAB(code); + code = MIPS_MARK_STAB (code); } (void) add_local_symbol (string_start, string_end, st, sc, value, code); @@ -3805,14 +3707,13 @@ parse_stabs_common (string_start, string_end, rest) STATIC void -parse_stabs (start) - const char *start; /* start of directive */ +parse_stabs (const char *start) { const char *end = strchr (start+1, '"'); if (*start != '"' || end == (const char *) 0 || end[1] != ',') { - error ("Invalid .stabs directive, no string"); + error ("invalid .stabs directive, no string"); return; } @@ -3821,8 +3722,7 @@ parse_stabs (start) STATIC void -parse_stabn (start) - const char *start; /* start of directive */ +parse_stabn (const char *start) { parse_stabs_common ((const char *) 0, (const char *) 0, start); } @@ -3832,7 +3732,7 @@ parse_stabn (start) if needed. */ STATIC void -parse_input () +parse_input (void) { char *p; Size_t i; @@ -3852,7 +3752,7 @@ parse_input () while ((p = read_line ()) != (char *) 0) { - /* Skip leading blanks */ + /* Skip leading blanks. */ while (ISSPACE ((unsigned char)*p)) p++; @@ -3895,7 +3795,7 @@ parse_input () to write out the .T file. */ STATIC void -update_headers () +update_headers (void) { symint_t i; efdr_t *file_ptr; @@ -3939,7 +3839,7 @@ update_headers () sym_end_p1 = sym_start + fd_ptr->csym; for (sym = sym_start; sym < sym_end_p1; sym++) { - if ((st_t)sym->st == st_Static) + if ((st_t) sym->st == st_Static) { char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss); Size_t len = strlen (str); @@ -3949,15 +3849,15 @@ update_headers () if (str[0] == '$' && str[1] == 'L') continue; hash_ptr = hash_string (str, - (Ptrdiff_t)len, + (Ptrdiff_t) len, &file_ptr->shash_head[0], - (symint_t *) 0); + (symint_t *) 0); if (hash_ptr == (shash_t *) 0) { (void) add_local_symbol (str, str + len, - (st_t)sym->st, (sc_t)sym->sc, - (symint_t)sym->value, - (symint_t)indexNil); + (st_t) sym->st, (sc_t) sym->sc, + (symint_t) sym->value, + (symint_t) indexNil); } } } @@ -4081,10 +3981,9 @@ update_headers () /* Write out a varray at a given location. */ STATIC void -write_varray (vp, offset, str) - varray_t *vp; /* virtual array */ - off_t offset; /* offset to write varray to */ - const char *str; /* string to print out when tracing */ +write_varray (varray_t *vp, /* virtual array */ + off_t offset, /* offset to write varray to */ + const char *str) /* string to print out when tracing */ { int num_write, sys_write; vlinks_t *ptr; @@ -4093,15 +3992,12 @@ write_varray (vp, offset, str) return; if (debug) - { - fputs ("\twarray\tvp = ", stderr); - fprintf (stderr, HOST_PTR_PRINTF, (PTR) vp); - fprintf (stderr, ", offset = %7lu, size = %7lu, %s\n", - (unsigned long) offset, vp->num_allocated * vp->object_size, str); - } - - if (file_offset != offset - && fseek (object_stream, (long)offset, SEEK_SET) < 0) + fprintf (stderr, "\twarray\tvp = %p, offset = %7lu, size = %7lu, %s\n", + (void *) vp, (unsigned long) offset, + vp->num_allocated * vp->object_size, str); + + if (file_offset != (unsigned long) offset + && fseek (object_stream, (long) offset, SEEK_SET) < 0) pfatal_with_name (object_name); for (ptr = vp->first; ptr != (vlinks_t *) 0; ptr = ptr->next) @@ -4110,12 +4006,12 @@ write_varray (vp, offset, str) ? vp->objects_last_page * vp->object_size : vp->objects_per_page * vp->object_size; - sys_write = fwrite ((PTR) ptr->datum, 1, num_write, object_stream); + sys_write = fwrite (ptr->datum, 1, num_write, object_stream); if (sys_write <= 0) pfatal_with_name (object_name); else if (sys_write != num_write) - fatal ("Wrote %d bytes to %s, system returned %d", + fatal ("wrote %d bytes to %s, system returned %d", num_write, object_name, sys_write); @@ -4128,21 +4024,18 @@ write_varray (vp, offset, str) /* Write out the symbol table in the object file. */ STATIC void -write_object () +write_object (void) { int sys_write; efdr_t *file_ptr; off_t offset; if (debug) - { - fputs ("\n\twrite\tvp = ", stderr); - fprintf (stderr, HOST_PTR_PRINTF, (PTR) &symbolic_header); - fprintf (stderr, ", offset = %7u, size = %7lu, %s\n", - 0, (unsigned long) sizeof (symbolic_header), "symbolic header"); - } + fprintf (stderr, "\n\twrite\tvp = %p, offset = %7u, size = %7lu, %s\n", + (void *) &symbolic_header, 0, + (unsigned long) sizeof (symbolic_header), "symbolic header"); - sys_write = fwrite ((PTR) &symbolic_header, + sys_write = fwrite (&symbolic_header, 1, sizeof (symbolic_header), object_stream); @@ -4151,7 +4044,7 @@ write_object () pfatal_with_name (object_name); else if (sys_write != sizeof (symbolic_header)) - fatal ("Wrote %d bytes to %s, system returned %d", + fatal ("wrote %d bytes to %s, system returned %d", (int) sizeof (symbolic_header), object_name, sys_write); @@ -4163,20 +4056,16 @@ write_object () { long sys_write; - if (file_offset != symbolic_header.cbLineOffset + if (file_offset != (unsigned long) symbolic_header.cbLineOffset && fseek (object_stream, symbolic_header.cbLineOffset, SEEK_SET) != 0) pfatal_with_name (object_name); if (debug) - { - fputs ("\twrite\tvp = ", stderr); - fprintf (stderr, HOST_PTR_PRINTF, (PTR) &orig_linenum); - fprintf (stderr, ", offset = %7lu, size = %7lu, %s\n", - (long) symbolic_header.cbLineOffset, - (long) symbolic_header.cbLine, "Line numbers"); - } + fprintf (stderr, "\twrite\tvp = %p, offset = %7lu, size = %7lu, %s\n", + (void *) &orig_linenum, (long) symbolic_header.cbLineOffset, + (long) symbolic_header.cbLine, "Line numbers"); - sys_write = fwrite ((PTR) orig_linenum, + sys_write = fwrite (orig_linenum, 1, symbolic_header.cbLine, object_stream); @@ -4185,7 +4074,7 @@ write_object () pfatal_with_name (object_name); else if (sys_write != symbolic_header.cbLine) - fatal ("Wrote %ld bytes to %s, system returned %ld", + fatal ("wrote %ld bytes to %s, system returned %ld", (long) symbolic_header.cbLine, object_name, sys_write); @@ -4198,20 +4087,16 @@ write_object () long sys_write; long num_write = symbolic_header.ioptMax * sizeof (OPTR); - if (file_offset != symbolic_header.cbOptOffset + if (file_offset != (unsigned long) symbolic_header.cbOptOffset && fseek (object_stream, symbolic_header.cbOptOffset, SEEK_SET) != 0) pfatal_with_name (object_name); if (debug) - { - fputs ("\twrite\tvp = ", stderr); - fprintf (stderr, HOST_PTR_PRINTF, (PTR) &orig_opt_syms); - fprintf (stderr, ", offset = %7lu, size = %7lu, %s\n", - (long) symbolic_header.cbOptOffset, - num_write, "Optimizer symbols"); - } + fprintf (stderr, "\twrite\tvp = %p, offset = %7lu, size = %7lu, %s\n", + (void *) &orig_opt_syms, (long) symbolic_header.cbOptOffset, + num_write, "Optimizer symbols"); - sys_write = fwrite ((PTR) orig_opt_syms, + sys_write = fwrite (orig_opt_syms, 1, num_write, object_stream); @@ -4220,7 +4105,7 @@ write_object () pfatal_with_name (object_name); else if (sys_write != num_write) - fatal ("Wrote %ld bytes to %s, system returned %ld", + fatal ("wrote %ld bytes to %s, system returned %ld", num_write, object_name, sys_write); @@ -4229,7 +4114,7 @@ write_object () } if (symbolic_header.idnMax > 0) /* dense numbers */ - write_varray (&dense_num, (off_t)symbolic_header.cbDnOffset, "Dense numbers"); + write_varray (&dense_num, (off_t) symbolic_header.cbDnOffset, "Dense numbers"); if (symbolic_header.ipdMax > 0) /* procedure tables */ { @@ -4285,8 +4170,8 @@ write_object () if (symbolic_header.ifdMax > 0) /* file tables */ { offset = symbolic_header.cbFdOffset; - if (file_offset != offset - && fseek (object_stream, (long)offset, SEEK_SET) < 0) + if (file_offset != (unsigned long) offset + && fseek (object_stream, (long) offset, SEEK_SET) < 0) pfatal_with_name (object_name); file_offset = offset; @@ -4295,13 +4180,9 @@ write_object () file_ptr = file_ptr->next_file) { if (debug) - { - fputs ("\twrite\tvp = ", stderr); - fprintf (stderr, HOST_PTR_PRINTF, (PTR) &file_ptr->fdr); - fprintf (stderr, ", offset = %7lu, size = %7lu, %s\n", - file_offset, (unsigned long) sizeof (FDR), - "File header"); - } + fprintf (stderr, "\twrite\tvp = %p, offset = %7lu, size = %7lu, %s\n", + (void *) &file_ptr->fdr, file_offset, + (unsigned long) sizeof (FDR), "File header"); sys_write = fwrite (&file_ptr->fdr, 1, @@ -4312,7 +4193,7 @@ write_object () pfatal_with_name (object_name); else if (sys_write != sizeof (FDR)) - fatal ("Wrote %d bytes to %s, system returned %d", + fatal ("wrote %d bytes to %s, system returned %d", (int) sizeof (FDR), object_name, sys_write); @@ -4326,18 +4207,14 @@ write_object () long sys_write; symint_t num_write = symbolic_header.crfd * sizeof (symint_t); - if (file_offset != symbolic_header.cbRfdOffset + if (file_offset != (unsigned long) symbolic_header.cbRfdOffset && fseek (object_stream, symbolic_header.cbRfdOffset, SEEK_SET) != 0) pfatal_with_name (object_name); if (debug) - { - fputs ("\twrite\tvp = ", stderr); - fprintf (stderr, HOST_PTR_PRINTF, (PTR) &orig_rfds); - fprintf (stderr, ", offset = %7lu, size = %7lu, %s\n", - (long) symbolic_header.cbRfdOffset, - num_write, "Relative file descriptors"); - } + fprintf (stderr, "\twrite\tvp = %p, offset = %7lu, size = %7lu, %s\n", + (void *) &orig_rfds, (long) symbolic_header.cbRfdOffset, + num_write, "Relative file descriptors"); sys_write = fwrite (orig_rfds, 1, @@ -4347,8 +4224,8 @@ write_object () if (sys_write <= 0) pfatal_with_name (object_name); - else if (sys_write != (long)num_write) - fatal ("Wrote %lu bytes to %s, system returned %ld", + else if (sys_write != (long) num_write) + fatal ("wrote %lu bytes to %s, system returned %ld", num_write, object_name, sys_write); @@ -4357,7 +4234,7 @@ write_object () } if (symbolic_header.issExtMax > 0) /* external symbols */ - write_varray (&ext_symbols, (off_t)symbolic_header.cbExtOffset, "External symbols"); + write_varray (&ext_symbols, (off_t) symbolic_header.cbExtOffset, "External symbols"); if (fclose (object_stream) != 0) pfatal_with_name (object_name); @@ -4367,10 +4244,9 @@ write_object () /* Read some bytes at a specified location, and return a pointer. */ STATIC page_t * -read_seek (size, offset, str) - Size_t size; /* # bytes to read */ - off_t offset; /* offset to read at */ - const char *str; /* name for tracing */ +read_seek (Size_t size, /* # bytes to read */ + off_t offset, /* offset to read at */ + const char *str) /* name for tracing */ { page_t *ptr; long sys_read = 0; @@ -4386,12 +4262,12 @@ read_seek (size, offset, str) #ifndef MALLOC_CHECK ptr = allocate_multiple_pages ((size + PAGE_USIZE - 1) / PAGE_USIZE); #else - ptr = (page_t *) xcalloc (1, size); + ptr = xcalloc (1, size); #endif /* If we need to seek, and the distance is nearby, just do some reads, to speed things up. */ - if (file_offset != offset) + if (file_offset != (unsigned long) offset) { symint_t difference = offset - file_offset; @@ -4403,8 +4279,8 @@ read_seek (size, offset, str) if (sys_read <= 0) pfatal_with_name (obj_in_name); - if ((symint_t)sys_read != difference) - fatal ("Wanted to read %lu bytes from %s, system returned %ld", + if ((symint_t) sys_read != difference) + fatal ("wanted to read %lu bytes from %s, system returned %ld", (unsigned long) size, obj_in_name, sys_read); @@ -4413,12 +4289,12 @@ read_seek (size, offset, str) pfatal_with_name (obj_in_name); } - sys_read = fread ((PTR) ptr, 1, size, obj_in_stream); + sys_read = fread (ptr, 1, size, obj_in_stream); if (sys_read <= 0) pfatal_with_name (obj_in_name); if (sys_read != (long) size) - fatal ("Wanted to read %lu bytes from %s, system returned %ld", + fatal ("wanted to read %lu bytes from %s, system returned %ld", (unsigned long) size, obj_in_name, sys_read); @@ -4437,7 +4313,7 @@ read_seek (size, offset, str) symbol table. */ STATIC void -copy_object () +copy_object (void) { char buffer[ PAGE_SIZE ]; int sys_read; @@ -4456,7 +4332,7 @@ copy_object () || fseek (obj_in_stream, 0L, SEEK_SET) != 0) pfatal_with_name (obj_in_name); - sys_read = fread ((PTR) &orig_file_header, + sys_read = fread (&orig_file_header, 1, sizeof (struct filehdr), obj_in_stream); @@ -4468,7 +4344,7 @@ copy_object () return; /* create a .T file sans file header */ else if (sys_read < (int) sizeof (struct filehdr)) - fatal ("Wanted to read %d bytes from %s, system returned %d", + fatal ("wanted to read %d bytes from %s, system returned %d", (int) sizeof (struct filehdr), obj_in_name, sys_read); @@ -4483,7 +4359,7 @@ copy_object () if (fseek (obj_in_stream, (long) orig_file_header.f_symptr, SEEK_SET) != 0) pfatal_with_name (input_name); - sys_read = fread ((PTR) &orig_sym_hdr, + sys_read = fread (&orig_sym_hdr, 1, sizeof (orig_sym_hdr), obj_in_stream); @@ -4492,14 +4368,14 @@ copy_object () pfatal_with_name (object_name); else if (sys_read < (int) sizeof (struct filehdr)) - fatal ("Wanted to read %d bytes from %s, system returned %d", + fatal ("wanted to read %d bytes from %s, system returned %d", (int) sizeof (struct filehdr), obj_in_name, sys_read); /* Read in each of the sections if they exist in the object file. - We read things in in the order the mips assembler creates the + We read things in the order the mips assembler creates the sections, so in theory no extra seeks are done. For simplicity sake, round each read up to a page boundary, @@ -4508,69 +4384,69 @@ copy_object () file_offset = orig_file_header.f_symptr + sizeof (struct filehdr); if (orig_sym_hdr.cbLine > 0) /* line numbers */ - orig_linenum = (char *) read_seek ((Size_t)orig_sym_hdr.cbLine, + orig_linenum = (char *) read_seek (orig_sym_hdr.cbLine, orig_sym_hdr.cbLineOffset, "Line numbers"); if (orig_sym_hdr.ipdMax > 0) /* procedure tables */ - orig_procs = (PDR *) read_seek ((Size_t)orig_sym_hdr.ipdMax * sizeof (PDR), + orig_procs = (PDR *) read_seek (orig_sym_hdr.ipdMax * sizeof (PDR), orig_sym_hdr.cbPdOffset, "Procedure tables"); if (orig_sym_hdr.isymMax > 0) /* local symbols */ - orig_local_syms = (SYMR *) read_seek ((Size_t)orig_sym_hdr.isymMax * sizeof (SYMR), + orig_local_syms = (SYMR *) read_seek (orig_sym_hdr.isymMax * sizeof (SYMR), orig_sym_hdr.cbSymOffset, "Local symbols"); if (orig_sym_hdr.iauxMax > 0) /* aux symbols */ - orig_aux_syms = (AUXU *) read_seek ((Size_t)orig_sym_hdr.iauxMax * sizeof (AUXU), + orig_aux_syms = (AUXU *) read_seek (orig_sym_hdr.iauxMax * sizeof (AUXU), orig_sym_hdr.cbAuxOffset, "Aux. symbols"); if (orig_sym_hdr.issMax > 0) /* local strings */ - orig_local_strs = (char *) read_seek ((Size_t)orig_sym_hdr.issMax, + orig_local_strs = (char *) read_seek (orig_sym_hdr.issMax, orig_sym_hdr.cbSsOffset, "Local strings"); if (orig_sym_hdr.issExtMax > 0) /* external strings */ - orig_ext_strs = (char *) read_seek ((Size_t)orig_sym_hdr.issExtMax, + orig_ext_strs = (char *) read_seek (orig_sym_hdr.issExtMax, orig_sym_hdr.cbSsExtOffset, "External strings"); if (orig_sym_hdr.ifdMax > 0) /* file tables */ - orig_files = (FDR *) read_seek ((Size_t)orig_sym_hdr.ifdMax * sizeof (FDR), + orig_files = (FDR *) read_seek (orig_sym_hdr.ifdMax * sizeof (FDR), orig_sym_hdr.cbFdOffset, "File tables"); if (orig_sym_hdr.crfd > 0) /* relative file descriptors */ - orig_rfds = (symint_t *) read_seek ((Size_t)orig_sym_hdr.crfd * sizeof (symint_t), + orig_rfds = (symint_t *) read_seek (orig_sym_hdr.crfd * sizeof (symint_t), orig_sym_hdr.cbRfdOffset, "Relative file descriptors"); if (orig_sym_hdr.issExtMax > 0) /* external symbols */ - orig_ext_syms = (EXTR *) read_seek ((Size_t)orig_sym_hdr.iextMax * sizeof (EXTR), + orig_ext_syms = (EXTR *) read_seek (orig_sym_hdr.iextMax * sizeof (EXTR), orig_sym_hdr.cbExtOffset, "External symbols"); if (orig_sym_hdr.idnMax > 0) /* dense numbers */ { - orig_dense = (DNR *) read_seek ((Size_t)orig_sym_hdr.idnMax * sizeof (DNR), + orig_dense = (DNR *) read_seek (orig_sym_hdr.idnMax * sizeof (DNR), orig_sym_hdr.cbDnOffset, "Dense numbers"); - add_bytes (&dense_num, (char *) orig_dense, (Size_t)orig_sym_hdr.idnMax); + add_bytes (&dense_num, (char *) orig_dense, orig_sym_hdr.idnMax); } if (orig_sym_hdr.ioptMax > 0) /* opt symbols */ - orig_opt_syms = (OPTR *) read_seek ((Size_t)orig_sym_hdr.ioptMax * sizeof (OPTR), + orig_opt_syms = (OPTR *) read_seek (orig_sym_hdr.ioptMax * sizeof (OPTR), orig_sym_hdr.cbOptOffset, "Optimizer symbols"); - /* Abort if the symbol table is not last. */ - if (max_file_offset != stat_buf.st_size) - fatal ("Symbol table is not last (symbol table ends at %ld, .o ends at %ld", + /* The symbol table should be last. */ + if (max_file_offset != (unsigned long) stat_buf.st_size) + fatal ("symbol table is not last (symbol table ends at %ld, .o ends at %ld", max_file_offset, (long) stat_buf.st_size); @@ -4593,7 +4469,7 @@ copy_object () (in case there are duplicate filenames, we collapse them into one file section, the MIPS assembler may or may not collapse them). */ - remap_file_number = (int *) alloca (sizeof (int) * orig_sym_hdr.ifdMax); + remap_file_number = alloca (sizeof (int) * orig_sym_hdr.ifdMax); for (fd = delete_ifd; fd < orig_sym_hdr.ifdMax; fd++) { @@ -4623,7 +4499,7 @@ copy_object () for (es = 0; es < orig_sym_hdr.iextMax; es++) { EXTR *eptr = orig_ext_syms + es; - unsigned ifd = eptr->ifd; + int ifd = eptr->ifd; (void) add_ext_symbol (eptr, ((long) ifd < orig_sym_hdr.ifdMax) ? remap_file_number[ ifd ] : ifd ); @@ -4686,7 +4562,7 @@ copy_object () char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss); Size_t len = strlen (str); shash_t *shash_ptr = hash_string (str, - (Ptrdiff_t)len, + (Ptrdiff_t) len, &orig_str_hash[0], &hash_index); @@ -4716,7 +4592,7 @@ copy_object () { Size_t len = strlen (str); shash_t *shash_ptr = hash_string (str, - (Ptrdiff_t)len, + (Ptrdiff_t) len, &orig_str_hash[0], (symint_t *) 0); @@ -4746,7 +4622,7 @@ copy_object () char *str = ORIG_LSTRS (fd_ptr->issBase + proc_sym->iss); Size_t len = strlen (str); shash_t *shash_ptr = hash_string (str, - (Ptrdiff_t)len, + (Ptrdiff_t) len, &orig_str_hash[0], (symint_t *) 0); @@ -4781,12 +4657,12 @@ copy_object () num_write = (remaining <= (int) sizeof (buffer)) ? remaining : (int) sizeof (buffer); - sys_read = fread ((PTR) buffer, 1, num_write, obj_in_stream); + sys_read = fread (buffer, 1, num_write, obj_in_stream); if (sys_read <= 0) pfatal_with_name (obj_in_name); else if (sys_read != num_write) - fatal ("Wanted to read %d bytes from %s, system returned %d", + fatal ("wanted to read %d bytes from %s, system returned %d", num_write, obj_in_name, sys_read); @@ -4796,7 +4672,7 @@ copy_object () pfatal_with_name (object_name); else if (sys_write != num_write) - fatal ("Wrote %d bytes to %s, system returned %d", + fatal ("wrote %d bytes to %s, system returned %d", num_write, object_name, sys_write); @@ -4806,12 +4682,10 @@ copy_object () /* Ye olde main program. */ -extern int main PARAMS ((int, char **)); +extern int main (int, char **); int -main (argc, argv) - int argc; - char **argv; +main (int argc, char **argv) { int iflag = 0; char *p = strrchr (argv[0], '/'); @@ -4827,12 +4701,12 @@ main (argc, argv) #if !defined(__SABER__) && !defined(lint) if (sizeof (efdr_t) > PAGE_USIZE) - fatal ("Efdr_t has a sizeof %d bytes, when it should be less than %d", + fatal ("efdr_t has a sizeof %d bytes, when it should be less than %d", (int) sizeof (efdr_t), (int) PAGE_USIZE); if (sizeof (page_t) != PAGE_USIZE) - fatal ("Page_t has a sizeof %d bytes, when it should be %d", + fatal ("page_t has a sizeof %d bytes, when it should be %d", (int) sizeof (page_t), (int) PAGE_USIZE); @@ -4854,7 +4728,7 @@ main (argc, argv) void_type_info = type_info_init; void_type_info.basic_type = bt_Void; - while ((option = getopt (argc, argv, "d:i:I:o:v")) != EOF) + while ((option = getopt_long (argc, argv, "d:i:I:o:v", options, NULL)) != -1) switch (option) { default: @@ -4863,7 +4737,7 @@ main (argc, argv) case 'd': debug = strtol (optarg, &num_end, 0); - if ((unsigned)debug > 4 || num_end == optarg) + if ((unsigned) debug > 4 || num_end == optarg) had_errors++; break; @@ -4874,7 +4748,7 @@ main (argc, argv) else rename_output = 1; - /* fall through to 'i' case. */ + /* Fall through to 'i' case. */ case 'i': if (obj_in_name == (char *) 0) @@ -4894,10 +4768,24 @@ main (argc, argv) break; case 'v': + verbose++; + break; + + case 'V': version++; break; } + if (version) + { + printf (_("mips-tfile %s%s\n"), pkgversion_string, version_string); + fputs ("Copyright (C) 2008 Free Software Foundation, Inc.\n", stdout); + fputs (_("This is free software; see the source for copying conditions. There is NO\n\ +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"), + stdout); + exit (0); + } + if (obj_in_name == (char *) 0 && optind <= argc - 2) obj_in_name = argv[--argc]; @@ -4907,13 +4795,25 @@ main (argc, argv) /* If there is an output name, but no input name use the same file for both, deleting the name between opening it for input and opening it for output. */ - if (obj_in_name == (char *) 0 && object_name != (char *)0) + if (obj_in_name == (char *) 0 && object_name != (char *) 0) { obj_in_name = object_name; delete_input = 1; } - if (object_name == (char *) 0 || had_errors || optind != argc - 1) + if (optind != argc - 1) + had_errors++; + + if (verbose || had_errors) + { + fprintf (stderr, _("mips-tfile (GCC) %s"), version_string); +#ifdef TARGET_VERSION + TARGET_VERSION; +#endif + fputc ('\n', stderr); + } + + if (object_name == (char *) 0 || had_errors) { fprintf (stderr, _("Calling Sequence:\n")); fprintf (stderr, _("\tmips-tfile [-d ] [-v] [-i ] -o (or)\n")); @@ -4928,16 +4828,6 @@ main (argc, argv) return 1; } - - if (version) - { - fprintf (stderr, _("mips-tfile version %s"), version_string); -#ifdef TARGET_VERSION - TARGET_VERSION; -#endif - fputc ('\n', stderr); - } - if (obj_in_name == (char *) 0) obj_in_name = object_name; @@ -4968,7 +4858,7 @@ main (argc, argv) fatal ("wrote %d bytes to %s, expected to write %d", len2, obj_in_name, len); } - free_multiple_pages ((page_t *)buffer, 4); + free_multiple_pages ((page_t *) buffer, 4); if (len < 0) pfatal_with_name (object_name); @@ -5009,7 +4899,7 @@ main (argc, argv) if (debug) { fprintf (stderr, "\n\tAllocation summary:\n\n"); - for (i = (int)alloc_type_none; i < (int)alloc_type_last; i++) + for (i = (int) alloc_type_none; i < (int) alloc_type_last; i++) if (alloc_counts[i].total_alloc) { fprintf (stderr, @@ -5028,19 +4918,17 @@ main (argc, argv) /* Catch a signal and exit without dumping core. */ STATIC void -catch_signal (signum) - int signum; +catch_signal (int signum) { (void) signal (signum, SIG_DFL); /* just in case... */ - fatal ("%s", strsignal(signum)); + fatal ("%s", strsignal (signum)); } /* Print a fatal error message. NAME is the text. Also include a system error message based on `errno'. */ void -pfatal_with_name (msg) - const char *msg; +pfatal_with_name (const char *msg) { int save_errno = errno; /* just in case.... */ if (line_number > 0) @@ -5058,16 +4946,15 @@ pfatal_with_name (msg) } -/* Procedure to abort with an out of bounds error message. It has +/* Procedure to die with an out of bounds error message. It has type int, so it can be used with an ?: expression within the ORIG_xxx macros, but the function never returns. */ static int -out_of_bounds (indx, max, str, prog_line) - symint_t indx; /* index that is out of bounds */ - symint_t max; /* maximum index */ - const char *str; /* string to print out */ - int prog_line; /* line number within mips-tfile.c */ +out_of_bounds (symint_t indx, /* index that is out of bounds */ + symint_t max, /* maximum index */ + const char *str, /* string to print out */ + int prog_line) /* line number within mips-tfile.c */ { if (indx < max) /* just in case */ return 0; @@ -5088,10 +4975,9 @@ out_of_bounds (indx, max, str, prog_line) #ifdef USE_MALLOC STATIC page_t * -allocate_cluster (npages) - Size_t npages; +allocate_cluster (Size_t npages) { - page_t *value = (page_t *) xcalloc (npages, PAGE_USIZE); + page_t *value = xcalloc (npages, PAGE_USIZE); if (debug > 3) fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value); @@ -5102,8 +4988,7 @@ allocate_cluster (npages) #else /* USE_MALLOC */ STATIC page_t * -allocate_cluster (npages) - Size_t npages; +allocate_cluster (Size_t npages) { page_t *ptr = (page_t *) sbrk (0); /* current sbreak */ unsigned long offset = ((unsigned long) ptr) & (PAGE_SIZE - 1); @@ -5113,19 +4998,15 @@ allocate_cluster (npages) if (sbrk (PAGE_USIZE - offset) == (char *)-1) pfatal_with_name ("allocate_cluster"); - ptr = (page_t *) (((char *)ptr) + PAGE_SIZE - offset); + ptr = (page_t *) (((char *) ptr) + PAGE_SIZE - offset); } - if (sbrk (npages * PAGE_USIZE) == (char *)-1) + if (sbrk (npages * PAGE_USIZE) == (char *) -1) pfatal_with_name ("allocate_cluster"); if (debug > 3) - { - fprintf (stderr, "\talloc\tnpages = %lu, value = ", - (unsigned long) npages); - fprintf (stderr, HOST_PTR_PRINTF, (PTR) ptr); - fputs ("\n", stderr); - } + fprintf (stderr, "\talloc\tnpages = %lu, value = %p\n", + (unsigned long) npages, (void *) ptr); return ptr; } @@ -5142,8 +5023,7 @@ static unsigned pages_left = 0; /* Allocate some pages (which is initialized to 0). */ STATIC page_t * -allocate_multiple_pages (npages) - Size_t npages; +allocate_multiple_pages (Size_t npages) { #ifndef MALLOC_CHECK if (pages_left == 0 && npages < MAX_CLUSTER_PAGES) @@ -5163,7 +5043,7 @@ allocate_multiple_pages (npages) return allocate_cluster (npages); #else /* MALLOC_CHECK */ - return (page_t *) xcalloc (npages, PAGE_SIZE); + return xcalloc (npages, PAGE_SIZE); #endif /* MALLOC_CHECK */ } @@ -5172,9 +5052,7 @@ allocate_multiple_pages (npages) /* Release some pages. */ STATIC void -free_multiple_pages (page_ptr, npages) - page_t *page_ptr; - Size_t npages; +free_multiple_pages (page_t *page_ptr, Size_t npages) { #ifndef MALLOC_CHECK if (pages_left == 0) @@ -5194,7 +5072,7 @@ free_multiple_pages (page_ptr, npages) the free pages is done right after an allocate. */ #else /* MALLOC_CHECK */ - free ((char *) page_ptr); + free (page_ptr); #endif /* MALLOC_CHECK */ } @@ -5203,7 +5081,7 @@ free_multiple_pages (page_ptr, npages) /* Allocate one page (which is initialized to 0). */ STATIC page_t * -allocate_page () +allocate_page (void) { #ifndef MALLOC_CHECK if (pages_left == 0) @@ -5216,7 +5094,7 @@ allocate_page () return cluster_ptr++; #else /* MALLOC_CHECK */ - return (page_t *) xcalloc (1, PAGE_SIZE); + return xcalloc (1, PAGE_SIZE); #endif /* MALLOC_CHECK */ } @@ -5225,38 +5103,38 @@ allocate_page () /* Allocate scoping information. */ STATIC scope_t * -allocate_scope () +allocate_scope (void) { 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 *) 0) - 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 { - int unallocated = alloc_counts[ (int)alloc_type_scope ].unallocated; - page_t *cur_page = alloc_counts[ (int)alloc_type_scope ].cur_page; + int unallocated = alloc_counts[ (int) alloc_type_scope ].unallocated; + page_t *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 - ptr = (scope_t *) xmalloc (sizeof (scope_t)); + ptr = xmalloc (sizeof (scope_t)); #endif - alloc_counts[ (int)alloc_type_scope ].total_alloc++; + alloc_counts[ (int) alloc_type_scope ].total_alloc++; *ptr = initial_scope; return ptr; } @@ -5264,17 +5142,16 @@ 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); + free (ptr); #endif } @@ -5283,31 +5160,31 @@ free_scope (ptr) /* Allocate links for pages in a virtual array. */ STATIC vlinks_t * -allocate_vlinks () +allocate_vlinks (void) { vlinks_t *ptr; static vlinks_t initial_vlinks; #ifndef MALLOC_CHECK - int unallocated = alloc_counts[ (int)alloc_type_vlinks ].unallocated; - page_t *cur_page = alloc_counts[ (int)alloc_type_vlinks ].cur_page; + int unallocated = alloc_counts[ (int) alloc_type_vlinks ].unallocated; + page_t *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 - ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t)); + ptr = xmalloc (sizeof (vlinks_t)); #endif - alloc_counts[ (int)alloc_type_vlinks ].total_alloc++; + alloc_counts[ (int) alloc_type_vlinks ].total_alloc++; *ptr = initial_vlinks; return ptr; } @@ -5316,31 +5193,31 @@ allocate_vlinks () /* Allocate string hash buckets. */ STATIC shash_t * -allocate_shash () +allocate_shash (void) { shash_t *ptr; static shash_t initial_shash; #ifndef MALLOC_CHECK - int unallocated = alloc_counts[ (int)alloc_type_shash ].unallocated; - page_t *cur_page = alloc_counts[ (int)alloc_type_shash ].cur_page; + int unallocated = alloc_counts[ (int) alloc_type_shash ].unallocated; + page_t *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 - ptr = (shash_t *) xmalloc (sizeof (shash_t)); + ptr = xmalloc (sizeof (shash_t)); #endif - alloc_counts[ (int)alloc_type_shash ].total_alloc++; + alloc_counts[ (int) alloc_type_shash ].total_alloc++; *ptr = initial_shash; return ptr; } @@ -5349,31 +5226,31 @@ allocate_shash () /* Allocate type hash buckets. */ STATIC thash_t * -allocate_thash () +allocate_thash (void) { thash_t *ptr; static thash_t initial_thash; #ifndef MALLOC_CHECK - int unallocated = alloc_counts[ (int)alloc_type_thash ].unallocated; - page_t *cur_page = alloc_counts[ (int)alloc_type_thash ].cur_page; + int unallocated = alloc_counts[ (int) alloc_type_thash ].unallocated; + page_t *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 - ptr = (thash_t *) xmalloc (sizeof (thash_t)); + ptr = xmalloc (sizeof (thash_t)); #endif - alloc_counts[ (int)alloc_type_thash ].total_alloc++; + alloc_counts[ (int) alloc_type_thash ].total_alloc++; *ptr = initial_thash; return ptr; } @@ -5382,38 +5259,38 @@ allocate_thash () /* Allocate structure, union, or enum tag information. */ STATIC tag_t * -allocate_tag () +allocate_tag (void) { 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 *) 0) - 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 { - int unallocated = alloc_counts[ (int)alloc_type_tag ].unallocated; - page_t *cur_page = alloc_counts[ (int)alloc_type_tag ].cur_page; + int unallocated = alloc_counts[ (int) alloc_type_tag ].unallocated; + page_t *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 - ptr = (tag_t *) xmalloc (sizeof (tag_t)); + ptr = xmalloc (sizeof (tag_t)); #endif - alloc_counts[ (int)alloc_type_tag ].total_alloc++; + alloc_counts[ (int) alloc_type_tag ].total_alloc++; *ptr = initial_tag; return ptr; } @@ -5421,17 +5298,16 @@ 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) ptr); + free (ptr); #endif } @@ -5440,38 +5316,38 @@ free_tag (ptr) /* Allocate forward reference to a yet unknown tag. */ STATIC forward_t * -allocate_forward () +allocate_forward (void) { forward_t *ptr; static forward_t initial_forward; #ifndef MALLOC_CHECK - ptr = alloc_counts[ (int)alloc_type_forward ].free_list.f_forward; + ptr = alloc_counts[ (int) alloc_type_forward ].free_list.f_forward; if (ptr != (forward_t *) 0) - alloc_counts[ (int)alloc_type_forward ].free_list.f_forward = ptr->free; + alloc_counts[ (int) alloc_type_forward ].free_list.f_forward = ptr->free; else { - int unallocated = alloc_counts[ (int)alloc_type_forward ].unallocated; - page_t *cur_page = alloc_counts[ (int)alloc_type_forward ].cur_page; + int unallocated = alloc_counts[ (int) alloc_type_forward ].unallocated; + page_t *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 - ptr = (forward_t *) xmalloc (sizeof (forward_t)); + ptr = xmalloc (sizeof (forward_t)); #endif - alloc_counts[ (int)alloc_type_forward ].total_alloc++; + alloc_counts[ (int) alloc_type_forward ].total_alloc++; *ptr = initial_forward; return ptr; } @@ -5479,17 +5355,16 @@ allocate_forward () /* Free scoping information. */ STATIC void -free_forward (ptr) - forward_t *ptr; +free_forward (forward_t *ptr) { - alloc_counts[ (int)alloc_type_forward ].total_free++; + alloc_counts[ (int) alloc_type_forward ].total_free++; #ifndef MALLOC_CHECK - ptr->free = alloc_counts[ (int)alloc_type_forward ].free_list.f_forward; - alloc_counts[ (int)alloc_type_forward ].free_list.f_forward = ptr; + ptr->free = alloc_counts[ (int) alloc_type_forward ].free_list.f_forward; + alloc_counts[ (int) alloc_type_forward ].free_list.f_forward = ptr; #else - free ((PTR) ptr); + free (ptr); #endif } @@ -5498,38 +5373,38 @@ free_forward (ptr) /* Allocate head of type hash list. */ STATIC thead_t * -allocate_thead () +allocate_thead (void) { 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 *) 0) - 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 { - int unallocated = alloc_counts[ (int)alloc_type_thead ].unallocated; - page_t *cur_page = alloc_counts[ (int)alloc_type_thead ].cur_page; + int unallocated = alloc_counts[ (int) alloc_type_thead ].unallocated; + page_t *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 - ptr = (thead_t *) xmalloc (sizeof (thead_t)); + ptr = xmalloc (sizeof (thead_t)); #endif - alloc_counts[ (int)alloc_type_thead ].total_alloc++; + alloc_counts[ (int) alloc_type_thead ].total_alloc++; *ptr = initial_thead; return ptr; } @@ -5537,17 +5412,16 @@ 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) ptr); + free (ptr); #endif } @@ -5555,14 +5429,14 @@ free_thead (ptr) #endif /* MIPS_DEBUGGING_INFO */ -/* Output an error message and exit */ +/* Output an error message and exit. */ -/*VARARGS*/ void -fatal VPARAMS ((const char *format, ...)) +fatal (const char *format, ...) { - VA_OPEN (ap, format); - VA_FIXEDARG (ap, const char *, format); + va_list ap; + + va_start (ap, format); if (line_number > 0) fprintf (stderr, "%s, %s:%ld ", progname, input_name, line_number); @@ -5570,7 +5444,7 @@ fatal VPARAMS ((const char *format, ...)) fprintf (stderr, "%s:", progname); vfprintf (stderr, format, ap); - VA_CLOSE (ap); + va_end (ap); fprintf (stderr, "\n"); if (line_number > 0) fprintf (stderr, "line:\t%s\n", cur_line_start); @@ -5579,12 +5453,12 @@ fatal VPARAMS ((const char *format, ...)) exit (1); } -/*VARARGS*/ void -error VPARAMS ((const char *format, ...)) +error (const char *format, ...) { - VA_OPEN (ap, format); - VA_FIXEDARG (ap, char *, format); + va_list ap; + + va_start (ap, format); if (line_number > 0) fprintf (stderr, "%s, %s:%ld ", progname, input_name, line_number); @@ -5597,18 +5471,17 @@ error VPARAMS ((const char *format, ...)) fprintf (stderr, "line:\t%s\n", cur_line_start); had_errors++; - VA_CLOSE (ap); + va_end (ap); saber_stop (); } -/* More 'friendly' abort that prints the line and file. - config.h can #define abort fancy_abort if you like that sort of thing. */ +/* More 'friendly' abort that prints the line and file. */ void -fancy_abort () +fancy_abort (const char *file, int line, const char *func) { - fatal ("Internal abort"); + fatal ("abort in %s, at %s:%d", func, file, line); } @@ -5616,8 +5489,7 @@ fancy_abort () it calls this function to report clobberage. */ void -botch (s) - const char *s; +botch (const char *s) { fatal ("%s", s); }