/* ECOFF debugging support.
- Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
- Free Software Foundation, Inc.
+ Copyright (C) 1993-2020 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
GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
+ the Free Software Foundation; either version 3, or (at your option)
any later version.
GAS is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING. If not, write to the Free
- Software Foundation, 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
+ 02110-1301, USA. */
#include "as.h"
/* This file is compiled conditionally for those targets which use
- ECOFF debugging information (e.g., MIPS ECOFF, MIPS ELF, Alpha
- ECOFF). */
+ ECOFF debugging information (e.g., MIPS ELF, Alpha ECOFF). */
#include "ecoff.h"
#include "coff/internal.h"
#include "coff/symconst.h"
#include "aout/stab_gnu.h"
-
+#include "filenames.h"
#include "safe-ctype.h"
/* Why isn't this in coff/sym.h? */
Each file table has offsets for where the line numbers, local
strings, local symbols, and procedure table starts from within the
- global tables, and the indexs are reset to 0 for each of those
+ global tables, and the indices are reset to 0 for each of those
tables for the file.
The procedure table contains the binary equivalents of the .ent
#26 48 0x00000030 struct no name { ifd = -1, index = 1048575 }
*/
\f
-/* Redefinition of of storage classes as an enumeration for better
+/* Redefinition of storage classes as an enumeration for better
debugging. */
typedef enum sc {
varray_t aux_syms; /* auxiliary symbols */
struct efdr *next_file; /* next file descriptor */
/* string/type hash tables */
- struct hash_control *str_hash; /* string hash table */
+ htab_t str_hash; /* string hash table */
thash_t *thash_head[THASH_SIZE];
} efdr_t;
(struct efdr *)0, /* next_file: next file structure */
- (struct hash_control *)0, /* str_hash: string hash table */
+ (htab_t)0, /* str_hash: string hash table */
{ 0 }, /* thash_head: type hash table */
};
static varray_t file_desc = INIT_VARRAY (efdr_t);
-static struct hash_control *tag_hash;
+static htab_t tag_hash;
/* Static types for int and void. Also, remember the last function's
type (which is set up when we encounter the declaration for the
static void add_varray_page (varray_t *vp);
static symint_t add_string (varray_t *vp,
- struct hash_control *hash_tbl,
+ htab_t hash_tbl,
const char *str,
shash_t **ret_hash);
static localsym_t *add_ecoff_symbol (const char *str, st_t type,
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_procedure (char *func, int aent);
static void add_file (const char *file_name, int indx, int fake);
#ifdef ECOFF_DEBUG
static char *sc_to_string (sc_t storage_class);
void
ecoff_read_begin_hook (void)
{
- tag_hash = hash_new ();
+ tag_hash = str_htab_create ();
top_tag_head = allocate_thead ();
top_tag_head->first_tag = (tag_t *) NULL;
top_tag_head->free = (thead_t *) NULL;
obj->ecoff_symbol = NULL;
obj->ecoff_extern_size = 0;
}
+
+void
+ecoff_symbol_clone_hook (symbolS *newsymP, symbolS *orgsymP)
+{
+ OBJ_SYMFIELD_TYPE *n, *o;
+
+ n = symbol_get_obj (newsymP);
+ o = symbol_get_obj (orgsymP);
+ memcpy (n, o, sizeof *n);
+}
\f
/* Add a page to a varray object. */
static symint_t
add_string (varray_t *vp, /* string obstack */
- struct hash_control *hash_tbl, /* ptr to hash table */
+ htab_t 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;
+ unsigned long len = strlen (str);
+ shash_t *hash_ptr;
if (len >= PAGE_USIZE)
as_fatal (_("string too big (%lu bytes)"), len);
- hash_ptr = (shash_t *) hash_find (hash_tbl, str);
+ hash_ptr = (shash_t *) str_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 =
strcpy (hash_ptr->string, str);
- err = hash_insert (hash_tbl, str, (char *) hash_ptr);
- if (err)
- as_fatal (_("inserting \"%s\" into string hash table: %s"),
- str, err);
+ str_hash_insert (hash_tbl, str, (char *) hash_ptr);
}
if (ret_hash != (shash_t **) NULL)
symint_t indx /* index to local/aux. syms */)
{
localsym_t *psym;
- register scope_t *pscope;
- register thead_t *ptag_head;
- register tag_t *ptag;
- register tag_t *ptag_next;
- register varray_t *vp;
- register int scope_delta = 0;
+ scope_t *pscope;
+ thead_t *ptag_head;
+ tag_t *ptag;
+ tag_t *ptag_next;
+ varray_t *vp;
+ int scope_delta = 0;
shash_t *hash_ptr = (shash_t *) NULL;
if (cur_file_ptr == (efdr_t *) NULL)
ty = add_aux_sym_tir (&last_func_type_info,
hash_no,
&cur_file_ptr->thash_head[0]);
-
+ (void) ty;
/* This seems to be unnecessary. I'm not even sure what it is
* intended to do. It's from mips-tfile.
* if (last_func_sym_value != (symbolS *) NULL)
static symint_t
add_aux_sym_symint (symint_t aux_word /* auxiliary information word */)
{
- register varray_t *vp;
- register aux_t *aux_ptr;
+ varray_t *vp;
+ aux_t *aux_ptr;
if (cur_file_ptr == (efdr_t *) NULL)
as_fatal (_("no current file pointer"));
static symint_t
add_aux_sym_rndx (int file_index, symint_t sym_index)
{
- register varray_t *vp;
- register aux_t *aux_ptr;
+ varray_t *vp;
+ aux_t *aux_ptr;
if (cur_file_ptr == (efdr_t *) NULL)
as_fatal (_("no current file pointer"));
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;
+ varray_t *vp;
+ aux_t *aux_ptr;
static AUXU init_aux;
symint_t ret;
int i;
if (state != hash_no)
{
- register thash_t *hash_ptr;
- register symint_t hi;
+ thash_t *hash_ptr;
+ symint_t hi;
hi = aux.isym & ((1 << HASHBITS) - 1);
hi %= THASH_SIZE;
|| t->basic_type == bt_Union
|| t->basic_type == bt_Enum)
{
- register symint_t file_index = t->tag_ptr->ifd;
- register localsym_t *sym = t->tag_ptr->sym;
- register forward_t *forward_ref = allocate_forward ();
+ symint_t file_index = t->tag_ptr->ifd;
+ localsym_t *sym = t->tag_ptr->sym;
+ forward_t *forward_ref = allocate_forward ();
if (sym != (localsym_t *) NULL)
{
bt_t basic_type /* bt_Struct, bt_Union, or bt_Enum */)
{
shash_t *hash_ptr;
- const char *err;
tag_t *tag_ptr;
if (cur_file_ptr == (efdr_t *) NULL)
as_fatal (_("no current file pointer"));
- hash_ptr = (shash_t *) hash_find (tag_hash, tag);
+ hash_ptr = (shash_t *) str_hash_find (tag_hash, tag);
if (hash_ptr != (shash_t *) NULL
&& hash_ptr->tag_ptr != (tag_t *) NULL)
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"),
- tag, err);
+ str_hash_insert (tag_hash, perm, (char *) hash_ptr);
hash_ptr->string = perm;
}
}
\f
/* Add a procedure to the current file's list of procedures, and record
- this is the current procedure. */
+ this is the current procedure. If AENT, then only set the requested
+ symbol's function type. */
static void
-add_procedure (char *func /* func name */)
+add_procedure (char *func /* func name */, int aent)
{
- register varray_t *vp;
- register proc_t *new_proc_ptr;
+ varray_t *vp;
+ proc_t *new_proc_ptr;
symbolS *sym;
#ifdef ECOFF_DEBUG
fputc ('\n', stderr);
#endif
+ /* Set the BSF_FUNCTION flag for the symbol. */
+ sym = symbol_find_or_make (func);
+ symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
+
+ if (aent)
+ return;
+
if (cur_file_ptr == (efdr_t *) NULL)
as_fatal (_("no current file pointer"));
new_proc_ptr->pdr.lnLow = -1;
new_proc_ptr->pdr.lnHigh = -1;
- /* Set the BSF_FUNCTION flag for the symbol. */
- sym = symbol_find_or_make (func);
- 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,
sym, (bfd_vma) 0, (symint_t) 0,
static void
add_file (const char *file_name, int indx ATTRIBUTE_UNUSED, int fake)
{
- register int first_ch;
- register efdr_t *fil_ptr;
+ int first_ch;
+ efdr_t *fil_ptr;
#ifdef ECOFF_DEBUG
if (debug)
want to use the actual file name. */
if (file_name == (const char *) NULL)
{
- char *file;
-
if (first_file != (efdr_t *) NULL)
as_fatal (_("fake .file after real one"));
- as_where (&file, (unsigned int *) NULL);
- file_name = (const char *) file;
+ file_name = as_where ((unsigned int *) NULL);
/* Automatically generate ECOFF debugging information, since I
think that's what other ECOFF assemblers do. We don't do
if (stabs_seen)
{
(void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
- symbol_new ("L0\001", now_seg,
- (valueT) frag_now_fix (),
- frag_now),
+ symbol_new (FAKE_LABEL_NAME, now_seg,
+ frag_now, frag_now_fix ()),
(bfd_vma) 0, 0, ECOFF_MARK_STAB (N_SOL));
return;
}
fil_ptr = fil_ptr->next_file)
{
if (first_ch == fil_ptr->name[0]
- && strcmp (file_name, fil_ptr->name) == 0
+ && filename_cmp (file_name, fil_ptr->name) == 0
&& fil_ptr->fdr.fMerge)
{
cur_file_ptr = fil_ptr;
fil_ptr->fake = fake;
/* Allocate the string hash table. */
- fil_ptr->str_hash = hash_new ();
+ fil_ptr->str_hash = str_htab_create ();
/* Make sure 0 byte in string table is null */
add_string (&fil_ptr->strings,
compiler output, only in hand coded assembler. */
void
-ecoff_new_file (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)
+ if (cur_file_ptr != NULL && filename_cmp (cur_file_ptr->name, name) == 0)
return;
add_file (name, 0, 0);
return;
}
- name = input_line_pointer;
- name_end = get_symbol_end ();
+ name_end = get_symbol_name (&name);
(void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text,
symbol_find_or_make (name),
(bfd_vma) 0, (symint_t) 0, (symint_t) 0);
- *input_line_pointer = name_end;
+ (void) restore_line_pointer (name_end);
/* The line number follows, but we don't use it. */
(void) get_absolute_expression ();
return;
}
- name = input_line_pointer;
- name_end = get_symbol_end ();
+ name_end = get_symbol_name (&name);
/* The value is the distance between the .bend directive and the
corresponding symbol. We fill in the offset when we write out
(void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym,
(bfd_vma) 0, (symint_t) 0, (symint_t) 0);
- *input_line_pointer = name_end;
+ restore_line_pointer (name_end);
/* The line number follows, but we don't use it. */
(void) get_absolute_expression ();
SKIP_WHITESPACE ();
- name = input_line_pointer;
- name_end = get_symbol_end ();
+ name_end = get_symbol_name (&name);
if (coff_sym_name != (char *) NULL)
as_warn (_(".def pseudo-op used inside of .def/.endef; 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);
-
+ free (coff_sym_name);
+ free (coff_tag);
+
coff_sym_name = xstrdup (name);
coff_type = type_info_init;
coff_storage_class = sc_Nil;
coff_sym_addend = 0;
}
- *input_line_pointer = name_end;
+ restore_line_pointer (name_end);
demand_empty_rest_of_line ();
}
return;
}
- name = input_line_pointer;
- name_end = get_symbol_end ();
+ name_end = get_symbol_name (&name);
coff_tag = xstrdup (name);
- *input_line_pointer = name_end;
+ (void) restore_line_pointer (name_end);
demand_empty_rest_of_line ();
}
expression (&exp);
if (exp.X_op != O_constant && exp.X_op != O_symbol)
{
- as_bad (_(".val expression is too copmlex"));
+ as_bad (_(".val expression is too complex"));
demand_empty_rest_of_line ();
return;
}
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
+ /* Is this a bitfield? This is indicated by a structure member
having a size field that isn't an array. */
coff_type.bitfield = 1;
}
return;
}
- name = input_line_pointer;
- name_end = get_symbol_end ();
+ name_end = get_symbol_name (&name);
if (name == input_line_pointer)
{
as_warn (_(".end directive has no name"));
- *input_line_pointer = name_end;
+ (void) restore_line_pointer (name_end);
demand_empty_rest_of_line ();
return;
}
as_warn (_(".end directive names unknown symbol"));
else
(void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text,
- symbol_new ("L0\001", now_seg,
- (valueT) frag_now_fix (),
- frag_now),
+ symbol_new (FAKE_LABEL_NAME, now_seg,
+ frag_now, frag_now_fix ()),
(bfd_vma) 0, (symint_t) 0, (symint_t) 0);
+#ifdef md_flush_pending_output
+ md_flush_pending_output ();
+#endif
+
cur_proc_ptr = (proc_t *) NULL;
- *input_line_pointer = name_end;
+ (void) restore_line_pointer (name_end);
demand_empty_rest_of_line ();
}
\f
/* Parse .ent directives. */
void
-ecoff_directive_ent (int ignore ATTRIBUTE_UNUSED)
+ecoff_directive_ent (int aent)
{
char *name;
char name_end;
if (cur_file_ptr == (efdr_t *) NULL)
add_file ((const char *) NULL, 0, 1);
- if (cur_proc_ptr != (proc_t *) NULL)
+ if (!aent && cur_proc_ptr != (proc_t *) NULL)
{
as_warn (_("second .ent directive found before .end directive"));
demand_empty_rest_of_line ();
return;
}
- name = input_line_pointer;
- name_end = get_symbol_end ();
+ name_end = get_symbol_name (&name);
if (name == input_line_pointer)
{
- as_warn (_(".ent directive has no name"));
- *input_line_pointer = name_end;
+ as_warn (_("%s directive has no name"), aent ? ".aent" : ".ent");
+ (void) restore_line_pointer (name_end);
demand_empty_rest_of_line ();
return;
}
- add_procedure (name);
+ add_procedure (name, aent);
- *input_line_pointer = name_end;
+ (void) restore_line_pointer (name_end);
/* The .ent directive is sometimes followed by a number. I'm not
really sure what the number means. I don't see any way to store
symbolS *symbolp;
valueT size;
- name = input_line_pointer;
- c = get_symbol_end ();
+ c = get_symbol_name (&name);
symbolp = symbol_find_or_make (name);
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
S_SET_EXTERNAL (symbolp);
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
+ anywhere. Don't call demand_empty_rest_of_line (). */
s_ignore (42);
-#endif
}
\f
/* Parse .mask directives. */
if (stabs_seen)
{
(void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
- symbol_new ("L0\001", now_seg,
- (valueT) frag_now_fix (),
- frag_now),
+ symbol_new (FAKE_LABEL_NAME, now_seg,
+ frag_now, frag_now_fix ()),
(bfd_vma) 0, 0, lineno);
return;
}
{
if (! stabs_seen)
{
- /* Add a dummy @stabs dymbol. */
+ /* Add a dummy @stabs symbol. */
stabs_seen = 1;
- (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
+ (void) add_ecoff_symbol (stabs_symbol, st_Nil, sc_Info,
(symbolS *) NULL,
(bfd_vma) 0, (symint_t) -1,
ECOFF_MARK_STAB (0));
symbolS *symbolP;
expressionS exp;
- name = input_line_pointer;
- c = get_symbol_end ();
+ c = get_symbol_name (&name);
symbolP = symbol_find_or_make (name);
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
SKIP_WHITESPACE ();
return;
}
- name = input_line_pointer;
- name_end = get_symbol_end ();
-
+ name_end = get_symbol_name (&name);
sym = symbol_find_or_make (name);
- *input_line_pointer = name_end;
+ (void) restore_line_pointer (name_end);
value = 0;
addend = 0;
but with the name .scommon. */
if (scom_section.name == NULL)
{
- scom_section = bfd_com_section;
+ scom_section = *bfd_com_section_ptr;
scom_section.name = ".scommon";
scom_section.output_section = &scom_section;
scom_section.symbol = &scom_symbol;
scom_section.symbol_ptr_ptr = &scom_section.symbol;
- scom_symbol = *bfd_com_section.symbol;
+ scom_symbol = *bfd_com_section_ptr->symbol;
scom_symbol.name = ".scommon";
scom_symbol.section = &scom_section;
}
if (need < PAGE_SIZE)
need = PAGE_SIZE;
want = (*bufend - *buf) + need;
- *buf = xrealloc (*buf, want);
+ *buf = XRESIZEVEC (char, *buf, want);
*bufend = *buf + want;
return *buf + at;
}
long *linecntptr)
{
char *bufptr;
- register lineno_list_t *l;
+ lineno_list_t *l;
lineno_list_t *last;
efdr_t *file;
proc_t *proc;
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
&& first_proc_ptr != (proc_t *) NULL
&& local_first_lineno != (lineno_list_t *) NULL
&& ((S_GET_VALUE (first_proc_ptr->sym->as_sym)
- + bfd_get_section_vma (stdoutput,
- S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
+ + bfd_section_vma (S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
!= 0))
{
first.file = local_first_lineno->file;
unsigned long offset)
{
const bfd_size_type external_sym_size = backend->external_sym_size;
- void (* const swap_sym_out) (bfd *, const SYMR *, PTR)
+ void (* const swap_sym_out) (bfd *, const SYMR *, void *)
= backend->swap_sym_out;
char *sym_out;
long isym;
else
sym_ptr->ecoff_sym.asym.value =
(S_GET_VALUE (as_sym)
- + bfd_get_section_vma (stdoutput,
- S_GET_SEGMENT (as_sym))
+ + bfd_section_vma (S_GET_SEGMENT (as_sym))
+ sym_ptr->addend);
sym_ptr->ecoff_sym.weakext = S_IS_WEAK (as_sym);
sc = sc_Bss;
else if (strcmp (segname, ".sbss") == 0)
sc = sc_SBss;
- else if (seg == &bfd_abs_section)
+ else if (seg == bfd_abs_section_ptr)
sc = sc_Abs;
else
{
/* 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. */
+ numbers will have FAKE_LABEL_CHAR in the names. */
if (local
&& sym_ptr->ecoff_sym.asym.st != st_End
- && strchr (sym_ptr->name, '\001') == 0)
+ && strchr (sym_ptr->name, FAKE_LABEL_CHAR) == 0)
sym_ptr->ecoff_sym.asym.iss =
add_string (&fil_ptr->strings,
fil_ptr->str_hash,
sym_ptr->ecoff_sym.asym.iss =
begin_ptr->ecoff_sym.asym.iss;
- begin_type = begin_ptr->ecoff_sym.asym.st;
+ begin_type = (st_t) begin_ptr->ecoff_sym.asym.st;
if (begin_type == st_File
|| begin_type == st_Block)
{
unsigned long offset)
{
const bfd_size_type external_pdr_size = backend->external_pdr_size;
- void (* const swap_pdr_out) (bfd *, const PDR *, PTR)
+ void (* const swap_pdr_out) (bfd *, const PDR *, void *)
= backend->swap_pdr_out;
char *pdr_out;
long iproc;
adr_sym = proc_ptr->sym->as_sym;
adr = (S_GET_VALUE (adr_sym)
- + bfd_get_section_vma (stdoutput,
- S_GET_SEGMENT (adr_sym)));
+ + bfd_section_vma (S_GET_SEGMENT (adr_sym)));
if (first)
{
/* This code used to force the adr of the very
unsigned long offset)
{
const bfd_size_type external_fdr_size = backend->external_fdr_size;
- void (* const swap_fdr_out) (bfd *, const FDR *, PTR)
+ void (* const swap_fdr_out) (bfd *, const FDR *, void *)
= backend->swap_fdr_out;
long ifile;
char *fdr_out;
static void
ecoff_setup_ext (void)
{
- register symbolS *sym;
+ symbolS *sym;
for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
{
/* Build the symbolic information. */
offset = 0;
- buf = xmalloc (PAGE_SIZE);
+ buf = XNEWVEC (char, PAGE_SIZE);
bufend = buf + PAGE_SIZE;
/* Build the line number information. */
static page_type *
allocate_cluster (unsigned long npages)
{
- register page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE);
+ page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE);
#ifdef ECOFF_DEBUG
if (debug > 3)
static scope_t *
allocate_scope (void)
{
- register scope_t *ptr;
+ scope_t *ptr;
static scope_t initial_scope;
#ifndef MALLOC_CHECK
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;
+ int unallocated = alloc_counts[(int) alloc_type_scope].unallocated;
+ page_type *cur_page = alloc_counts[(int) alloc_type_scope].cur_page;
if (unallocated == 0)
{
#else
- ptr = (scope_t *) xmalloc (sizeof (scope_t));
+ ptr = XNEW (scope_t);
#endif
ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr;
#else
- free ((PTR) ptr);
+ free ((void *) ptr);
#endif
}
\f
static vlinks_t *
allocate_vlinks (void)
{
- register vlinks_t *ptr;
+ 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;
+ int unallocated = alloc_counts[(int) alloc_type_vlinks].unallocated;
+ page_type *cur_page = alloc_counts[(int) alloc_type_vlinks].cur_page;
if (unallocated == 0)
{
#else
- ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
+ ptr = XNEW (vlinks_t);
#endif
static shash_t *
allocate_shash (void)
{
- register shash_t *ptr;
+ 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;
+ int unallocated = alloc_counts[(int) alloc_type_shash].unallocated;
+ page_type *cur_page = alloc_counts[(int) alloc_type_shash].cur_page;
if (unallocated == 0)
{
#else
- ptr = (shash_t *) xmalloc (sizeof (shash_t));
+ ptr = XNEW (shash_t);
#endif
static thash_t *
allocate_thash (void)
{
- register thash_t *ptr;
+ 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;
+ int unallocated = alloc_counts[(int) alloc_type_thash].unallocated;
+ page_type *cur_page = alloc_counts[(int) alloc_type_thash].cur_page;
if (unallocated == 0)
{
#else
- ptr = (thash_t *) xmalloc (sizeof (thash_t));
+ ptr = XNEW (thash_t);
#endif
static tag_t *
allocate_tag (void)
{
- register tag_t *ptr;
+ tag_t *ptr;
static tag_t initial_tag;
#ifndef MALLOC_CHECK
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;
+ int unallocated = alloc_counts[(int) alloc_type_tag].unallocated;
+ page_type *cur_page = alloc_counts[(int) alloc_type_tag].cur_page;
if (unallocated == 0)
{
#else
- ptr = (tag_t *) xmalloc (sizeof (tag_t));
+ ptr = XNEW (tag_t);
#endif
static forward_t *
allocate_forward (void)
{
- register forward_t *ptr;
+ 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;
+ int unallocated = alloc_counts[(int) alloc_type_forward].unallocated;
+ page_type *cur_page = alloc_counts[(int) alloc_type_forward].cur_page;
if (unallocated == 0)
{
#else
- ptr = (forward_t *) xmalloc (sizeof (forward_t));
+ ptr = XNEW (forward_t);
#endif
static thead_t *
allocate_thead (void)
{
- register thead_t *ptr;
+ thead_t *ptr;
static thead_t initial_thead;
#ifndef MALLOC_CHECK
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;
+ int unallocated = alloc_counts[(int) alloc_type_thead].unallocated;
+ page_type *cur_page = alloc_counts[(int) alloc_type_thead].cur_page;
if (unallocated == 0)
{
#else
- ptr = (thead_t *) xmalloc (sizeof (thead_t));
+ ptr = XNEW (thead_t);
#endif
static lineno_list_t *
allocate_lineno_list (void)
{
- register lineno_list_t *ptr;
+ 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;
+ int unallocated = alloc_counts[(int) alloc_type_lineno].unallocated;
+ page_type *cur_page = alloc_counts[(int) alloc_type_lineno].cur_page;
if (unallocated == 0)
{
#else
- ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
+ ptr = XNEW (lineno_list_t);
#endif
ecoff_generate_asm_lineno (void)
{
unsigned int lineno;
- char *filename;
+ const char *filename;
lineno_list_t *list;
- as_where (&filename, &lineno);
+ filename = as_where (&lineno);
if (current_stabs_filename == (char *) NULL
- || strcmp (current_stabs_filename, filename))
+ || filename_cmp (current_stabs_filename, filename))
add_file (filename, 0, 1);
list = allocate_lineno_list ();
projects / thirdparty / binutils-gdb.git / blobdiff