/* ECOFF debugging support.
- Copyright (C) 1993, 94, 95, 96, 97, 98 Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+ 2003, 2004, 2005
+ 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;
+
/* Make sure that we have a file pointer, but only if we have seen a
file. If we haven't seen a file, then this is a probably special
symbol created by md_begin which may required special handling at
if (cur_file_ptr == (efdr_t *) NULL
&& seen_at_least_1_file ())
add_file ((const char *) NULL, 0, 1);
- symbolP->ecoff_file = cur_file_ptr;
- symbolP->ecoff_symbol = NULL;
- symbolP->ecoff_extern_size = 0;
+ obj = symbol_get_obj (symbolP);
+ obj->ecoff_file = cur_file_ptr;
+ obj->ecoff_symbol = NULL;
+ obj->ecoff_extern_size = 0;
}
\f
/* 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);
psym->name = str;
psym->as_sym = sym_value;
if (sym_value != (symbolS *) NULL)
- sym_value->ecoff_symbol = psym;
+ symbol_get_obj (sym_value)->ecoff_symbol = psym;
psym->addend = addend;
psym->file_ptr = cur_file_ptr;
psym->proc_ptr = cur_proc_ptr;
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;
/* Set the BSF_FUNCTION flag for the symbol. */
sym = symbol_find_or_make (func);
- sym->bsym->flags |= BSF_FUNCTION;
+ symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
/* Push the start of the function. */
new_proc_ptr->sym = add_ecoff_symbol ((const char *) NULL, st_Proc, sc_Text,
}
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, int appfile ATTRIBUTE_UNUSED)
{
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)
{
else if (coff_symbol_typ == st_Member
&& 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. */
+ /* Is this a bitfield? This is indicated by a structure member
+ 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 (*input_line_pointer) || *input_line_pointer == '-')
+ if (ISDIGIT (*input_line_pointer)
+ || *input_line_pointer == '-')
(void) get_absolute_expression ();
demand_empty_rest_of_line ();
/* Parse .extern directives. */
void
-ecoff_directive_extern (ignore)
- int ignore;
+ecoff_directive_extern (int ignore ATTRIBUTE_UNUSED)
{
char *name;
int c;
++input_line_pointer;
size = get_absolute_expression ();
- symbolp->ecoff_extern_size = size;
+ symbol_get_obj (symbolp)->ecoff_extern_size = size;
}
\f
/* 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. */
- demand_empty_rest_of_line ();
-#else
+ /* 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. Don't call demand_empty_rest_of_line (). */
s_ignore (42);
-#endif
}
\f
/* 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;
}
- symbolP->sy_value = exp;
+ 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 (*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
ECOFF symbol. We want to compute the type of the ECOFF symbol
independently. */
if (sym != (symbolS *) NULL)
- hold = sym->ecoff_symbol;
+ hold = symbol_get_obj (sym)->ecoff_symbol;
(void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx);
if (sym != (symbolS *) NULL)
- sym->ecoff_symbol = hold;
+ symbol_get_obj (sym)->ecoff_symbol = hold;
/* Restore normal file type. */
cur_file_ptr = save_file_ptr;
.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;
}
/* Double check weak symbols. */
- if (sym->bsym->flags & BSF_WEAK)
+ 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;
iline = 0;
totcount = 0;
+ /* FIXME? Now that MIPS embedded-PIC is gone, it may be safe to
+ remove this code. */
/* For some reason the address of the first procedure is ignored
when reading line numbers. This doesn't matter if the address of
the first procedure is 0, but when gcc is generating MIPS
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
|| S_IS_WEAK (as_sym)
|| ! S_IS_DEFINED (as_sym)))
{
- if ((as_sym->bsym->flags & BSF_FUNCTION) != 0)
+ if ((symbol_get_bfdsym (as_sym)->flags
+ & BSF_FUNCTION) != 0)
st = st_Proc;
else
st = st_Global;
if (! S_IS_DEFINED (as_sym))
{
- if (as_sym->ecoff_extern_size == 0
- || (as_sym->ecoff_extern_size
- > bfd_get_gp_size (stdoutput)))
+ valueT s;
+
+ s = symbol_get_obj (as_sym)->ecoff_extern_size;
+ if (s == 0
+ || s > bfd_get_gp_size (stdoutput))
sc = sc_Undefined;
else
{
sc = sc_SUndefined;
- sym_ptr->ecoff_sym.asym.value =
- as_sym->ecoff_extern_size;
+ sym_ptr->ecoff_sym.asym.value = s;
}
#ifdef S_SET_SIZE
- S_SET_SIZE (as_sym, as_sym->ecoff_extern_size);
+ S_SET_SIZE (as_sym, s);
#endif
}
else if (S_IS_COMMON (as_sym))
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);
case this is an external symbol. Note that this
destroys the asym.index field. */
if (as_sym != (symbolS *) NULL
- && as_sym->ecoff_symbol == sym_ptr)
+ && symbol_get_obj (as_sym)->ecoff_symbol == sym_ptr)
{
if ((sym_ptr->ecoff_sym.asym.st == st_Proc
|| sym_ptr->ecoff_sym.asym.st == st_StaticProc)
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;
for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
{
- if (sym->ecoff_symbol == NULL)
+ if (symbol_get_obj (sym)->ecoff_symbol == NULL)
continue;
/* If this is a local symbol, then force the fields to zero. */
&& ! S_IS_WEAK (sym)
&& S_IS_DEFINED (sym))
{
- sym->ecoff_symbol->ecoff_sym.asym.value = 0;
- sym->ecoff_symbol->ecoff_sym.asym.st = (int) st_Nil;
- sym->ecoff_symbol->ecoff_sym.asym.sc = (int) sc_Nil;
- sym->ecoff_symbol->ecoff_sym.asym.index = indexNil;
+ struct localsym *lsym;
+
+ lsym = symbol_get_obj (sym)->ecoff_symbol;
+ lsym->ecoff_sym.asym.value = 0;
+ lsym->ecoff_sym.asym.st = (int) st_Nil;
+ lsym->ecoff_sym.asym.sc = (int) sc_Nil;
+ lsym->ecoff_sym.asym.index = indexNil;
}
- obj_ecoff_set_ext (sym, &sym->ecoff_symbol->ecoff_sym);
+ obj_ecoff_set_ext (sym, &symbol_get_obj (sym)->ecoff_symbol->ecoff_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_proc_ptr = (proc_t *) NULL;
for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
{
- if (sym->ecoff_symbol != NULL
- || sym->ecoff_file == (efdr_t *) NULL
- || (sym->bsym->flags & BSF_SECTION_SYM) != 0)
+ if (symbol_get_obj (sym)->ecoff_symbol != NULL
+ || symbol_get_obj (sym)->ecoff_file == (efdr_t *) NULL
+ || (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0)
continue;
- cur_file_ptr = sym->ecoff_file;
+ cur_file_ptr = symbol_get_obj (sym)->ecoff_file;
add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
(bfd_vma) 0, S_GET_VALUE (sym), indexNil);
}
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)
{
}