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,
- 2002, 2003 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2005 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
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)
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
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
}
Mips-tdump produces the following information:
-
+
Global file header:
magic number 0x162
# sections 2
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
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
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"
/* 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;
\f
#ifndef MIPS_DEBUGGING_INFO
static const char *input_name;
int
-main ()
+main (void)
{
fprintf (stderr, "Mips-tfile should only be run on a MIPS computer!\n");
exit (1);
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 */
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 INITIALIZE_VARRAY(x,type) \
do { \
(x)->object_size = sizeof (type); \
- (x)->objects_per_page = OBJECTS_PER_PAGE (type); \
+ (x)->objects_per_page = OBJECTS_PER_PAGE (type); \
(x)->objects_last_page = OBJECTS_PER_PAGE (type); \
} while (0)
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*/
#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 initialize_init_file PARAMS ((void));
-
-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;
typedef struct _pseudo_ops {
const char *const name; /* pseudo-op in ascii */
const int len; /* length of name to compare */
- void (*const func) PARAMS ((const char *)); /* function to handle line */
+ void (*const func) (const char *); /* function to handle line */
} pseudo_ops_t;
static const pseudo_ops_t pseudo_ops[] = {
/* 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 ();
#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;
\f
/* 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;
}
\f
-/* 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;
}
\f
-/* 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 */
/* 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;
/* 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;
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;
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.)
/* 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;
/* 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;
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;
/* Initialize the init_file structure. */
STATIC void
-initialize_init_file ()
+initialize_init_file (void)
{
- memset ((void*) &init_file, 0, sizeof (init_file));
+ memset (&init_file, 0, sizeof (init_file));
init_file.fdr.lang = langC;
init_file.fdr.fMerge = 1;
init_file.fdr.glevel = GLEVEL_2;
-#ifdef HOST_WORDS_BIG_ENDIAN
+#ifdef WORDS_BIG_ENDIAN
init_file.fdr.fBigendian = 1;
#endif
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' };
/* 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;
/* 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)
{
/* 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)
{
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;
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;
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;
.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*/
&& 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++)
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,
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. */
/* 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;
/* 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;
/* 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;
/* 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)
{
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;
STATIC void
-parse_stabs (start)
- const char *start; /* start of directive */
+parse_stabs (const char *start)
{
const char *end = strchr (start+1, '"');
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);
}
if needed. */
STATIC void
-parse_input ()
+parse_input (void)
{
char *p;
Size_t i;
while ((p = read_line ()) != (char *) 0)
{
- /* Skip leading blanks */
+ /* Skip leading blanks. */
while (ISSPACE ((unsigned char)*p))
p++;
to write out the .T file. */
STATIC void
-update_headers ()
+update_headers (void)
{
symint_t i;
efdr_t *file_ptr;
hash_ptr = hash_string (str,
(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,
/* 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;
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);
- }
-
+ fprintf (stderr, "\twarray\tvp = " HOST_PTR_PRINTF
+ ", 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);
? 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);
/* 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 = " HOST_PTR_PRINTF
+ ", 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);
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 = " HOST_PTR_PRINTF
+ ", 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);
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 = " HOST_PTR_PRINTF
+ ", 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);
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 = " HOST_PTR_PRINTF
+ ", 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,
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 = " HOST_PTR_PRINTF
+ ", offset = %7lu, size = %7lu, %s\n",
+ (void *) &orig_rfds, (long) symbolic_header.cbRfdOffset,
+ num_write, "Relative file descriptors");
sys_write = fwrite (orig_rfds,
1,
/* 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;
#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,
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);
symbol table. */
STATIC void
-copy_object ()
+copy_object (void)
{
char buffer[ PAGE_SIZE ];
int sys_read;
|| 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);
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);
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. */
+ /* 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,
(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++)
{
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);
\f
/* 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], '/');
else
rename_output = 1;
- /* fall through to 'i' case. */
+ /* Fall through to 'i' case. */
case 'i':
if (obj_in_name == (char *) 0)
if (version)
{
printf (_("mips-tfile (GCC) %s\n"), version_string);
- fputs (_("Copyright (C) 2003 Free Software Foundation, Inc.\n"), stdout);
+ fputs ("Copyright (C) 2004 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);
+ stdout);
exit (0);
}
/* 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));
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)
}
\f
-/* 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;
#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);
#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);
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 = " HOST_PTR_PRINTF "\n",
+ (unsigned long) npages, (void *) ptr);
return ptr;
}
/* 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)
return allocate_cluster (npages);
#else /* MALLOC_CHECK */
- return (page_t *) xcalloc (npages, PAGE_SIZE);
+ return xcalloc (npages, PAGE_SIZE);
#endif /* MALLOC_CHECK */
}
/* 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)
the free pages is done right after an allocate. */
#else /* MALLOC_CHECK */
- free ((char *) page_ptr);
+ free (page_ptr);
#endif /* MALLOC_CHECK */
}
/* Allocate one page (which is initialized to 0). */
STATIC page_t *
-allocate_page ()
+allocate_page (void)
{
#ifndef MALLOC_CHECK
if (pages_left == 0)
return cluster_ptr++;
#else /* MALLOC_CHECK */
- return (page_t *) xcalloc (1, PAGE_SIZE);
+ return xcalloc (1, PAGE_SIZE);
#endif /* MALLOC_CHECK */
}
/* Allocate scoping information. */
STATIC scope_t *
-allocate_scope ()
+allocate_scope (void)
{
scope_t *ptr;
static scope_t initial_scope;
}
#else
- ptr = (scope_t *) xmalloc (sizeof (scope_t));
+ ptr = xmalloc (sizeof (scope_t));
#endif
/* 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 ].free_list.f_scope = ptr;
#else
- free ((PTR) ptr);
+ free (ptr);
#endif
}
/* Allocate links for pages in a virtual array. */
STATIC vlinks_t *
-allocate_vlinks ()
+allocate_vlinks (void)
{
vlinks_t *ptr;
static vlinks_t initial_vlinks;
alloc_counts[ (int) alloc_type_vlinks ].unallocated = unallocated;
#else
- ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
+ ptr = xmalloc (sizeof (vlinks_t));
#endif
/* Allocate string hash buckets. */
STATIC shash_t *
-allocate_shash ()
+allocate_shash (void)
{
shash_t *ptr;
static shash_t initial_shash;
alloc_counts[ (int) alloc_type_shash ].unallocated = unallocated;
#else
- ptr = (shash_t *) xmalloc (sizeof (shash_t));
+ ptr = xmalloc (sizeof (shash_t));
#endif
/* Allocate type hash buckets. */
STATIC thash_t *
-allocate_thash ()
+allocate_thash (void)
{
thash_t *ptr;
static thash_t initial_thash;
alloc_counts[ (int) alloc_type_thash ].unallocated = unallocated;
#else
- ptr = (thash_t *) xmalloc (sizeof (thash_t));
+ ptr = xmalloc (sizeof (thash_t));
#endif
/* Allocate structure, union, or enum tag information. */
STATIC tag_t *
-allocate_tag ()
+allocate_tag (void)
{
tag_t *ptr;
static tag_t initial_tag;
}
#else
- ptr = (tag_t *) xmalloc (sizeof (tag_t));
+ ptr = xmalloc (sizeof (tag_t));
#endif
/* 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 ].free_list.f_tag = ptr;
#else
- free ((PTR) ptr);
+ free (ptr);
#endif
}
/* Allocate forward reference to a yet unknown tag. */
STATIC forward_t *
-allocate_forward ()
+allocate_forward (void)
{
forward_t *ptr;
static forward_t initial_forward;
}
#else
- ptr = (forward_t *) xmalloc (sizeof (forward_t));
+ ptr = xmalloc (sizeof (forward_t));
#endif
/* 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 ].free_list.f_forward = ptr;
#else
- free ((PTR) ptr);
+ free (ptr);
#endif
}
/* Allocate head of type hash list. */
STATIC thead_t *
-allocate_thead ()
+allocate_thead (void)
{
thead_t *ptr;
static thead_t initial_thead;
}
#else
- ptr = (thead_t *) xmalloc (sizeof (thead_t));
+ ptr = xmalloc (sizeof (thead_t));
#endif
/* 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 ].free_list.f_thead = ptr;
#else
- free ((PTR) ptr);
+ free (ptr);
#endif
}
#endif /* MIPS_DEBUGGING_INFO */
\f
-/* Output an error message and exit */
+/* Output an error message and exit. */
void
fatal (const char *format, ...)
{
va_list ap;
-
+
va_start (ap, format);
if (line_number > 0)
error (const char *format, ...)
{
va_list ap;
-
+
va_start (ap, format);
if (line_number > 0)
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);
}
\f
it calls this function to report clobberage. */
void
-botch (s)
- const char *s;
+botch (const char *s)
{
fatal ("%s", s);
}
OSDN Git Service
