/* ECOFF debugging support.
- Copyright (C) 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
+ Free Software Foundation, Inc.
Contributed by Cygnus Support.
This file was put together by Ian Lance Taylor <ian@cygnus.com>. A
good deal of it comes directly from mips-tfile.c, by Michael
ECOFF debugging information (e.g., MIPS ECOFF, MIPS ELF, Alpha
ECOFF). */
+#include "ecoff.h"
+
#ifdef ECOFF_DEBUGGING
#include "coff/internal.h"
#include "coff/symconst.h"
-#include "ecoff.h"
#include "aout/stab_gnu.h"
-#include <ctype.h>
+#include "safe-ctype.h"
/* Why isn't this in coff/sym.h? */
#define ST_RFDESCAPE 0xfff
tqFar -- 8086 far pointers
tqVol -- volatile
-
The dense number table is used in the front ends, and disappears by
the time the .o is created.
5) index: pointer to a local symbol or aux. entry.
-
-
For the following program:
#include <stdio.h>
/* States for whether to hash type or not. */
typedef enum hash_state {
- hash_no = 0, /* don't hash type */
- hash_yes = 1, /* ok to hash type, or use previous hash */
- hash_record = 2 /* ok to record hash, but don't use prev. */
+ hash_no = 0, /* Don't hash type */
+ hash_yes = 1, /* OK to hash type, or use previous hash */
+ hash_record = 2 /* OK to record hash, but don't use prev. */
} hash_state_t;
/* Types of different sized allocation requests. */
can't be represented (assuming there are strings > 4096 bytes). */
/* FIXME: Yes, there can be such strings while emitting C++ class debug
- info. Templates are the offender here, the test case in question
+ info. Templates are the offender here, the test case in question
having a mangled class name of
t7rb_tree4Z4xkeyZt4pair2ZC4xkeyZt7xsocket1Z4UserZt9select1st2Zt4pair\
unsigned long start_index; /* starting index # of page */
} vlinks_t;
-
/* Virtual array header. */
typedef struct varray {
vlinks_t *first; /* first page link */
OBJECTS_PER_PAGE (type), /* objects_last_page */ \
}
-
-/* Master type for indexes within the symbol table. */
+/* Master type for indexes within the symbol table. */
typedef unsigned long symint_t;
-
/* Linked list support for nested scopes (file, block, structure, etc.). */
typedef struct scope {
struct scope *prev; /* previous scope level */
st_t type; /* type of the node */
} scope_t;
-
/* For a local symbol we store a gas symbol as well as the debugging
information we generate. The gas symbol will be NULL if this is
only a debugging symbol. */
EXTR ecoff_sym; /* ECOFF debugging symbol */
} localsym_t;
-
/* For aux information we keep the type and the data. */
typedef struct ecoff_aux {
enum aux_type type; /* aux type */
/* Number of proc_t structures allocated. */
static unsigned long proc_cnt;
-
/* Forward reference list for tags referenced, but not yet defined. */
typedef struct forward {
struct forward *next; /* next forward reference */
aux_t *index_ptr; /* pointer to store symbol index */
} forward_t;
-
/* Linked list support for tags. The first tag in the list is always
the current tag for that block. */
typedef struct tag {
localsym_t *sym; /* file's local symbols */
} tag_t;
-
/* Head of a block's linked list of tags. */
typedef struct thead {
struct thead *prev; /* previous block */
struct tag *first_tag; /* first tag in block defined */
} thead_t;
-
/* Union containing pointers to each the small structures which are freed up. */
typedef union small_free {
scope_t *f_scope; /* scope structure */
forward_t *f_forward; /* forward tag reference */
} small_free_t;
-
/* String hash table entry. */
typedef struct shash {
proc_t *proc_ptr; /* procedure descriptor pointer */
} shash_t;
-
/* Type hash table support. The size of the hash table must fit
within a page with the other extended file descriptor information.
Because unique types which are hashed are fewer in number than
symint_t indx; /* index within string table */
} thash_t;
-
/* Extended file descriptor that contains all of the support necessary
to add things to each file separately. */
typedef struct efdr {
} efdr_t;
/* Pre-initialized extended file structure. */
-static const efdr_t init_file =
-{
+static const efdr_t init_file = {
{ /* FDR structure */
0, /* adr: memory address of beginning of file */
0, /* rss: file name (of source, if known) */
{ 0 }, /* thash_head: type hash table */
};
-
static efdr_t *first_file; /* first file descriptor */
static efdr_t **last_file_ptr = &first_file; /* file descriptor tail */
-
/* Line number information is kept in a list until the assembly is
finished. */
typedef struct lineno_list {
lineno_list_t lineno [ PAGE_SIZE / sizeof (lineno_list_t) ];
} page_type;
-
/* Structure holding allocation information for small sized structures. */
typedef struct alloc_info {
char *alloc_name; /* name of this allocation type (must be first) */
int total_pages; /* total number of pages allocated */
} alloc_info_t;
-
/* Type information collected together. */
typedef struct type_info {
bt_t basic_type; /* basic type */
/* Global hash table for the tags table and global table for file
descriptors. */
-static varray_t file_desc = INIT_VARRAY (efdr_t);
+static varray_t file_desc = INIT_VARRAY (efdr_t);
static struct hash_control *tag_hash;
static type_info_t last_func_type_info;
static symbolS *last_func_sym_value;
-
/* Convert COFF basic type to ECOFF basic type. The T_NULL type
really should use bt_Void, but this causes the current ecoff GDB to
issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS
st_Nil, /* 106: C_HIDDEN ??? */
};
-
/* Keep track of different sized allocation requests. */
-static alloc_info_t alloc_counts[ (int)alloc_type_last ];
+static alloc_info_t alloc_counts[(int) alloc_type_last];
\f
/* Record whether we have seen any debugging information. */
int ecoff_debugging_seen = 0;
\f
/* Prototypes for functions defined in this file. */
-static void add_varray_page PARAMS ((varray_t *vp));
-static symint_t add_string PARAMS ((varray_t *vp,
- struct hash_control *hash_tbl,
- const char *str,
- shash_t **ret_hash));
-static localsym_t *add_ecoff_symbol PARAMS ((const char *str, st_t type,
- sc_t storage, symbolS *sym,
- bfd_vma addend, symint_t value,
- symint_t indx));
-static symint_t add_aux_sym_symint PARAMS ((symint_t aux_word));
-static symint_t add_aux_sym_rndx PARAMS ((int file_index,
- symint_t sym_index));
-static symint_t add_aux_sym_tir PARAMS ((type_info_t *t,
- hash_state_t state,
- thash_t **hash_tbl));
-static tag_t *get_tag PARAMS ((const char *tag, localsym_t *sym,
- bt_t basic_type));
-static void add_unknown_tag PARAMS ((tag_t *ptag));
-static void add_procedure PARAMS ((char *func));
-static void add_file PARAMS ((const char *file_name, int indx, int fake));
+static void add_varray_page (varray_t *vp);
+static symint_t add_string (varray_t *vp,
+ struct hash_control *hash_tbl,
+ const char *str,
+ shash_t **ret_hash);
+static localsym_t *add_ecoff_symbol (const char *str, st_t type,
+ sc_t storage, symbolS *sym,
+ bfd_vma addend, symint_t value,
+ symint_t indx);
+static symint_t add_aux_sym_symint (symint_t aux_word);
+static symint_t add_aux_sym_rndx (int file_index, symint_t sym_index);
+static symint_t add_aux_sym_tir (type_info_t *t,
+ hash_state_t state,
+ thash_t **hash_tbl);
+static tag_t *get_tag (const char *tag, localsym_t *sym, bt_t basic_type);
+static void add_unknown_tag (tag_t *ptag);
+static void add_procedure (char *func);
+static void add_file (const char *file_name, int indx, int fake);
#ifdef ECOFF_DEBUG
-static char *sc_to_string PARAMS ((sc_t storage_class));
-static char *st_to_string PARAMS ((st_t symbol_type));
+static char *sc_to_string (sc_t storage_class);
+static char *st_to_string (st_t symbol_type);
#endif
-static void mark_stabs PARAMS ((int));
-static char *ecoff_add_bytes PARAMS ((char **buf, char **bufend,
- char *bufptr, unsigned long need));
+static void mark_stabs (int);
+static char *ecoff_add_bytes (char **buf, char **bufend,
+ char *bufptr, unsigned long need);
static unsigned long ecoff_padding_adjust
- PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
- unsigned long offset, char **bufptrptr));
+ (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
+ unsigned long offset, char **bufptrptr);
static unsigned long ecoff_build_lineno
- PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
- unsigned long offset, long *linecntptr));
+ (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
+ unsigned long offset, long *linecntptr);
static unsigned long ecoff_build_symbols
- PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
- unsigned long offset));
+ (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
+ unsigned long offset);
static unsigned long ecoff_build_procs
- PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
- unsigned long offset));
+ (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
+ unsigned long offset);
static unsigned long ecoff_build_aux
- PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
- unsigned long offset));
-static unsigned long ecoff_build_strings PARAMS ((char **buf, char **bufend,
- unsigned long offset,
- varray_t *vp));
+ (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
+ unsigned long offset);
+static unsigned long ecoff_build_strings (char **buf, char **bufend,
+ unsigned long offset,
+ varray_t *vp);
static unsigned long ecoff_build_ss
- PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
- unsigned long offset));
+ (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
+ unsigned long offset);
static unsigned long ecoff_build_fdr
- PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
- unsigned long offset));
-static void ecoff_setup_ext PARAMS ((void));
-static page_type *allocate_cluster PARAMS ((unsigned long npages));
-static page_type *allocate_page PARAMS ((void));
-static scope_t *allocate_scope PARAMS ((void));
-static void free_scope PARAMS ((scope_t *ptr));
-static vlinks_t *allocate_vlinks PARAMS ((void));
-static shash_t *allocate_shash PARAMS ((void));
-static thash_t *allocate_thash PARAMS ((void));
-static tag_t *allocate_tag PARAMS ((void));
-static void free_tag PARAMS ((tag_t *ptr));
-static forward_t *allocate_forward PARAMS ((void));
-static thead_t *allocate_thead PARAMS ((void));
-static void free_thead PARAMS ((thead_t *ptr));
-static lineno_list_t *allocate_lineno_list PARAMS ((void));
+ (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
+ unsigned long offset);
+static void ecoff_setup_ext (void);
+static page_type *allocate_cluster (unsigned long npages);
+static page_type *allocate_page (void);
+static scope_t *allocate_scope (void);
+static void free_scope (scope_t *ptr);
+static vlinks_t *allocate_vlinks (void);
+static shash_t *allocate_shash (void);
+static thash_t *allocate_thash (void);
+static tag_t *allocate_tag (void);
+static void free_tag (tag_t *ptr);
+static forward_t *allocate_forward (void);
+static thead_t *allocate_thead (void);
+static void free_thead (thead_t *ptr);
+static lineno_list_t *allocate_lineno_list (void);
\f
/* This function should be called when the assembler starts up. */
void
-ecoff_read_begin_hook ()
+ecoff_read_begin_hook (void)
{
tag_hash = hash_new ();
top_tag_head = allocate_thead ();
/* This function should be called when a symbol is created. */
void
-ecoff_symbol_new_hook (symbolP)
- symbolS *symbolP;
+ecoff_symbol_new_hook (symbolS *symbolP)
{
OBJ_SYMFIELD_TYPE *obj;
/* Add a page to a varray object. */
static void
-add_varray_page (vp)
- varray_t *vp; /* varray to add page to */
+add_varray_page (varray_t *vp /* varray to add page to */)
{
vlinks_t *new_links = allocate_vlinks ();
#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;
/* Add a string (and null pad) to one of the string tables. */
static symint_t
-add_string (vp, hash_tbl, str, ret_hash)
- varray_t *vp; /* string obstack */
- struct hash_control *hash_tbl; /* ptr to hash table */
- const char *str; /* string */
- shash_t **ret_hash; /* return hash pointer */
+add_string (varray_t *vp, /* string obstack */
+ struct hash_control *hash_tbl, /* ptr to hash table */
+ const char *str, /* string */
+ shash_t **ret_hash /* return hash pointer */)
{
register unsigned long len = strlen (str);
register shash_t *hash_ptr;
if (len >= PAGE_USIZE)
- as_fatal (_("String too big (%lu bytes)"), len);
+ as_fatal (_("string too big (%lu bytes)"), len);
hash_ptr = (shash_t *) hash_find (hash_tbl, str);
if (hash_ptr == (shash_t *) NULL)
register const char *err;
if (vp->objects_last_page + len >= PAGE_USIZE)
- {
- vp->num_allocated =
- ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
- add_varray_page (vp);
- }
+ {
+ vp->num_allocated =
+ ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
+ add_varray_page (vp);
+ }
hash_ptr = allocate_shash ();
hash_ptr->indx = vp->num_allocated;
err = hash_insert (hash_tbl, str, (char *) hash_ptr);
if (err)
- as_fatal (_("Inserting \"%s\" into string hash table: %s"),
+ as_fatal (_("inserting \"%s\" into string hash table: %s"),
str, err);
}
/* Add debugging information for a symbol. */
static localsym_t *
-add_ecoff_symbol (str, type, storage, sym_value, addend, value, indx)
- const char *str; /* symbol name */
- st_t type; /* symbol type */
- sc_t storage; /* storage class */
- symbolS *sym_value; /* associated symbol. */
- bfd_vma addend; /* addend to sym_value. */
- symint_t value; /* value of symbol */
- symint_t indx; /* index to local/aux. syms */
+add_ecoff_symbol (const char *str, /* symbol name */
+ st_t type, /* symbol type */
+ sc_t storage, /* storage class */
+ symbolS *sym_value, /* associated symbol. */
+ bfd_vma addend, /* addend to sym_value. */
+ symint_t value, /* value of symbol */
+ symint_t indx /* index to local/aux. syms */)
{
localsym_t *psym;
register scope_t *pscope;
vp = &cur_file_ptr->symbols;
- if (vp->objects_last_page == vp->objects_per_page)
+ if (vp->objects_last_page == vp->objects_per_page)
add_varray_page (vp);
- psym = &vp->last->datum->sym[ vp->objects_last_page++ ];
+ psym = &vp->last->datum->sym[vp->objects_last_page++];
if (str == (const char *) NULL && sym_value != (symbolS *) NULL)
psym->name = S_GET_NAME (sym_value);
scope_delta = 1;
/* For every block type except file, struct, union, or
- enumeration blocks, push a level on the tag stack. We omit
- file types, so that tags can span file boundaries. */
+ enumeration blocks, push a level on the tag stack. We omit
+ file types, so that tags can span file boundaries. */
if (type != st_File && storage != sc_Info)
{
ptag_head = allocate_thead ();
value, depth, sc_str);
if (str_start && str_end_p1 - str_start > 0)
- fprintf (stderr, " st= %-11s name= %.*s\n", st_str, str_end_p1 - str_start, str_start);
+ fprintf (stderr, " st= %-11s name= %.*s\n",
+ st_str, str_end_p1 - str_start, str_start);
else
{
unsigned long len = strlen (st_str);
- fprintf (stderr, " st= %.*s\n", len-1, st_str);
+ fprintf (stderr, " st= %.*s\n", len - 1, st_str);
}
}
#endif
for integral aux types, not just symints. */
static symint_t
-add_aux_sym_symint (aux_word)
- symint_t aux_word; /* auxiliary information word */
+add_aux_sym_symint (symint_t aux_word /* auxiliary information word */)
{
register varray_t *vp;
register aux_t *aux_ptr;
return vp->num_allocated++;
}
-
/* Add an auxiliary symbol (passing a file/symbol index combo). */
static symint_t
-add_aux_sym_rndx (file_index, sym_index)
- int file_index;
- symint_t sym_index;
+add_aux_sym_rndx (int file_index, symint_t sym_index)
{
register varray_t *vp;
register aux_t *aux_ptr;
type qualifiers). */
static symint_t
-add_aux_sym_tir (t, state, hash_tbl)
- type_info_t *t; /* current type information */
- hash_state_t state; /* whether to hash type or not */
- thash_t **hash_tbl; /* pointer to hash table to use */
+add_aux_sym_tir (type_info_t *t, /* current type information */
+ hash_state_t state, /* whether to hash type or not */
+ thash_t **hash_tbl /* pointer to hash table to use */)
{
register varray_t *vp;
register aux_t *aux_ptr;
aux.ti.tq4 = (int) t->type_qualifiers[4];
aux.ti.tq5 = (int) t->type_qualifiers[5];
-
/* For anything that adds additional information, we must not hash,
- so check here, and reset our state. */
+ so check here, and reset our state. */
if (state != hash_no
&& (t->type_qualifiers[0] == tq_Array
}
}
- /* Everything is set up, add the aux symbol. */
+ /* Everything is set up, add the aux symbol. */
if (vp->objects_last_page == vp->objects_per_page)
add_varray_page (vp);
- aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
+ aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
aux_ptr->type = aux_tir;
aux_ptr->data = aux;
for an enum bitfield. */
if (t->bitfield)
- (void) add_aux_sym_symint ((symint_t)t->sizes[t->num_sizes-1]);
-
+ (void) add_aux_sym_symint ((symint_t) t->sizes[t->num_sizes - 1]);
/* Add tag information if needed. Structure, union, and enum
references add 2 aux symbols: a [file index, symbol index]
|| t->basic_type == bt_Enum)
{
register symint_t file_index = t->tag_ptr->ifd;
- register localsym_t *sym = t->tag_ptr->sym;
+ register localsym_t *sym = t->tag_ptr->sym;
register forward_t *forward_ref = allocate_forward ();
if (sym != (localsym_t *) NULL)
(void) add_aux_sym_rndx (ST_RFDESCAPE, indexNil);
forward_ref->index_ptr
- = &vp->last->datum->aux[ vp->objects_last_page - 1];
+ = &vp->last->datum->aux[vp->objects_last_page - 1];
(void) add_aux_sym_symint (file_index);
forward_ref->ifd_ptr
- = &vp->last->datum->aux[ vp->objects_last_page - 1];
+ = &vp->last->datum->aux[vp->objects_last_page - 1];
}
/* Add information about array bounds if they exist. */
};
/* NOTE: Mips documentation claims that the bitfield width goes here.
- But it needs to be emitted earlier. */
+ But it needs to be emitted earlier. */
return ret;
}
/* Add a tag to the tag table (unless it already exists). */
static tag_t *
-get_tag (tag, sym, basic_type)
- const char *tag; /* tag name */
- localsym_t *sym; /* tag start block */
- bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */
+get_tag (const char *tag, /* tag name */
+ localsym_t *sym, /* tag start block */
+ bt_t basic_type /* bt_Struct, bt_Union, or bt_Enum */)
{
shash_t *hash_ptr;
const char *err;
if (hash_ptr != (shash_t *) NULL
&& hash_ptr->tag_ptr != (tag_t *) NULL)
- {
- tag_ptr = hash_ptr->tag_ptr;
- if (sym != (localsym_t *) NULL)
- {
- tag_ptr->basic_type = basic_type;
- tag_ptr->ifd = cur_file_ptr->file_index;
- tag_ptr->sym = sym;
- }
- return tag_ptr;
- }
+ {
+ tag_ptr = hash_ptr->tag_ptr;
+ if (sym != (localsym_t *) NULL)
+ {
+ tag_ptr->basic_type = basic_type;
+ tag_ptr->ifd = cur_file_ptr->file_index;
+ tag_ptr->sym = sym;
+ }
+ return tag_ptr;
+ }
if (hash_ptr == (shash_t *) NULL)
{
char *perm;
- perm = xmalloc ((unsigned long) (strlen (tag) + 1));
- strcpy (perm, tag);
+ perm = xstrdup (tag);
hash_ptr = allocate_shash ();
err = hash_insert (tag_hash, perm, (char *) hash_ptr);
if (err)
- as_fatal (_("Inserting \"%s\" into tag hash table: %s"),
+ as_fatal (_("inserting \"%s\" into tag hash table: %s"),
tag, err);
hash_ptr->string = perm;
}
/* Add an unknown {struct, union, enum} tag. */
static void
-add_unknown_tag (ptag)
- tag_t *ptag; /* pointer to tag information */
+add_unknown_tag (tag_t *ptag /* pointer to tag information */)
{
shash_t *hash_ptr = ptag->hash_ptr;
char *name = hash_ptr->string;
#ifdef ECOFF_DEBUG
if (debug > 1)
{
- char *agg_type = "{unknown aggregate type}";
+ char *agg_type = "{unknown aggregate type}";
switch (ptag->basic_type)
{
case bt_Struct: agg_type = "struct"; break;
this is the current procedure. */
static void
-add_procedure (func)
- char *func; /* func name */
+add_procedure (char *func /* func name */)
{
register varray_t *vp;
register proc_t *new_proc_ptr;
}
symbolS *
-ecoff_get_cur_proc_sym ()
+ecoff_get_cur_proc_sym (void)
{
return (cur_proc_ptr ? cur_proc_ptr->sym->as_sym : NULL);
}
where the current file structure lives. */
static void
-add_file (file_name, indx, fake)
- const char *file_name; /* file name */
- int indx;
- int fake;
+add_file (const char *file_name, int indx ATTRIBUTE_UNUSED, int fake)
{
register int first_ch;
register efdr_t *fil_ptr;
this if we see a .file directive with a string, since that
implies that some sort of debugging information is being
provided. */
- if (! symbol_table_frozen && debug_type == DEBUG_NONE)
+ if (! symbol_table_frozen && debug_type == DEBUG_UNSPECIFIED)
debug_type = DEBUG_ECOFF;
}
+ else if (debug_type == DEBUG_UNSPECIFIED)
+ debug_type = DEBUG_NONE;
#ifndef NO_LISTING
if (listing)
}
}
- /* If this is a new file, create it. */
+ /* If this is a new file, create it. */
if (fil_ptr == (efdr_t *) NULL)
{
if (file_desc.objects_last_page == file_desc.objects_per_page)
(shash_t **)0);
if (strlen (file_name) > PAGE_USIZE - 2)
- as_fatal (_("Filename goes over one page boundary."));
+ as_fatal (_("filename goes over one page boundary"));
/* Push the start of the filename. We assume that the filename
will be stored at string offset 1. */
last_file_ptr = &fil_ptr->next_file;
/* Add void & int types to the file (void should be first to catch
- errant 0's within the index fields). */
+ errant 0's within the index fields). */
fil_ptr->void_type = add_aux_sym_tir (&void_type_info,
hash_yes,
&cur_file_ptr->thash_head[0]);
compiler output, only in hand coded assembler. */
void
-ecoff_new_file (name)
- const char *name;
+ecoff_new_file (const char *name)
{
if (cur_file_ptr != NULL && strcmp (cur_file_ptr->name, name) == 0)
return;
/* This is a hand coded assembler file, so automatically turn on
debugging information. */
- if (debug_type == DEBUG_NONE)
+ if (debug_type == DEBUG_UNSPECIFIED)
debug_type = DEBUG_ECOFF;
}
\f
/* Convert storage class to string. */
static char *
-sc_to_string(storage_class)
+sc_to_string (storage_class)
sc_t storage_class;
{
- switch(storage_class)
+ switch (storage_class)
{
case sc_Nil: return "Nil,";
case sc_Text: return "Text,";
/* Convert symbol type to string. */
static char *
-st_to_string(symbol_type)
+st_to_string (symbol_type)
st_t symbol_type;
{
- switch(symbol_type)
+ switch (symbol_type)
{
case st_Nil: return "Nil,";
case st_Global: return "Global,";
which gives the location of the start of the block. */
void
-ecoff_directive_begin (ignore)
- int ignore;
+ecoff_directive_begin (int ignore ATTRIBUTE_UNUSED)
{
char *name;
char name_end;
which gives the location of the end of the block. */
void
-ecoff_directive_bend (ignore)
- int ignore;
+ecoff_directive_bend (int ignore ATTRIBUTE_UNUSED)
{
char *name;
char name_end;
/* Handle a .def directive: start defining a symbol. */
void
-ecoff_directive_def (ignore)
- int ignore;
+ecoff_directive_def (int ignore ATTRIBUTE_UNUSED)
{
char *name;
char name_end;
if (coff_sym_name != (char *) NULL)
as_warn (_(".def pseudo-op used inside of .def/.endef; ignored"));
else if (*name == '\0')
- as_warn (_("Empty symbol name in .def; ignored"));
+ as_warn (_("empty symbol name in .def; ignored"));
else
{
if (coff_sym_name != (char *) NULL)
free (coff_sym_name);
if (coff_tag != (char *) NULL)
free (coff_tag);
- coff_sym_name = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
- strcpy (coff_sym_name, name);
+
+ coff_sym_name = xstrdup (name);
coff_type = type_info_init;
coff_storage_class = sc_Nil;
coff_symbol_typ = st_Nil;
more than that anyhow, so I will also make that assumption. */
void
-ecoff_directive_dim (ignore)
- int ignore;
+ecoff_directive_dim (int ignore ATTRIBUTE_UNUSED)
{
int dimens[N_TQ];
int i;
{
if (*input_line_pointer != '\n'
&& *input_line_pointer != ';')
- as_warn (_("Badly formed .dim directive"));
+ as_warn (_("badly formed .dim directive"));
break;
}
}
{
if (coff_type.num_dims >= N_TQ)
{
- as_warn (_("Too many .dim entries"));
+ as_warn (_("too many .dim entries"));
break;
}
coff_type.dimensions[coff_type.num_dims] = dimens[i];
symbol. */
void
-ecoff_directive_scl (ignore)
- int ignore;
+ecoff_directive_scl (int ignore ATTRIBUTE_UNUSED)
{
long val;
never generate more than one argument. */
void
-ecoff_directive_size (ignore)
- int ignore;
+ecoff_directive_size (int ignore ATTRIBUTE_UNUSED)
{
int sizes[N_TQ];
int i;
{
if (*input_line_pointer != '\n'
&& *input_line_pointer != ';')
- as_warn (_("Badly formed .size directive"));
+ as_warn (_("badly formed .size directive"));
break;
}
}
{
if (coff_type.num_sizes >= N_TQ)
{
- as_warn (_("Too many .size entries"));
+ as_warn (_("too many .size entries"));
break;
}
coff_type.sizes[coff_type.num_sizes] = sizes[i];
symbol. */
void
-ecoff_directive_type (ignore)
- int ignore;
+ecoff_directive_type (int ignore ATTRIBUTE_UNUSED)
{
long val;
tq_t *tq_ptr;
coff_type.basic_type = map_coff_types[coff_type.orig_type];
tq_ptr = &coff_type.type_qualifiers[N_TQ];
- while (val &~ N_BTMASK)
+ while (val & ~N_BTMASK)
{
if (tq_ptr == &coff_type.type_qualifiers[0])
{
/* FIXME: We could handle this by setting the continued bit.
- There would still be a limit: the .type argument can not
- be infinite. */
- as_warn (_("The type of %s is too complex; it will be simplified"),
+ There would still be a limit: the .type argument can not
+ be infinite. */
+ as_warn (_("the type of %s is too complex; it will be simplified"),
coff_sym_name);
break;
}
if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc)
{
/* If this is a function, ignore it, so that we don't get two
- entries (one from the .ent, and one for the .def that
- precedes it). Save the type information so that the end
- block can properly add it after the begin block index. For
- MIPS knows what reason, we must strip off the function type
- at this point. */
+ entries (one from the .ent, and one for the .def that
+ precedes it). Save the type information so that the end
+ block can properly add it after the begin block index. For
+ MIPS knows what reason, we must strip off the function type
+ at this point. */
coff_is_function = 1;
tq_shft[-1] = tq_Nil;
}
union or enum. */
void
-ecoff_directive_tag (ignore)
- int ignore;
+ecoff_directive_tag (int ignore ATTRIBUTE_UNUSED)
{
char *name;
char name_end;
name = input_line_pointer;
name_end = get_symbol_end ();
- coff_tag = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
- strcpy (coff_tag, name);
+ coff_tag = xstrdup (name);
*input_line_pointer = name_end;
may be the name of a static or global symbol. */
void
-ecoff_directive_val (ignore)
- int ignore;
+ecoff_directive_val (int ignore ATTRIBUTE_UNUSED)
{
expressionS exp;
debugging information for a symbol. */
void
-ecoff_directive_endef (ignore)
- int ignore;
+ecoff_directive_endef (int ignore ATTRIBUTE_UNUSED)
{
char *name;
symint_t indx;
if (coff_type.num_sizes != 1 || diff < 0)
{
- as_warn (_("Bad COFF debugging info"));
+ as_warn (_("bad COFF debugging information"));
return;
}
/* If this is an array, make sure the same number of dimensions
- and sizes were passed, creating extra sizes for multiply
- dimensioned arrays if not passed. */
+ and sizes were passed, creating extra sizes for multiply
+ dimensioned arrays if not passed. */
coff_type.extra_sizes = 0;
if (diff)
{
&& coff_type.num_sizes - coff_type.extra_sizes == 1)
{
/* Is this a bitfield? This is indicated by a structure memeber
- having a size field that isn't an array. */
+ having a size field that isn't an array. */
coff_type.bitfield = 1;
}
{
if (coff_tag == (char *) NULL)
{
- as_warn (_("No tag specified for %s"), name);
+ as_warn (_("no tag specified for %s"), name);
return;
}
break;
/* For the beginning of structs, unions, and enumerations, the
- size info needs to be passed in the value field. */
+ size info needs to be passed in the value field. */
case st_Block:
if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes
!= 1)
{
- as_warn (_("Bad COFF debugging information"));
+ as_warn (_("bad COFF debugging information"));
return;
}
else
break;
/* For the end of structs, unions, and enumerations, omit the
- name which is always ".eos". This needs to be done last, so
- that any error reporting above gives the correct name. */
+ name which is always ".eos". This needs to be done last, so
+ that any error reporting above gives the correct name. */
case st_End:
free (name);
name = (char *) NULL;
break;
/* Members of structures and unions that aren't bitfields, need
- to adjust the value from a byte offset to a bit offset.
- Members of enumerations do not have the value adjusted, and
- can be distinguished by indx == indexNil. For enumerations,
- update the maximum enumeration value. */
+ to adjust the value from a byte offset to a bit offset.
+ Members of enumerations do not have the value adjusted, and
+ can be distinguished by indx == indexNil. For enumerations,
+ update the maximum enumeration value. */
case st_Member:
if (! coff_type.bitfield && ! coff_inside_enumeration)
coff_value *= 8;
/* Parse .end directives. */
void
-ecoff_directive_end (ignore)
- int ignore;
+ecoff_directive_end (int ignore ATTRIBUTE_UNUSED)
{
char *name;
char name_end;
- register int ch;
symbolS *ent;
if (cur_file_ptr == (efdr_t *) NULL)
name = input_line_pointer;
name_end = get_symbol_end ();
- ch = *name;
- if (! is_name_beginner (ch))
+ if (name == input_line_pointer)
{
as_warn (_(".end directive has no name"));
*input_line_pointer = name_end;
/* Parse .ent directives. */
void
-ecoff_directive_ent (ignore)
- int ignore;
+ecoff_directive_ent (int ignore ATTRIBUTE_UNUSED)
{
char *name;
char name_end;
- register int ch;
if (cur_file_ptr == (efdr_t *) NULL)
add_file ((const char *) NULL, 0, 1);
name = input_line_pointer;
name_end = get_symbol_end ();
- ch = *name;
- if (! is_name_beginner (ch))
+ if (name == input_line_pointer)
{
as_warn (_(".ent directive has no name"));
*input_line_pointer = name_end;
++input_line_pointer;
SKIP_WHITESPACE ();
}
- if (isdigit ((unsigned char) *input_line_pointer)
+ if (ISDIGIT (*input_line_pointer)
|| *input_line_pointer == '-')
(void) get_absolute_expression ();
/* Parse .extern directives. */
void
-ecoff_directive_extern (ignore)
- int ignore;
+ecoff_directive_extern (int ignore ATTRIBUTE_UNUSED)
{
char *name;
int c;
/* Parse .file directives. */
void
-ecoff_directive_file (ignore)
- int ignore;
+ecoff_directive_file (int ignore ATTRIBUTE_UNUSED)
{
int indx;
char *name;
if (cur_proc_ptr != (proc_t *) NULL)
{
- as_warn (_("No way to handle .file within .ent/.end section"));
+ as_warn (_("no way to handle .file within .ent/.end section"));
demand_empty_rest_of_line ();
return;
}
/* Parse .fmask directives. */
void
-ecoff_directive_fmask (ignore)
- int ignore;
+ecoff_directive_fmask (int ignore ATTRIBUTE_UNUSED)
{
long val;
if (get_absolute_expression_and_terminator (&val) != ',')
{
- as_warn (_("Bad .fmask directive"));
+ as_warn (_("bad .fmask directive"));
--input_line_pointer;
demand_empty_rest_of_line ();
return;
/* Parse .frame directives. */
void
-ecoff_directive_frame (ignore)
- int ignore;
+ecoff_directive_frame (int ignore ATTRIBUTE_UNUSED)
{
long val;
if (*input_line_pointer++ != ','
|| get_absolute_expression_and_terminator (&val) != ',')
{
- as_warn (_("Bad .frame directive"));
+ as_warn (_("bad .frame directive"));
--input_line_pointer;
demand_empty_rest_of_line ();
return;
cur_proc_ptr->pdr.pcreg = tc_get_register (0);
-#if 0 /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according
- to Sandro. I don't yet know where this value should be stored, if
- anywhere. */
+#if 0
+ /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to
+ Sandro. I don't yet know where this value should be stored, if
+ anywhere. */
demand_empty_rest_of_line ();
#else
s_ignore (42);
/* Parse .mask directives. */
void
-ecoff_directive_mask (ignore)
- int ignore;
+ecoff_directive_mask (int ignore ATTRIBUTE_UNUSED)
{
long val;
if (get_absolute_expression_and_terminator (&val) != ',')
{
- as_warn (_("Bad .mask directive"));
+ as_warn (_("bad .mask directive"));
--input_line_pointer;
demand_empty_rest_of_line ();
return;
/* Parse .loc directives. */
void
-ecoff_directive_loc (ignore)
- int ignore;
+ecoff_directive_loc (int ignore ATTRIBUTE_UNUSED)
{
lineno_list_t *list;
symint_t lineno;
information so that it points to the instruction after the nop. */
void
-ecoff_fix_loc (old_frag, old_frag_offset)
- fragS *old_frag;
- unsigned long old_frag_offset;
+ecoff_fix_loc (fragS *old_frag, unsigned long old_frag_offset)
{
if (last_lineno != NULL
&& last_lineno->frag == old_frag
/* Make sure the @stabs symbol is emitted. */
static void
-mark_stabs (ignore)
- int ignore;
+mark_stabs (int ignore ATTRIBUTE_UNUSED)
{
if (! stabs_seen)
{
- /* Add a dummy @stabs dymbol. */
+ /* Add a dummy @stabs dymbol. */
stabs_seen = 1;
(void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
(symbolS *) NULL,
\f
/* Parse .weakext directives. */
#ifndef TC_MIPS
-/* For TC_MIPS use the version in tc-mips.c. */
+/* For TC_MIPS use the version in tc-mips.c. */
void
-ecoff_directive_weakext (ignore)
- int ignore;
+ecoff_directive_weakext (int ignore ATTRIBUTE_UNUSED)
{
char *name;
int c;
{
if (S_IS_DEFINED (symbolP))
{
- as_bad (_("Ignoring attempt to redefine symbol `%s'."),
+ as_bad (_("symbol `%s' is already defined"),
S_GET_NAME (symbolP));
ignore_rest_of_line ();
return;
if (exp.X_op != O_symbol)
{
as_bad (_("bad .weakext directive"));
- ignore_rest_of_line();
+ ignore_rest_of_line ();
return;
}
symbol_set_value_expression (symbolP, &exp);
value a numeric value or an address. */
void
-ecoff_stab (sec, what, string, type, other, desc)
- segT sec;
- int what;
- const char *string;
- int type;
- int other;
- int desc;
+ecoff_stab (segT sec ATTRIBUTE_UNUSED,
+ int what,
+ const char *string,
+ int type,
+ int other,
+ int desc)
{
efdr_t *save_file_ptr = cur_file_ptr;
symbolS *sym;
dummy_symr.index = desc;
if (dummy_symr.index != desc)
{
- as_warn (_("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)"),
+ as_warn (_("line number (%d) for .stab%c directive cannot fit in index field (20 bits)"),
desc, what);
return;
}
listing_source_file (string);
#endif
- if (isdigit ((unsigned char) *input_line_pointer)
+ if (ISDIGIT (*input_line_pointer)
|| *input_line_pointer == '-'
|| *input_line_pointer == '+')
{
}
else if (! is_name_beginner ((unsigned char) *input_line_pointer))
{
- as_warn (_("Illegal .stab%c directive, bad character"), what);
+ as_warn (_("illegal .stab%c directive, bad character"), what);
return;
}
else
.scommon section rather than bfd_com_section. */
void
-ecoff_frob_symbol (sym)
- symbolS *sym;
+ecoff_frob_symbol (symbolS *sym)
{
if (S_IS_COMMON (sym)
&& S_GET_VALUE (sym) > 0
static asymbol scom_symbol;
/* We must construct a fake section similar to bfd_com_section
- but with the name .scommon. */
+ but with the name .scommon. */
if (scom_section.name == NULL)
{
scom_section = bfd_com_section;
if (S_IS_WEAK (sym))
{
if (S_IS_COMMON (sym))
- as_bad (_("Symbol `%s' can not be both weak and common"),
+ as_bad (_("symbol `%s' can not be both weak and common"),
S_GET_NAME (sym));
}
}
/* Add bytes to the symbolic information buffer. */
static char *
-ecoff_add_bytes (buf, bufend, bufptr, need)
- char **buf;
- char **bufend;
- char *bufptr;
- unsigned long need;
+ecoff_add_bytes (char **buf,
+ char **bufend,
+ char *bufptr,
+ unsigned long need)
{
unsigned long at;
unsigned long want;
for the ECOFF target debugging information. */
static unsigned long
-ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr)
- const struct ecoff_debug_swap *backend;
- char **buf;
- char **bufend;
- unsigned long offset;
- char **bufptrptr;
+ecoff_padding_adjust (const struct ecoff_debug_swap *backend,
+ char **buf,
+ char **bufend,
+ unsigned long offset,
+ char **bufptrptr)
{
bfd_size_type align;
unsigned long add;
add = align - (offset & (align - 1));
- if (*bufend - (*buf + offset) < add)
+ if ((unsigned long) (*bufend - (*buf + offset)) < add)
(void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
memset (*buf + offset, 0, add);
offset += add;
/* Build the line number information. */
static unsigned long
-ecoff_build_lineno (backend, buf, bufend, offset, linecntptr)
- const struct ecoff_debug_swap *backend;
- char **buf;
- char **bufend;
- unsigned long offset;
- long *linecntptr;
+ecoff_build_lineno (const struct ecoff_debug_swap *backend,
+ char **buf,
+ char **bufend,
+ unsigned long offset,
+ long *linecntptr)
{
char *bufptr;
register lineno_list_t *l;
embedded PIC code, it will put strings in the .text section
before the first procedure. We cope by inserting a dummy line if
the address of the first procedure is not 0. Hopefully this
- won't screw things up too badly.
+ won't screw things up too badly.
Don't do this for ECOFF assembly source line numbers. They work
without this extra attention. */
long delta;
/* Get the offset to the memory address of the next line number
- (in words). Do this first, so that we can skip ahead to the
- next useful line number entry. */
+ (in words). Do this first, so that we can skip ahead to the
+ next useful line number entry. */
if (l->next == (lineno_list_t *) NULL)
{
/* We want a count of zero, but it will be decremented
/* Build and swap out the symbols. */
static unsigned long
-ecoff_build_symbols (backend, buf, bufend, offset)
- const struct ecoff_debug_swap *backend;
- char **buf;
- char **bufend;
- unsigned long offset;
+ecoff_build_symbols (const struct ecoff_debug_swap *backend,
+ char **buf,
+ char **bufend,
+ unsigned long offset)
{
const bfd_size_type external_sym_size = backend->external_sym_size;
- void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
+ void (* const swap_sym_out) (bfd *, const SYMR *, PTR)
= backend->swap_sym_out;
char *sym_out;
long isym;
symint_t indx;
/* The value of a block start symbol is the
- offset from the start of the procedure. For
- other symbols we just use the gas value (but
- we must offset it by the vma of the section,
- just as BFD does, because BFD will not see
- this value). */
+ offset from the start of the procedure. For
+ other symbols we just use the gas value (but
+ we must offset it by the vma of the section,
+ just as BFD does, because BFD will not see
+ this value). */
if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
&& sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
{
sym_ptr->ecoff_sym.asym.st = st_StaticProc;
/* Get the type and storage class based on where
- the symbol actually wound up. Traditionally,
- N_LBRAC and N_RBRAC are *not* relocated. */
+ the symbol actually wound up. Traditionally,
+ N_LBRAC and N_RBRAC are *not* relocated. */
indx = sym_ptr->ecoff_sym.asym.index;
if (sym_ptr->ecoff_sym.asym.st == st_Nil
&& sym_ptr->ecoff_sym.asym.sc == sc_Nil
else
{
/* This must be a user named section.
- This is not possible in ECOFF, but it
- is in ELF. */
+ This is not possible in ECOFF, but it
+ is in ELF. */
sc = sc_Data;
}
}
/* This is just an external symbol if it is
- outside a procedure and it has a type.
- FIXME: g++ will generate symbols which have
- different names in the debugging information
- than the actual symbol. Should we handle
- them here? */
+ outside a procedure and it has a type.
+ FIXME: g++ will generate symbols which have
+ different names in the debugging information
+ than the actual symbol. Should we handle
+ them here? */
if ((S_IS_EXTERNAL (as_sym)
|| S_IS_WEAK (as_sym)
|| ! S_IS_DEFINED (as_sym))
local = 0;
/* This is just an external symbol if it is a
- common symbol. */
+ common symbol. */
if (S_IS_COMMON (as_sym))
local = 0;
/* If an st_end symbol has an associated gas
- symbol, then it is a local label created for
- a .bend or .end directive. Stabs line
- numbers will have \001 in the names. */
+ symbol, then it is a local label created for
+ a .bend or .end directive. Stabs line
+ numbers will have \001 in the names. */
if (local
&& sym_ptr->ecoff_sym.asym.st != st_End
&& strchr (sym_ptr->name, '\001') == 0)
}
/* The value of the symbol marking the end of a
- procedure is the size of the procedure. The
- value of the symbol marking the end of a
- block is the offset from the start of the
- procedure to the block. */
+ procedure is the size of the procedure. The
+ value of the symbol marking the end of a
+ block is the offset from the start of the
+ procedure to the block. */
if (begin_type == st_Proc
|| begin_type == st_StaticProc)
{
- S_GET_VALUE (begin_ptr->as_sym));
/* If the size is odd, this is probably a
- mips16 function; force it to be even. */
+ mips16 function; force it to be even. */
if ((sym_ptr->ecoff_sym.asym.value & 1) != 0)
++sym_ptr->ecoff_sym.asym.value;
if (local)
{
- if (*bufend - sym_out < external_sym_size)
+ if ((bfd_size_type)(*bufend - sym_out) < external_sym_size)
sym_out = ecoff_add_bytes (buf, bufend,
sym_out,
external_sym_size);
sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
/* Don't try to merge an FDR which has an
- external symbol attached to it. */
+ external symbol attached to it. */
if (S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym))
fil_ptr->fdr.fMerge = 0;
}
/* Swap out the procedure information. */
static unsigned long
-ecoff_build_procs (backend, buf, bufend, offset)
- const struct ecoff_debug_swap *backend;
- char **buf;
- char **bufend;
- unsigned long offset;
+ecoff_build_procs (const struct ecoff_debug_swap *backend,
+ char **buf,
+ char **bufend,
+ unsigned long offset)
{
const bfd_size_type external_pdr_size = backend->external_pdr_size;
- void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR))
+ void (* const swap_pdr_out) (bfd *, const PDR *, PTR)
= backend->swap_pdr_out;
char *pdr_out;
long iproc;
if (first)
{
/* This code used to force the adr of the very
- first fdr to be 0. However, the native tools
- don't do that, and I can't remember why it
- used to work that way, so I took it out. */
+ first fdr to be 0. However, the native tools
+ don't do that, and I can't remember why it
+ used to work that way, so I took it out. */
fil_ptr->fdr.adr = adr;
first = 0;
}
proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
- if (*bufend - pdr_out < external_pdr_size)
+ if ((bfd_size_type)(*bufend - pdr_out) < external_pdr_size)
pdr_out = ecoff_add_bytes (buf, bufend,
pdr_out,
external_pdr_size);
/* Swap out the aux information. */
static unsigned long
-ecoff_build_aux (backend, buf, bufend, offset)
- const struct ecoff_debug_swap *backend;
- char **buf;
- char **bufend;
- unsigned long offset;
+ecoff_build_aux (const struct ecoff_debug_swap *backend,
+ char **buf,
+ char **bufend,
+ unsigned long offset)
{
int bigendian;
union aux_ext *aux_out;
aux_end = aux_ptr + aux_cnt;
for (; aux_ptr < aux_end; aux_ptr++)
{
- if (*bufend - (char *) aux_out < sizeof (union aux_ext))
+ if ((unsigned long) (*bufend - (char *) aux_out)
+ < sizeof (union aux_ext))
aux_out = ((union aux_ext *)
ecoff_add_bytes (buf, bufend,
(char *) aux_out,
bytes copied, rather than the new offset. */
static unsigned long
-ecoff_build_strings (buf, bufend, offset, vp)
- char **buf;
- char **bufend;
- unsigned long offset;
- varray_t *vp;
+ecoff_build_strings (char **buf,
+ char **bufend,
+ unsigned long offset,
+ varray_t *vp)
{
unsigned long istr;
char *str_out;
else
str_cnt = vp->objects_per_page;
- if (*bufend - str_out < str_cnt)
+ if ((unsigned long)(*bufend - str_out) < str_cnt)
str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
memcpy (str_out, str_link->datum->byte, str_cnt);
/* Dump out the local strings. */
static unsigned long
-ecoff_build_ss (backend, buf, bufend, offset)
- const struct ecoff_debug_swap *backend;
- char **buf;
- char **bufend;
- unsigned long offset;
+ecoff_build_ss (const struct ecoff_debug_swap *backend,
+ char **buf,
+ char **bufend,
+ unsigned long offset)
{
long iss;
vlinks_t *file_link;
/* Swap out the file descriptors. */
static unsigned long
-ecoff_build_fdr (backend, buf, bufend, offset)
- const struct ecoff_debug_swap *backend;
- char **buf;
- char **bufend;
- unsigned long offset;
+ecoff_build_fdr (const struct ecoff_debug_swap *backend,
+ char **buf,
+ char **bufend,
+ unsigned long offset)
{
const bfd_size_type external_fdr_size = backend->external_fdr_size;
- void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
+ void (* const swap_fdr_out) (bfd *, const FDR *, PTR)
= backend->swap_fdr_out;
long ifile;
char *fdr_out;
fil_end = fil_ptr + fil_cnt;
for (; fil_ptr < fil_end; fil_ptr++)
{
- if (*bufend - fdr_out < external_fdr_size)
+ if ((bfd_size_type)(*bufend - fdr_out) < external_fdr_size)
fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
external_fdr_size);
(*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
calls a backend function to deal with it. */
static void
-ecoff_setup_ext ()
+ecoff_setup_ext (void)
{
register symbolS *sym;
/* Build the ECOFF debugging information. */
unsigned long
-ecoff_build_debug (hdr, bufp, backend)
- HDRR *hdr;
- char **bufp;
- const struct ecoff_debug_swap *backend;
+ecoff_build_debug (HDRR *hdr,
+ char **bufp,
+ const struct ecoff_debug_swap *backend)
{
const bfd_size_type external_pdr_size = backend->external_pdr_size;
tag_t *ptag;
efdr_t *fil_ptr;
int end_warning;
efdr_t *hold_file_ptr;
- proc_t * hold_proc_ptr;
+ proc_t *hold_proc_ptr;
symbolS *sym;
char *buf;
char *bufend;
cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
if (! end_warning && ! cur_file_ptr->fake)
{
- as_warn (_("Missing .end or .bend at end of file"));
+ as_warn (_("missing .end or .bend at end of file"));
end_warning = 1;
}
}
space at this point. */
hdr->ipdMax = proc_cnt;
hdr->cbPdOffset = offset;
- if (bufend - (buf + offset) < proc_cnt * external_pdr_size)
+ if ((bfd_size_type)(bufend - (buf + offset)) < proc_cnt * external_pdr_size)
(void) ecoff_add_bytes (&buf, &bufend, buf + offset,
proc_cnt * external_pdr_size);
offset += proc_cnt * external_pdr_size;
#ifndef MALLOC_CHECK
static page_type *
-allocate_cluster (npages)
- unsigned long npages;
+allocate_cluster (unsigned long npages)
{
register page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE);
return value;
}
-
static page_type *cluster_ptr = NULL;
static unsigned long pages_left = 0;
/* Allocate one page (which is initialized to 0). */
static page_type *
-allocate_page ()
+allocate_page (void)
{
#ifndef MALLOC_CHECK
pages_left--;
return cluster_ptr++;
-#else /* MALLOC_CHECK */
+#else /* MALLOC_CHECK */
page_type *ptr;
memset (ptr, 0, PAGE_USIZE);
return ptr;
-#endif /* MALLOC_CHECK */
+#endif /* MALLOC_CHECK */
}
\f
/* Allocate scoping information. */
static scope_t *
-allocate_scope ()
+allocate_scope (void)
{
register scope_t *ptr;
static scope_t initial_scope;
#ifndef MALLOC_CHECK
- ptr = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
+ ptr = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
if (ptr != (scope_t *) NULL)
- alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr->free;
+ alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr->free;
else
{
- register int unallocated = alloc_counts[(int)alloc_type_scope].unallocated;
- register page_type *cur_page = alloc_counts[(int)alloc_type_scope].cur_page;
+ register int unallocated = alloc_counts[(int) alloc_type_scope].unallocated;
+ register page_type *cur_page = alloc_counts[(int) alloc_type_scope].cur_page;
if (unallocated == 0)
{
unallocated = PAGE_SIZE / sizeof (scope_t);
- alloc_counts[(int)alloc_type_scope].cur_page = cur_page = allocate_page ();
- alloc_counts[(int)alloc_type_scope].total_pages++;
+ alloc_counts[(int) alloc_type_scope].cur_page = cur_page = allocate_page ();
+ alloc_counts[(int) alloc_type_scope].total_pages++;
}
ptr = &cur_page->scope[--unallocated];
- alloc_counts[(int)alloc_type_scope].unallocated = unallocated;
+ alloc_counts[(int) alloc_type_scope].unallocated = unallocated;
}
#else
#endif
- alloc_counts[(int)alloc_type_scope].total_alloc++;
+ alloc_counts[(int) alloc_type_scope].total_alloc++;
*ptr = initial_scope;
return ptr;
}
/* Free scoping information. */
static void
-free_scope (ptr)
- scope_t *ptr;
+free_scope (scope_t *ptr)
{
- alloc_counts[(int)alloc_type_scope].total_free++;
+ alloc_counts[(int) alloc_type_scope].total_free++;
#ifndef MALLOC_CHECK
- ptr->free = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
- alloc_counts[(int)alloc_type_scope].free_list.f_scope = ptr;
+ ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
+ alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr;
#else
free ((PTR) ptr);
#endif
/* Allocate links for pages in a virtual array. */
static vlinks_t *
-allocate_vlinks ()
+allocate_vlinks (void)
{
register vlinks_t *ptr;
static vlinks_t initial_vlinks;
#ifndef MALLOC_CHECK
- register int unallocated = alloc_counts[(int)alloc_type_vlinks].unallocated;
- register page_type *cur_page = alloc_counts[(int)alloc_type_vlinks].cur_page;
+ register int unallocated = alloc_counts[(int) alloc_type_vlinks].unallocated;
+ register page_type *cur_page = alloc_counts[(int) alloc_type_vlinks].cur_page;
if (unallocated == 0)
{
unallocated = PAGE_SIZE / sizeof (vlinks_t);
- alloc_counts[(int)alloc_type_vlinks].cur_page = cur_page = allocate_page ();
- alloc_counts[(int)alloc_type_vlinks].total_pages++;
+ alloc_counts[(int) alloc_type_vlinks].cur_page = cur_page = allocate_page ();
+ alloc_counts[(int) alloc_type_vlinks].total_pages++;
}
ptr = &cur_page->vlinks[--unallocated];
- alloc_counts[(int)alloc_type_vlinks].unallocated = unallocated;
+ alloc_counts[(int) alloc_type_vlinks].unallocated = unallocated;
#else
#endif
- alloc_counts[(int)alloc_type_vlinks].total_alloc++;
+ alloc_counts[(int) alloc_type_vlinks].total_alloc++;
*ptr = initial_vlinks;
return ptr;
}
/* Allocate string hash buckets. */
static shash_t *
-allocate_shash ()
+allocate_shash (void)
{
register shash_t *ptr;
static shash_t initial_shash;
#ifndef MALLOC_CHECK
- register int unallocated = alloc_counts[(int)alloc_type_shash].unallocated;
- register page_type *cur_page = alloc_counts[(int)alloc_type_shash].cur_page;
+ register int unallocated = alloc_counts[(int) alloc_type_shash].unallocated;
+ register page_type *cur_page = alloc_counts[(int) alloc_type_shash].cur_page;
if (unallocated == 0)
{
unallocated = PAGE_SIZE / sizeof (shash_t);
- alloc_counts[(int)alloc_type_shash].cur_page = cur_page = allocate_page ();
- alloc_counts[(int)alloc_type_shash].total_pages++;
+ alloc_counts[(int) alloc_type_shash].cur_page = cur_page = allocate_page ();
+ alloc_counts[(int) alloc_type_shash].total_pages++;
}
ptr = &cur_page->shash[--unallocated];
- alloc_counts[(int)alloc_type_shash].unallocated = unallocated;
+ alloc_counts[(int) alloc_type_shash].unallocated = unallocated;
#else
#endif
- alloc_counts[(int)alloc_type_shash].total_alloc++;
+ alloc_counts[(int) alloc_type_shash].total_alloc++;
*ptr = initial_shash;
return ptr;
}
/* Allocate type hash buckets. */
static thash_t *
-allocate_thash ()
+allocate_thash (void)
{
register thash_t *ptr;
static thash_t initial_thash;
#ifndef MALLOC_CHECK
- register int unallocated = alloc_counts[(int)alloc_type_thash].unallocated;
- register page_type *cur_page = alloc_counts[(int)alloc_type_thash].cur_page;
+ register int unallocated = alloc_counts[(int) alloc_type_thash].unallocated;
+ register page_type *cur_page = alloc_counts[(int) alloc_type_thash].cur_page;
if (unallocated == 0)
{
unallocated = PAGE_SIZE / sizeof (thash_t);
- alloc_counts[(int)alloc_type_thash].cur_page = cur_page = allocate_page ();
- alloc_counts[(int)alloc_type_thash].total_pages++;
+ alloc_counts[(int) alloc_type_thash].cur_page = cur_page = allocate_page ();
+ alloc_counts[(int) alloc_type_thash].total_pages++;
}
ptr = &cur_page->thash[--unallocated];
- alloc_counts[(int)alloc_type_thash].unallocated = unallocated;
+ alloc_counts[(int) alloc_type_thash].unallocated = unallocated;
#else
#endif
- alloc_counts[(int)alloc_type_thash].total_alloc++;
+ alloc_counts[(int) alloc_type_thash].total_alloc++;
*ptr = initial_thash;
return ptr;
}
/* Allocate structure, union, or enum tag information. */
static tag_t *
-allocate_tag ()
+allocate_tag (void)
{
register tag_t *ptr;
static tag_t initial_tag;
#ifndef MALLOC_CHECK
- ptr = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
+ ptr = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
if (ptr != (tag_t *) NULL)
- alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr->free;
+ alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr->free;
else
{
- register int unallocated = alloc_counts[(int)alloc_type_tag].unallocated;
- register page_type *cur_page = alloc_counts[(int)alloc_type_tag].cur_page;
+ register int unallocated = alloc_counts[(int) alloc_type_tag].unallocated;
+ register page_type *cur_page = alloc_counts[(int) alloc_type_tag].cur_page;
if (unallocated == 0)
{
unallocated = PAGE_SIZE / sizeof (tag_t);
- alloc_counts[(int)alloc_type_tag].cur_page = cur_page = allocate_page ();
- alloc_counts[(int)alloc_type_tag].total_pages++;
+ alloc_counts[(int) alloc_type_tag].cur_page = cur_page = allocate_page ();
+ alloc_counts[(int) alloc_type_tag].total_pages++;
}
ptr = &cur_page->tag[--unallocated];
- alloc_counts[(int)alloc_type_tag].unallocated = unallocated;
+ alloc_counts[(int) alloc_type_tag].unallocated = unallocated;
}
#else
#endif
- alloc_counts[(int)alloc_type_tag].total_alloc++;
+ alloc_counts[(int) alloc_type_tag].total_alloc++;
*ptr = initial_tag;
return ptr;
}
/* Free scoping information. */
static void
-free_tag (ptr)
- tag_t *ptr;
+free_tag (tag_t *ptr)
{
- alloc_counts[(int)alloc_type_tag].total_free++;
+ alloc_counts[(int) alloc_type_tag].total_free++;
#ifndef MALLOC_CHECK
- ptr->free = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
- alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr;
+ ptr->free = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
+ alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr;
#else
free ((PTR_T) ptr);
#endif
/* Allocate forward reference to a yet unknown tag. */
static forward_t *
-allocate_forward ()
+allocate_forward (void)
{
register forward_t *ptr;
static forward_t initial_forward;
#ifndef MALLOC_CHECK
- register int unallocated = alloc_counts[(int)alloc_type_forward].unallocated;
- register page_type *cur_page = alloc_counts[(int)alloc_type_forward].cur_page;
+ register int unallocated = alloc_counts[(int) alloc_type_forward].unallocated;
+ register page_type *cur_page = alloc_counts[(int) alloc_type_forward].cur_page;
if (unallocated == 0)
{
unallocated = PAGE_SIZE / sizeof (forward_t);
- alloc_counts[(int)alloc_type_forward].cur_page = cur_page = allocate_page ();
- alloc_counts[(int)alloc_type_forward].total_pages++;
+ alloc_counts[(int) alloc_type_forward].cur_page = cur_page = allocate_page ();
+ alloc_counts[(int) alloc_type_forward].total_pages++;
}
ptr = &cur_page->forward[--unallocated];
- alloc_counts[(int)alloc_type_forward].unallocated = unallocated;
+ alloc_counts[(int) alloc_type_forward].unallocated = unallocated;
#else
#endif
- alloc_counts[(int)alloc_type_forward].total_alloc++;
+ alloc_counts[(int) alloc_type_forward].total_alloc++;
*ptr = initial_forward;
return ptr;
}
/* Allocate head of type hash list. */
static thead_t *
-allocate_thead ()
+allocate_thead (void)
{
register thead_t *ptr;
static thead_t initial_thead;
#ifndef MALLOC_CHECK
- ptr = alloc_counts[(int)alloc_type_thead].free_list.f_thead;
+ ptr = alloc_counts[(int) alloc_type_thead].free_list.f_thead;
if (ptr != (thead_t *) NULL)
- alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr->free;
+ alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr->free;
else
{
- register int unallocated = alloc_counts[(int)alloc_type_thead].unallocated;
- register page_type *cur_page = alloc_counts[(int)alloc_type_thead].cur_page;
+ register int unallocated = alloc_counts[(int) alloc_type_thead].unallocated;
+ register page_type *cur_page = alloc_counts[(int) alloc_type_thead].cur_page;
if (unallocated == 0)
{
unallocated = PAGE_SIZE / sizeof (thead_t);
- alloc_counts[(int)alloc_type_thead].cur_page = cur_page = allocate_page ();
- alloc_counts[(int)alloc_type_thead].total_pages++;
+ alloc_counts[(int) alloc_type_thead].cur_page = cur_page = allocate_page ();
+ alloc_counts[(int) alloc_type_thead].total_pages++;
}
ptr = &cur_page->thead[--unallocated];
- alloc_counts[(int)alloc_type_thead].unallocated = unallocated;
+ alloc_counts[(int) alloc_type_thead].unallocated = unallocated;
}
#else
#endif
- alloc_counts[(int)alloc_type_thead].total_alloc++;
+ alloc_counts[(int) alloc_type_thead].total_alloc++;
*ptr = initial_thead;
return ptr;
}
/* Free scoping information. */
static void
-free_thead (ptr)
- thead_t *ptr;
+free_thead (thead_t *ptr)
{
- alloc_counts[(int)alloc_type_thead].total_free++;
+ alloc_counts[(int) alloc_type_thead].total_free++;
#ifndef MALLOC_CHECK
- ptr->free = (thead_t *) alloc_counts[(int)alloc_type_thead].free_list.f_thead;
- alloc_counts[(int)alloc_type_thead].free_list.f_thead = ptr;
+ ptr->free = (thead_t *) alloc_counts[(int) alloc_type_thead].free_list.f_thead;
+ alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr;
#else
free ((PTR_T) ptr);
#endif
}
\f
static lineno_list_t *
-allocate_lineno_list ()
+allocate_lineno_list (void)
{
register lineno_list_t *ptr;
static lineno_list_t initial_lineno_list;
#ifndef MALLOC_CHECK
- register int unallocated = alloc_counts[(int)alloc_type_lineno].unallocated;
- register page_type *cur_page = alloc_counts[(int)alloc_type_lineno].cur_page;
+ register int unallocated = alloc_counts[(int) alloc_type_lineno].unallocated;
+ register page_type *cur_page = alloc_counts[(int) alloc_type_lineno].cur_page;
if (unallocated == 0)
{
unallocated = PAGE_SIZE / sizeof (lineno_list_t);
- alloc_counts[(int)alloc_type_lineno].cur_page = cur_page = allocate_page ();
- alloc_counts[(int)alloc_type_lineno].total_pages++;
+ alloc_counts[(int) alloc_type_lineno].cur_page = cur_page = allocate_page ();
+ alloc_counts[(int) alloc_type_lineno].total_pages++;
}
ptr = &cur_page->lineno[--unallocated];
- alloc_counts[(int)alloc_type_lineno].unallocated = unallocated;
+ alloc_counts[(int) alloc_type_lineno].unallocated = unallocated;
#else
#endif
- alloc_counts[(int)alloc_type_lineno].total_alloc++;
+ alloc_counts[(int) alloc_type_lineno].total_alloc++;
*ptr = initial_lineno_list;
return ptr;
}
void
-ecoff_set_gp_prolog_size (sz)
- int sz;
+ecoff_set_gp_prolog_size (int sz)
{
if (cur_proc_ptr == 0)
return;
cur_proc_ptr->pdr.gp_used = 1;
}
-int
-ecoff_no_current_file ()
+int
+ecoff_no_current_file (void)
{
return cur_file_ptr == (efdr_t *) NULL;
}
void
-ecoff_generate_asm_lineno ()
+ecoff_generate_asm_lineno (void)
{
unsigned int lineno;
char *filename;
as_where (&filename, &lineno);
- if (current_stabs_filename == (char *)NULL
+ if (current_stabs_filename == (char *) NULL
|| strcmp (current_stabs_filename, filename))
add_file (filename, 0, 1);
pl = &noproc_lineno;
while (*pl != (lineno_list_t *) NULL)
- pl = &(*pl)->next;
+ pl = &(*pl)->next;
*pl = list;
}
else
#else
void
-ecoff_generate_asm_lineno ()
+ecoff_generate_asm_lineno (void)
{
}
projects / deliverable / binutils-gdb.git / blobdiff