X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gas%2Fecoff.c;h=08bfee1fc5c6412934ae1ecd40e1ebbf8078b509;hb=3c7307403487367bc8d163a41324888efcebdd82;hp=cfd0901c14edde822c61b901322140894f11b5a2;hpb=9faec336f44c5db5e9f5d9c7cbd6042497ba7568;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/ecoff.c b/gas/ecoff.c index cfd0901c14..08bfee1fc5 100644 --- a/gas/ecoff.c +++ b/gas/ecoff.c @@ -1,5 +1,5 @@ /* ECOFF debugging support. - Copyright (C) 1993 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 . A good deal of it comes directly from mips-tfile.c, by Michael @@ -9,7 +9,7 @@ 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, @@ -18,23 +18,24 @@ GNU General Public License for more details. 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, 675 Mass Ave, Cambridge, MA 02139, USA. */ + along with GAS; see the file COPYING. If not, write to the Free + 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" #ifdef ECOFF_DEBUGGING #include "coff/internal.h" #include "coff/symconst.h" -#include "ecoff.h" #include "aout/stab_gnu.h" - -#include +#include "filenames.h" +#include "safe-ctype.h" /* Why isn't this in coff/sym.h? */ #define ST_RFDESCAPE 0xfff @@ -120,31 +121,31 @@ array, pointer, function, etc. qualifiers. The current base types that I have documentation for are: - btNil -- undefined + btNil -- undefined btAdr -- address - integer same size as ptr - btChar -- character - btUChar -- unsigned character - btShort -- short - btUShort -- unsigned short - btInt -- int - btUInt -- unsigned int - btLong -- long - btULong -- unsigned long - btFloat -- float (real) - btDouble -- Double (real) - btStruct -- Structure (Record) - btUnion -- Union (variant) - btEnum -- Enumerated - btTypedef -- defined via a typedef isymRef - btRange -- subrange of int - btSet -- pascal sets - btComplex -- fortran complex - btDComplex -- fortran double complex - btIndirect -- forward or unnamed typedef - btFixedDec -- Fixed Decimal - btFloatDec -- Float Decimal - btString -- Varying Length Character String - btBit -- Aligned Bit String + btChar -- character + btUChar -- unsigned character + btShort -- short + btUShort -- unsigned short + btInt -- int + btUInt -- unsigned int + btLong -- long + btULong -- unsigned long + btFloat -- float (real) + btDouble -- Double (real) + btStruct -- Structure (Record) + btUnion -- Union (variant) + btEnum -- Enumerated + btTypedef -- defined via a typedef isymRef + btRange -- subrange of int + btSet -- pascal sets + btComplex -- fortran complex + btDComplex -- fortran double complex + btIndirect -- forward or unnamed typedef + btFixedDec -- Fixed Decimal + btFloatDec -- Float Decimal + btString -- Varying Length Character String + btBit -- Aligned Bit String btPicture -- Picture btVoid -- Void (MIPS cc revision >= 2.00) @@ -152,13 +153,12 @@ current type qualifier fields I have documentation for are: - tqNil -- no more qualifiers - tqPtr -- pointer - tqProc -- procedure - tqArray -- array - tqFar -- 8086 far pointers - tqVol -- volatile - + tqNil -- no more qualifiers + tqPtr -- pointer + tqProc -- procedure + tqArray -- array + tqFar -- 8086 far pointers + tqVol -- volatile The dense number table is used in the front ends, and disappears by the time the .o is created. @@ -185,7 +185,7 @@ 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 @@ -254,8 +254,6 @@ 5) index: pointer to a local symbol or aux. entry. - - For the following program: #include @@ -266,7 +264,7 @@ } Mips-tdump produces the following information: - + Global file header: magic number 0x162 # sections 2 @@ -275,12 +273,12 @@ symbolic header size 96 optional header 56 flags 0x0 - + Symbolic header, magic number = 0x7009, vstamp = 1.31: - + Info Offset Number Bytes ==== ====== ====== ===== - + Line numbers 380 4 4 [13] Dense numbers 0 0 0 Procedures Tables 384 1 52 @@ -292,14 +290,14 @@ File Tables 1008 2 144 Relative Files 0 0 0 External Symbols 1152 20 320 - + File #0, "hello2.c" - + Name index = 1 Readin = No Merge = No Endian = LITTLE Debug level = G2 Language = C Adr = 0x00000000 - + Info Start Number Size Offset ==== ===== ====== ==== ====== Local strings 0 15 15 784 @@ -309,7 +307,7 @@ Procedures 0 1 52 384 Auxiliary symbols 0 14 56 628 Relative Files 0 0 0 0 - + There are 6 local symbols, starting at 436 Symbol# 0: "hello2.c" @@ -620,7 +618,7 @@ #26 48 0x00000030 struct no name { ifd = -1, index = 1048575 } */ -/* Redefinition of of storage classes as an enumeration for better +/* Redefinition of storage classes as an enumeration for better debugging. */ typedef enum sc { @@ -725,9 +723,9 @@ typedef enum bt { /* 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. */ @@ -767,18 +765,28 @@ enum aux_type { If PAGE_SIZE is > 4096, the string length in the shash_t structure 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 + having a mangled class name of + + t7rb_tree4Z4xkeyZt4pair2ZC4xkeyZt7xsocket1Z4UserZt9select1st2Zt4pair\ + 2ZC4xkeyZt7xsocket1Z4UserZ4xkeyZt4less1Z4xkey + + Repeat that a couple dozen times while listing the class members and + you've got strings over 4k. Hack around this for now by increasing + the page size. A proper solution would abandon this structure scheme + certainly for very large strings, and possibly entirely. */ + #ifndef PAGE_SIZE -#define PAGE_SIZE 4096 /* size of varray pages */ +#define PAGE_SIZE (8*1024) /* size of varray pages */ #endif #define PAGE_USIZE ((unsigned long) PAGE_SIZE) - #ifndef MAX_CLUSTER_PAGES /* # pages to get from system */ #define MAX_CLUSTER_PAGES 63 #endif - /* Linked list connecting separate page allocations. */ typedef struct vlinks { struct vlinks *prev; /* previous set of pages */ @@ -787,7 +795,6 @@ typedef struct vlinks { unsigned long start_index; /* starting index # of page */ } vlinks_t; - /* Virtual array header. */ typedef struct varray { vlinks_t *first; /* first page link */ @@ -813,11 +820,9 @@ typedef struct varray { 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 */ @@ -826,13 +831,13 @@ typedef struct scope { 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. */ typedef struct localsym { const char *name; /* symbol name */ symbolS *as_sym; /* symbol as seen by gas */ + bfd_vma addend; /* addend to as_sym value */ struct efdr *file_ptr; /* file pointer */ struct ecoff_proc *proc_ptr; /* proc pointer */ struct localsym *begin_ptr; /* symbol at start of block */ @@ -842,7 +847,6 @@ typedef struct localsym { 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 */ @@ -859,7 +863,6 @@ typedef struct ecoff_proc { /* 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 */ @@ -868,7 +871,6 @@ typedef struct forward { 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 { @@ -882,7 +884,6 @@ 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 */ @@ -890,7 +891,6 @@ typedef struct thead { 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 */ @@ -899,7 +899,6 @@ typedef union small_free { forward_t *f_forward; /* forward tag reference */ } small_free_t; - /* String hash table entry. */ typedef struct shash { @@ -912,7 +911,6 @@ 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 @@ -930,13 +928,13 @@ typedef struct thash { 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 { FDR fdr; /* File header to be written out */ FDR *orig_fdr; /* original file header */ char *name; /* filename */ + int fake; /* whether this is faked .file */ symint_t void_type; /* aux. pointer to 'void' type */ symint_t int_type; /* aux. pointer to 'int' type */ scope_t *cur_scope; /* current nested scopes */ @@ -953,8 +951,7 @@ 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) */ @@ -973,13 +970,9 @@ static const efdr_t init_file = 0, /* rfdBase: index into the file indirect table */ 0, /* crfd: count file indirect entries */ langC, /* lang: language for this file */ - 0, /* fMerge: whether this file can be merged */ + 1, /* fMerge: whether this file can be merged */ 0, /* fReadin: true if read in (not just created) */ -#ifdef TARGET_BYTES_BIG_ENDIAN - 1, /* fBigendian: if 1, compiled on big endian machine */ -#else - 0, /* fBigendian: if 1, compiled on big endian machine */ -#endif + TARGET_BYTES_BIG_ENDIAN, /* fBigendian: if 1, compiled on big endian machine */ GLEVEL_2, /* glevel: level this file was compiled with */ 0, /* reserved: reserved for future use */ 0, /* cbLineOffset: byte offset from header for this file ln's */ @@ -988,6 +981,7 @@ static const efdr_t init_file = (FDR *)0, /* orig_fdr: original file header pointer */ (char *)0, /* name: pointer to filename */ + 0, /* fake: whether this is a faked .file */ 0, /* void_type: ptr to aux node for void type */ 0, /* int_type: ptr to aux node for int type */ (scope_t *)0, /* cur_scope: current scope being processed */ @@ -1004,11 +998,9 @@ static const efdr_t init_file = { 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 { @@ -1021,6 +1013,7 @@ typedef struct lineno_list { } lineno_list_t; static lineno_list_t *first_lineno; +static lineno_list_t *last_lineno; static lineno_list_t **last_lineno_ptr = &first_lineno; /* Sometimes there will be some .loc statements before a .ent. We @@ -1046,13 +1039,12 @@ typedef union page { forward_t forward [ PAGE_SIZE / sizeof (forward_t) ]; thead_t thead [ PAGE_SIZE / sizeof (thead_t) ]; lineno_list_t lineno [ PAGE_SIZE / sizeof (lineno_list_t) ]; -} page_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) */ - page_t *cur_page; /* current page being allocated from */ + page_type *cur_page; /* current page being allocated from */ small_free_t free_list; /* current free list if any */ int unallocated; /* number of elements unallocated on page */ int total_alloc; /* total number of allocations */ @@ -1060,7 +1052,6 @@ typedef struct alloc_info { 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 */ @@ -1118,7 +1109,7 @@ static const type_info_t type_info_init = { /* 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; @@ -1131,7 +1122,6 @@ static type_info_t void_type_info; 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 @@ -1387,13 +1377,16 @@ static const st_t map_coff_sym_type[] = { 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]; +/* Record whether we have seen any debugging information. */ +int ecoff_debugging_seen = 0; + /* Various statics. */ static efdr_t *cur_file_ptr = (efdr_t *) 0; /* current file desc. header */ static proc_t *cur_proc_ptr = (proc_t *) 0; /* current procedure header */ +static proc_t *first_proc_ptr = (proc_t *) 0; /* first procedure header */ static thead_t *top_tag_head = (thead_t *) 0; /* top level tag head */ static thead_t *cur_tag_head = (thead_t *) 0; /* current tag head */ #ifdef ECOFF_DEBUG @@ -1401,6 +1394,8 @@ static int debug = 0; /* trace functions */ #endif static int stabs_seen = 0; /* != 0 if stabs have been seen */ +static int current_file_idx; +static const char *current_stabs_filename; /* Pseudo symbol to use when putting stabs into the symbol table. */ #ifndef STABS_SYMBOL @@ -1411,79 +1406,74 @@ static char stabs_symbol[] = STABS_SYMBOL; /* 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, - 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)); +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, int aent); +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 unsigned long ecoff_build_ext - PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend, - unsigned long offset, varray_t *ext_strings, - struct hash_control *ext_str_hash)); -static page_t *allocate_cluster PARAMS ((unsigned long npages)); -static page_t *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); /* 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 (); @@ -1496,33 +1486,50 @@ ecoff_read_begin_hook () /* This function should be called when a symbol is created. */ void -ecoff_symbol_new_hook (symbolP) - symbolS *symbolP; +ecoff_symbol_new_hook (symbolS *symbolP) { - if (cur_file_ptr == (efdr_t *) NULL) - add_file ((const char *) NULL, 0); - symbolP->ecoff_file = cur_file_ptr; - symbolP->ecoff_symbol = NULL; - symbolP->ecoff_undefined = 0; + 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 + some point. Creating a dummy file with a dummy name is certainly + wrong. */ + if (cur_file_ptr == (efdr_t *) NULL + && seen_at_least_1_file ()) + add_file ((const char *) NULL, 0, 1); + obj = symbol_get_obj (symbolP); + obj->ecoff_file = cur_file_ptr; + 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); } /* 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 (); #ifdef MALLOC_CHECK if (vp->object_size > 1) - new_links->datum = (page_t *) xcalloc (1, vp->object_size); + new_links->datum = (page_type *) xcalloc (1, vp->object_size); else #endif new_links->datum = allocate_page (); - alloc_counts[(int)alloc_type_varray].total_alloc++; - alloc_counts[(int)alloc_type_varray].total_pages++; + alloc_counts[(int) alloc_type_varray].total_alloc++; + alloc_counts[(int) alloc_type_varray].total_pages++; new_links->start_index = vp->num_allocated; vp->objects_last_page = 0; @@ -1540,29 +1547,28 @@ add_varray_page (vp) /* 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; + unsigned long len = strlen (str); + 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; + 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; @@ -1576,7 +1582,7 @@ add_string (vp, hash_tbl, str, ret_hash) 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); } @@ -1589,32 +1595,32 @@ add_string (vp, hash_tbl, str, ret_hash) /* Add debugging information for a symbol. */ static localsym_t * -add_ecoff_symbol (str, type, storage, sym_value, value, indx) - const char *str; /* symbol name */ - st_t type; /* symbol type */ - sc_t storage; /* storage class */ - symbolS *sym_value; /* associated symbol. */ - 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; - 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) - as_fatal ("no current file pointer"); + as_fatal (_("no current file pointer")); 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); @@ -1622,7 +1628,8 @@ add_ecoff_symbol (str, type, storage, sym_value, value, indx) 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; psym->begin_ptr = (localsym_t *) NULL; @@ -1679,8 +1686,8 @@ add_ecoff_symbol (str, type, storage, sym_value, value, indx) 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 (); @@ -1693,7 +1700,7 @@ add_ecoff_symbol (str, type, storage, sym_value, value, indx) case st_End: pscope = cur_file_ptr->cur_scope; if (pscope == (scope_t *) NULL) - as_fatal ("too many st_End's"); + as_fatal (_("too many st_End's")); else { st_t begin_type = (st_t) pscope->lsym->ecoff_sym.asym.st; @@ -1745,7 +1752,7 @@ add_ecoff_symbol (str, type, storage, sym_value, value, indx) 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) @@ -1776,11 +1783,12 @@ add_ecoff_symbol (str, type, storage, sym_value, value, indx) 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 @@ -1792,14 +1800,13 @@ add_ecoff_symbol (str, type, storage, sym_value, value, indx) 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; + varray_t *vp; + aux_t *aux_ptr; if (cur_file_ptr == (efdr_t *) NULL) - as_fatal ("no current file pointer"); + as_fatal (_("no current file pointer")); vp = &cur_file_ptr->aux_syms; @@ -1813,19 +1820,16 @@ add_aux_sym_symint (aux_word) 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; + varray_t *vp; + aux_t *aux_ptr; if (cur_file_ptr == (efdr_t *) NULL) - as_fatal ("no current file pointer"); + as_fatal (_("no current file pointer")); vp = &cur_file_ptr->aux_syms; @@ -1844,20 +1848,19 @@ add_aux_sym_rndx (file_index, sym_index) type qualifiers). */ static symint_t -add_aux_sym_tir (t, state, hash_tbl) - type_info_t *t; /* current type information */ - hash_state_t state; /* whether to hash type or not */ - thash_t **hash_tbl; /* pointer to hash table to use */ +add_aux_sym_tir (type_info_t *t, /* 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; + varray_t *vp; + aux_t *aux_ptr; static AUXU init_aux; symint_t ret; int i; AUXU aux; if (cur_file_ptr == (efdr_t *) NULL) - as_fatal ("no current file pointer"); + as_fatal (_("no current file pointer")); vp = &cur_file_ptr->aux_syms; @@ -1873,9 +1876,8 @@ add_aux_sym_tir (t, state, hash_tbl) 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 @@ -1898,8 +1900,8 @@ add_aux_sym_tir (t, state, hash_tbl) 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; @@ -1925,18 +1927,18 @@ add_aux_sym_tir (t, state, hash_tbl) } } - /* 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; ret = vp->num_allocated++; /* Add bitfield length if it exists. - + NOTE: Mips documentation claims bitfield goes at the end of the AUX record, but the DECstation compiler emits it here. (This would only make a difference for enum bitfields.) @@ -1945,8 +1947,7 @@ add_aux_sym_tir (t, state, hash_tbl) for an enum bitfield. */ if (t->bitfield) - (void) add_aux_sym_symint ((symint_t)t->sizes[t->num_sizes-1]); - + (void) add_aux_sym_symint ((symint_t) t->sizes[t->num_sizes - 1]); /* Add tag information if needed. Structure, union, and enum references add 2 aux symbols: a [file index, symbol index] @@ -1956,9 +1957,9 @@ add_aux_sym_tir (t, state, hash_tbl) || 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) { @@ -1973,11 +1974,11 @@ add_aux_sym_tir (t, state, hash_tbl) (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. */ @@ -1995,7 +1996,7 @@ add_aux_sym_tir (t, state, hash_tbl) }; /* 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; } @@ -2003,43 +2004,41 @@ add_aux_sym_tir (t, state, hash_tbl) /* Add a tag to the tag table (unless it already exists). */ static tag_t * -get_tag (tag, 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; tag_t *tag_ptr; if (cur_file_ptr == (efdr_t *) NULL) - as_fatal ("no current file pointer"); + as_fatal (_("no current file pointer")); hash_ptr = (shash_t *) hash_find (tag_hash, tag); 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; } @@ -2064,8 +2063,7 @@ get_tag (tag, sym, basic_type) /* Add an unknown {struct, union, enum} tag. */ static void -add_unknown_tag (ptag) - tag_t *ptag; /* pointer to tag information */ +add_unknown_tag (tag_t *ptag /* pointer to tag information */) { shash_t *hash_ptr = ptag->hash_ptr; char *name = hash_ptr->string; @@ -2075,7 +2073,7 @@ add_unknown_tag (ptag) #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; @@ -2093,6 +2091,7 @@ add_unknown_tag (ptag) st_Block, sc_Info, (symbolS *) NULL, + (bfd_vma) 0, (symint_t) 0, (symint_t) 0); @@ -2100,6 +2099,7 @@ add_unknown_tag (ptag) st_End, sc_Info, (symbolS *) NULL, + (bfd_vma) 0, (symint_t) 0, (symint_t) 0); @@ -2109,22 +2109,30 @@ add_unknown_tag (ptag) } /* 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 (func) - 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 if (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"); + as_fatal (_("no current file pointer")); vp = &cur_file_ptr->procs; @@ -2133,6 +2141,9 @@ add_procedure (func) cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[vp->objects_last_page++]; + if (first_proc_ptr == (proc_t *) NULL) + first_proc_ptr = new_proc_ptr; + vp->num_allocated++; new_proc_ptr->pdr.isym = -1; @@ -2142,8 +2153,8 @@ add_procedure (func) /* Push the start of the function. */ new_proc_ptr->sym = add_ecoff_symbol ((const char *) NULL, st_Proc, sc_Text, - symbol_find_or_make (func), - (symint_t) 0, (symint_t) 0); + sym, (bfd_vma) 0, (symint_t) 0, + (symint_t) 0); ++proc_cnt; @@ -2156,22 +2167,29 @@ add_procedure (func) l->proc = new_proc_ptr; *last_lineno_ptr = noproc_lineno; while (*last_lineno_ptr != NULL) - last_lineno_ptr = &(*last_lineno_ptr)->next; + { + last_lineno = *last_lineno_ptr; + last_lineno_ptr = &last_lineno->next; + } noproc_lineno = (lineno_list_t *) NULL; } } + +symbolS * +ecoff_get_cur_proc_sym (void) +{ + return (cur_proc_ptr ? cur_proc_ptr->sym->as_sym : NULL); +} /* Add a new filename, and set up all of the file relative virtual arrays (strings, symbols, aux syms, etc.). Record where the current file structure lives. */ static void -add_file (file_name, indx) - const char *file_name; /* file name */ - int indx; +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) @@ -2182,47 +2200,72 @@ add_file (file_name, indx) 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; + as_fatal (_("fake .file after real one")); + 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 + 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_UNSPECIFIED) + debug_type = DEBUG_ECOFF; } + else if (debug_type == DEBUG_UNSPECIFIED) + debug_type = DEBUG_NONE; #ifndef NO_LISTING if (listing) listing_source_file (file_name); #endif + current_stabs_filename = file_name; + /* If we're creating stabs, then we don't actually make a new FDR. Instead, we just create a stabs symbol. */ if (stabs_seen) { (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil, - symbol_new ("L0\001", now_seg, + symbol_new (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now), - 0, ECOFF_MARK_STAB (N_SOL)); + (bfd_vma) 0, 0, ECOFF_MARK_STAB (N_SOL)); return; } first_ch = *file_name; + /* FIXME: We can't safely merge files which have line number + information (fMerge will be zero in this case). Otherwise, we + get incorrect line number debugging info. See for instance + ecoff_build_lineno, which will end up setting all file->fdr.* + fields multiple times, resulting in incorrect debug info. In + order to make this work right, all line number and symbol info + for the same source file has to be adjacent in the object file, + so that a single file descriptor can be used to point to them. + This would require maintaining file specific lists of line + numbers and symbols for each file, so that they can be merged + together (or output together) when two .file pseudo-ops are + merged into one file descriptor. */ + /* See if the file has already been created. */ for (fil_ptr = first_file; fil_ptr != (efdr_t *) NULL; 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; + if (! fake) + cur_file_ptr->fake = 0; break; } } - /* 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) @@ -2232,9 +2275,11 @@ add_file (file_name, indx) &file_desc.last->datum->file[file_desc.objects_last_page++]; *fil_ptr = init_file; - fil_ptr->file_index = indx; + fil_ptr->file_index = current_file_idx++; ++file_desc.num_allocated; + fil_ptr->fake = fake; + /* Allocate the string hash table. */ fil_ptr->str_hash = hash_new (); @@ -2245,12 +2290,12 @@ add_file (file_name, indx) (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. */ (void) add_ecoff_symbol (file_name, st_File, sc_Text, - (symbolS *) NULL, + (symbolS *) NULL, (bfd_vma) 0, (symint_t) 0, (symint_t) 0); fil_ptr->fdr.rss = 1; fil_ptr->name = &fil_ptr->strings.last->datum->byte[1]; @@ -2260,7 +2305,7 @@ add_file (file_name, indx) 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]); @@ -2270,16 +2315,33 @@ add_file (file_name, indx) &cur_file_ptr->thash_head[0]); } } + +/* This function is called when the assembler notices a preprocessor + directive switching to a new file. This will not happen in + compiler output, only in hand coded assembler. */ + +void +ecoff_new_file (const char *name, int appfile ATTRIBUTE_UNUSED) +{ + if (cur_file_ptr != NULL && filename_cmp (cur_file_ptr->name, name) == 0) + return; + add_file (name, 0, 0); + + /* This is a hand coded assembler file, so automatically turn on + debugging information. */ + if (debug_type == DEBUG_UNSPECIFIED) + debug_type = DEBUG_ECOFF; +} #ifdef ECOFF_DEBUG /* 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,"; @@ -2317,10 +2379,10 @@ sc_to_string(storage_class) /* 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,"; @@ -2354,34 +2416,32 @@ st_to_string(symbol_type) 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; if (cur_file_ptr == (efdr_t *) NULL) { - as_warn (".begin directive without a preceding .file directive"); + as_warn (_(".begin directive without a preceding .file directive")); demand_empty_rest_of_line (); return; } if (cur_proc_ptr == (proc_t *) NULL) { - as_warn (".begin directive without a preceding .ent directive"); + as_warn (_(".begin directive without a preceding .ent directive")); demand_empty_rest_of_line (); 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), - (symint_t) 0, (symint_t) 0); + (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 (); @@ -2392,8 +2452,7 @@ ecoff_directive_begin (ignore) 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; @@ -2401,32 +2460,31 @@ ecoff_directive_bend (ignore) if (cur_file_ptr == (efdr_t *) NULL) { - as_warn (".bend directive without a preceding .file directive"); + as_warn (_(".bend directive without a preceding .file directive")); demand_empty_rest_of_line (); return; } if (cur_proc_ptr == (proc_t *) NULL) { - as_warn (".bend directive without a preceding .ent directive"); + as_warn (_(".bend directive without a preceding .ent directive")); demand_empty_rest_of_line (); 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 the symbol. */ endsym = symbol_find (name); if (endsym == (symbolS *) NULL) - as_warn (".bend directive names unknown symbol"); + as_warn (_(".bend directive names unknown symbol")); else (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym, - (symint_t) 0, (symint_t) 0); + (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 (); @@ -2444,35 +2502,34 @@ static st_t coff_symbol_typ; static int coff_is_function; static char *coff_tag; static valueT coff_value; -symbolS *coff_sym_value; +static symbolS *coff_sym_value; +static bfd_vma coff_sym_addend; static int coff_inside_enumeration; /* 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; + ecoff_debugging_seen = 1; + 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 (_(".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); + free (coff_sym_name); + free (coff_tag); + + coff_sym_name = xstrdup (name); coff_type = type_info_init; coff_storage_class = sc_Nil; coff_symbol_typ = st_Nil; @@ -2480,9 +2537,10 @@ ecoff_directive_def (ignore) coff_tag = (char *) NULL; coff_value = 0; coff_sym_value = (symbolS *) NULL; + coff_sym_addend = 0; } - *input_line_pointer = name_end; + restore_line_pointer (name_end); demand_empty_rest_of_line (); } @@ -2493,15 +2551,14 @@ ecoff_directive_def (ignore) 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 (coff_sym_name == (char *) NULL) { - as_warn (".dim pseudo-op used outside of .def/.endef; ignored"); + as_warn (_(".dim pseudo-op used outside of .def/.endef; ignored")); demand_empty_rest_of_line (); return; } @@ -2516,7 +2573,7 @@ ecoff_directive_dim (ignore) { if (*input_line_pointer != '\n' && *input_line_pointer != ';') - as_warn ("Badly formed .dim directive"); + as_warn (_("badly formed .dim directive")); break; } } @@ -2529,7 +2586,7 @@ ecoff_directive_dim (ignore) { 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]; @@ -2543,14 +2600,13 @@ ecoff_directive_dim (ignore) symbol. */ void -ecoff_directive_scl (ignore) - int ignore; +ecoff_directive_scl (int ignore ATTRIBUTE_UNUSED) { long val; if (coff_sym_name == (char *) NULL) { - as_warn (".scl pseudo-op used outside of .def/.endef; ignored"); + as_warn (_(".scl pseudo-op used outside of .def/.endef; ignored")); demand_empty_rest_of_line (); return; } @@ -2568,15 +2624,14 @@ ecoff_directive_scl (ignore) 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 (coff_sym_name == (char *) NULL) { - as_warn (".size pseudo-op used outside of .def/.endef; ignored"); + as_warn (_(".size pseudo-op used outside of .def/.endef; ignored")); demand_empty_rest_of_line (); return; } @@ -2591,7 +2646,7 @@ ecoff_directive_size (ignore) { if (*input_line_pointer != '\n' && *input_line_pointer != ';') - as_warn ("Badly formed .size directive"); + as_warn (_("badly formed .size directive")); break; } } @@ -2604,7 +2659,7 @@ ecoff_directive_size (ignore) { 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]; @@ -2618,8 +2673,7 @@ ecoff_directive_size (ignore) symbol. */ void -ecoff_directive_type (ignore) - int ignore; +ecoff_directive_type (int ignore ATTRIBUTE_UNUSED) { long val; tq_t *tq_ptr; @@ -2627,7 +2681,7 @@ ecoff_directive_type (ignore) if (coff_sym_name == (char *) NULL) { - as_warn (".type pseudo-op used outside of .def/.endef; ignored"); + as_warn (_(".type pseudo-op used outside of .def/.endef; ignored")); demand_empty_rest_of_line (); return; } @@ -2638,11 +2692,15 @@ ecoff_directive_type (ignore) 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]) { - as_warn ("Too derived values in .type argument"); + /* 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"), + coff_sym_name); break; } if (ISPTR (val)) @@ -2652,7 +2710,7 @@ ecoff_directive_type (ignore) else if (ISARY (val)) *--tq_ptr = tq_Array; else - as_fatal ("Unrecognized .type argument"); + as_fatal (_("Unrecognized .type argument")); val = DECREF (val); } @@ -2664,11 +2722,11 @@ ecoff_directive_type (ignore) 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; } @@ -2683,26 +2741,23 @@ ecoff_directive_type (ignore) union or enum. */ void -ecoff_directive_tag (ignore) - int ignore; +ecoff_directive_tag (int ignore ATTRIBUTE_UNUSED) { char *name; char name_end; if (coff_sym_name == (char *) NULL) { - as_warn (".tag pseudo-op used outside of .def/.endef; ignored"); + as_warn (_(".tag pseudo-op used outside of .def/.endef; ignored")); demand_empty_rest_of_line (); return; } - name = input_line_pointer; - name_end = get_symbol_end (); + name_end = get_symbol_name (&name); - coff_tag = (char *) xmalloc ((unsigned long) (strlen (name) + 1)); - strcpy (coff_tag, name); + coff_tag = xstrdup (name); - *input_line_pointer = name_end; + (void) restore_line_pointer (name_end); demand_empty_rest_of_line (); } @@ -2711,36 +2766,31 @@ ecoff_directive_tag (ignore) 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; + if (coff_sym_name == (char *) NULL) { - as_warn (".val pseudo-op used outside of .def/.endef; ignored"); + as_warn (_(".val pseudo-op used outside of .def/.endef; ignored")); demand_empty_rest_of_line (); return; } - if (! is_name_beginner ((unsigned char) *input_line_pointer)) - coff_value = get_absolute_expression (); - else + expression (&exp); + if (exp.X_op != O_constant && exp.X_op != O_symbol) { - char *name; - char name_end; - - name = input_line_pointer; - name_end = get_symbol_end (); - - if (strcmp (name, ".") == 0) - as_warn ("`.val .' not supported"); - else - coff_sym_value = symbol_find_or_make (name); - - *input_line_pointer = name_end; + as_bad (_(".val expression is too complex")); + demand_empty_rest_of_line (); + return; + } - /* FIXME: gcc can generate address expressions here in unusual - cases (search for "obscure" in sdbout.c), although this is - very unlikely for a MIPS chip. */ + if (exp.X_op == O_constant) + coff_value = exp.X_add_number; + else + { + coff_sym_value = exp.X_add_symbol; + coff_sym_addend = exp.X_add_number; } demand_empty_rest_of_line (); @@ -2750,8 +2800,7 @@ ecoff_directive_val (ignore) debugging information for a symbol. */ void -ecoff_directive_endef (ignore) - int ignore; +ecoff_directive_endef (int ignore ATTRIBUTE_UNUSED) { char *name; symint_t indx; @@ -2761,7 +2810,7 @@ ecoff_directive_endef (ignore) if (coff_sym_name == (char *) NULL) { - as_warn (".endef pseudo-op used before .def; ignored"); + as_warn (_(".endef pseudo-op used before .def; ignored")); return; } @@ -2787,13 +2836,13 @@ ecoff_directive_endef (ignore) 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) { @@ -2808,15 +2857,17 @@ ecoff_directive_endef (ignore) coff_type.num_sizes = i + 1; for (i--; i >= 0; i--) - coff_type.sizes[i] = (coff_type.sizes[i + 1] - / coff_type.dimensions[i + 1]); + coff_type.sizes[i] = (coff_type.dimensions[i + 1] == 0 + ? 0 + : (coff_type.sizes[i + 1] + / coff_type.dimensions[i + 1])); } } 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; } @@ -2834,7 +2885,7 @@ ecoff_directive_endef (ignore) { if (coff_tag == (char *) NULL) { - as_warn ("No tag specified for %s", name); + as_warn (_("no tag specified for %s"), name); return; } @@ -2861,12 +2912,12 @@ ecoff_directive_endef (ignore) 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 @@ -2876,8 +2927,8 @@ ecoff_directive_endef (ignore) 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; @@ -2886,10 +2937,10 @@ ecoff_directive_endef (ignore) 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; @@ -2902,6 +2953,7 @@ ecoff_directive_endef (ignore) coff_symbol_typ, coff_storage_class, coff_sym_value, + coff_sym_addend, (symint_t) coff_value, indx); @@ -2927,36 +2979,32 @@ ecoff_directive_endef (ignore) /* 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) { - as_warn (".end directive without a preceding .file directive"); + as_warn (_(".end directive without a preceding .file directive")); demand_empty_rest_of_line (); return; } if (cur_proc_ptr == (proc_t *) NULL) { - as_warn (".end directive without a preceding .ent directive"); + as_warn (_(".end directive without a preceding .ent directive")); demand_empty_rest_of_line (); return; } - name = input_line_pointer; - name_end = get_symbol_end (); - - ch = *name; - if (! is_name_beginner (ch)) + name_end = get_symbol_name (&name); + + if (name == input_line_pointer) { - as_warn (".end directive has no name"); - *input_line_pointer = name_end; + as_warn (_(".end directive has no name")); + (void) restore_line_pointer (name_end); demand_empty_rest_of_line (); return; } @@ -2967,55 +3015,55 @@ ecoff_directive_end (ignore) symbol. */ ent = symbol_find (name); if (ent == (symbolS *) NULL) - as_warn (".end directive names unknown symbol"); + 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, + symbol_new (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now), - (symint_t) 0, (symint_t) 0); + (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 (); } /* Parse .ent directives. */ void -ecoff_directive_ent (ignore) - int ignore; +ecoff_directive_ent (int aent) { char *name; char name_end; - register int ch; if (cur_file_ptr == (efdr_t *) NULL) - add_file ((const char *) NULL, 0); + 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"); + 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); - ch = *name; - if (! is_name_beginner (ch)) + 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 @@ -3027,17 +3075,40 @@ ecoff_directive_ent (ignore) ++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 (int ignore ATTRIBUTE_UNUSED) +{ + char *name; + int c; + symbolS *symbolp; + valueT size; + + c = get_symbol_name (&name); + symbolp = symbol_find_or_make (name); + (void) restore_line_pointer (c); + + S_SET_EXTERNAL (symbolp); + + if (*input_line_pointer == ',') + ++input_line_pointer; + size = get_absolute_expression (); + + symbol_get_obj (symbolp)->ecoff_extern_size = size; +} + /* Parse .file directives. */ void -ecoff_directive_file (ignore) - int ignore; +ecoff_directive_file (int ignore ATTRIBUTE_UNUSED) { int indx; char *name; @@ -3045,7 +3116,7 @@ ecoff_directive_file (ignore) 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; } @@ -3055,7 +3126,7 @@ ecoff_directive_file (ignore) /* FIXME: we don't have to save the name here. */ name = demand_copy_C_string (&len); - add_file (name, indx - 1); + add_file (name, indx - 1, 0); demand_empty_rest_of_line (); } @@ -3063,21 +3134,20 @@ ecoff_directive_file (ignore) /* Parse .fmask directives. */ void -ecoff_directive_fmask (ignore) - int ignore; +ecoff_directive_fmask (int ignore ATTRIBUTE_UNUSED) { long val; if (cur_proc_ptr == (proc_t *) NULL) { - as_warn (".fmask outside of .ent"); + as_warn (_(".fmask outside of .ent")); demand_empty_rest_of_line (); return; } 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; @@ -3092,14 +3162,13 @@ ecoff_directive_fmask (ignore) /* Parse .frame directives. */ void -ecoff_directive_frame (ignore) - int ignore; +ecoff_directive_frame (int ignore ATTRIBUTE_UNUSED) { long val; if (cur_proc_ptr == (proc_t *) NULL) { - as_warn (".frame outside of .ent"); + as_warn (_(".frame outside of .ent")); demand_empty_rest_of_line (); return; } @@ -3110,7 +3179,7 @@ ecoff_directive_frame (ignore) 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; @@ -3120,27 +3189,29 @@ ecoff_directive_frame (ignore) cur_proc_ptr->pdr.pcreg = tc_get_register (0); - demand_empty_rest_of_line (); + /* 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); } /* Parse .mask directives. */ void -ecoff_directive_mask (ignore) - int ignore; +ecoff_directive_mask (int ignore ATTRIBUTE_UNUSED) { long val; if (cur_proc_ptr == (proc_t *) NULL) { - as_warn (".mask outside of .ent"); + as_warn (_(".mask outside of .ent")); demand_empty_rest_of_line (); return; } 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; @@ -3155,22 +3226,21 @@ ecoff_directive_mask (ignore) /* Parse .loc directives. */ void -ecoff_directive_loc (ignore) - int ignore; +ecoff_directive_loc (int ignore ATTRIBUTE_UNUSED) { lineno_list_t *list; symint_t lineno; if (cur_file_ptr == (efdr_t *) NULL) { - as_warn (".loc before .file"); + as_warn (_(".loc before .file")); demand_empty_rest_of_line (); return; } if (now_seg != text_section) { - as_warn (".loc outside of .text"); + as_warn (_(".loc outside of .text")); demand_empty_rest_of_line (); return; } @@ -3192,10 +3262,10 @@ ecoff_directive_loc (ignore) if (stabs_seen) { (void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text, - symbol_new ("L0\001", now_seg, + symbol_new (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now), - 0, lineno); + (bfd_vma) 0, 0, lineno); return; } @@ -3208,6 +3278,9 @@ ecoff_directive_loc (ignore) list->paddr = frag_now_fix (); list->lineno = lineno; + /* We don't want to merge files which have line numbers. */ + cur_file_ptr->fdr.fMerge = 0; + /* A .loc directive will sometimes appear before a .ent directive, which means that cur_proc_ptr will be NULL here. Arrange to patch this up. */ @@ -3222,26 +3295,91 @@ ecoff_directive_loc (ignore) } else { + last_lineno = list; *last_lineno_ptr = list; last_lineno_ptr = &list->next; } } + +/* The MIPS assembler sometimes inserts nop instructions in the + instruction stream. When this happens, we must patch up the .loc + information so that it points to the instruction after the nop. */ + +void +ecoff_fix_loc (fragS *old_frag, unsigned long old_frag_offset) +{ + if (last_lineno != NULL + && last_lineno->frag == old_frag + && last_lineno->paddr == old_frag_offset) + { + last_lineno->frag = frag_now; + last_lineno->paddr = frag_now_fix (); + } +} /* 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 symbol. */ stabs_seen = 1; - (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo, + (void) add_ecoff_symbol (stabs_symbol, st_Nil, sc_Info, (symbolS *) NULL, - (symint_t) -1, ECOFF_MARK_STAB (0)); + (bfd_vma) 0, (symint_t) -1, + ECOFF_MARK_STAB (0)); + } +} + +/* Parse .weakext directives. */ +#ifndef TC_MIPS +/* For TC_MIPS use the version in tc-mips.c. */ +void +ecoff_directive_weakext (int ignore ATTRIBUTE_UNUSED) +{ + char *name; + int c; + symbolS *symbolP; + expressionS exp; + + c = get_symbol_name (&name); + symbolP = symbol_find_or_make (name); + (void) restore_line_pointer (c); + + SKIP_WHITESPACE (); + + if (*input_line_pointer == ',') + { + if (S_IS_DEFINED (symbolP)) + { + as_bad (_("symbol `%s' is already defined"), + S_GET_NAME (symbolP)); + ignore_rest_of_line (); + return; + } + + ++input_line_pointer; + SKIP_WHITESPACE (); + if (! is_end_of_line[(unsigned char) *input_line_pointer]) + { + expression (&exp); + if (exp.X_op != O_symbol) + { + as_bad (_("bad .weakext directive")); + ignore_rest_of_line (); + return; + } + symbol_set_value_expression (symbolP, &exp); + } } + + S_SET_WEAK (symbolP); + + demand_empty_rest_of_line (); } +#endif /* not TC_MIPS */ /* Handle .stabs directives. The actual parsing routine is done by a generic routine. This routine is called via OBJ_PROCESS_STAB. @@ -3276,24 +3414,28 @@ mark_stabs (ignore) value a numeric value or an address. */ void -ecoff_stab (what, string, type, other, desc) - 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; symint_t value; + bfd_vma addend; st_t st; sc_t sc; symint_t indx; + localsym_t *hold = NULL; + + ecoff_debugging_seen = 1; /* We don't handle .stabd. */ if (what != 's' && what != 'n') { - as_bad (".stab%c is not supported", what); + as_bad (_(".stab%c is not supported"), what); return; } @@ -3303,12 +3445,12 @@ ecoff_stab (what, string, type, other, desc) /* We ignore the other field. */ if (other != 0) - as_warn (".stab%c: ignoring non-zero other field", what); + as_warn (_(".stab%c: ignoring non-zero other field"), what); /* Make sure we have a current file. */ if (cur_file_ptr == (efdr_t *) NULL) { - add_file ((const char *) NULL, 0); + add_file ((const char *) NULL, 0, 1); save_file_ptr = cur_file_ptr; } @@ -3337,18 +3479,17 @@ ecoff_stab (what, string, type, other, desc) 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; } - 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; st = st_Label; sc = sc_Text; indx = desc; @@ -3359,8 +3500,8 @@ ecoff_stab (what, string, type, other, desc) if (listing && (type == N_SO || type == N_SOL)) listing_source_file (string); #endif - - if (isdigit (*input_line_pointer) + + if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-' || *input_line_pointer == '+') { @@ -3368,53 +3509,104 @@ ecoff_stab (what, string, type, other, desc) sc = sc_Nil; sym = (symbolS *) NULL; value = get_absolute_expression (); + addend = 0; } 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 { - char *name; - char name_end; - - name = input_line_pointer; - name_end = get_symbol_end (); - - sym = symbol_find_or_make (name); + expressionS exp; sc = sc_Nil; st = st_Nil; - value = 0; - *input_line_pointer = name_end; - if (name_end == '+' || name_end == '-') + expression (&exp); + if (exp.X_op == O_constant) + { + sym = NULL; + value = exp.X_add_number; + addend = 0; + } + else if (exp.X_op == O_symbol) + { + sym = exp.X_add_symbol; + value = 0; + addend = exp.X_add_number; + } + else { - ++input_line_pointer; - value = get_absolute_expression (); - if (name_end == '-') - value = - value; + sym = make_expr_symbol (&exp); + value = 0; + addend = 0; } } indx = ECOFF_MARK_STAB (type); } - (void) add_ecoff_symbol (string, st, sc, sym, value, indx); + /* Don't store the stabs symbol we are creating as the type of the + ECOFF symbol. We want to compute the type of the ECOFF symbol + independently. */ + if (sym != (symbolS *) NULL) + hold = symbol_get_obj (sym)->ecoff_symbol; + + (void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx); + + if (sym != (symbolS *) NULL) + symbol_get_obj (sym)->ecoff_symbol = hold; /* Restore normal file type. */ cur_file_ptr = save_file_ptr; } +/* Frob an ECOFF symbol. Small common symbols go into a special + .scommon section rather than bfd_com_section. */ + +void +ecoff_frob_symbol (symbolS *sym) +{ + if (S_IS_COMMON (sym) + && S_GET_VALUE (sym) > 0 + && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput)) + { + static asection scom_section; + static asymbol scom_symbol; + + /* We must construct a fake section similar to bfd_com_section + but with the name .scommon. */ + if (scom_section.name == NULL) + { + 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_ptr->symbol; + scom_symbol.name = ".scommon"; + scom_symbol.section = &scom_section; + } + S_SET_SEGMENT (sym, &scom_section); + } + + /* Double check weak symbols. */ + if (S_IS_WEAK (sym)) + { + if (S_IS_COMMON (sym)) + 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; @@ -3424,7 +3616,7 @@ ecoff_add_bytes (buf, bufend, bufptr, need) 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; } @@ -3433,12 +3625,11 @@ ecoff_add_bytes (buf, bufend, bufptr, need) 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; @@ -3448,7 +3639,7 @@ ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr) 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; @@ -3462,21 +3653,22 @@ ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr) /* 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; + lineno_list_t *l; lineno_list_t *last; efdr_t *file; proc_t *proc; unsigned long c; long iline; long totcount; + lineno_list_t first; + lineno_list_t *local_first_lineno = first_lineno; if (linecntptr != (long *) NULL) *linecntptr = 0; @@ -3489,26 +3681,61 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) c = offset; iline = 0; totcount = 0; - for (l = first_lineno; l != (lineno_list_t *) NULL; l = l->next) + + /* 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. + + Don't do this for ECOFF assembly source line numbers. They work + without this extra attention. */ + if (debug_type != DEBUG_ECOFF + && first_proc_ptr != (proc_t *) NULL + && local_first_lineno != (lineno_list_t *) NULL + && ((S_GET_VALUE (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; + first.proc = local_first_lineno->proc; + first.frag = &zero_address_frag; + first.paddr = 0; + first.lineno = 0; + + first.next = local_first_lineno; + local_first_lineno = &first; + } + + for (l = local_first_lineno; l != (lineno_list_t *) NULL; l = l->next) { long count; 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) - count = 0; - else + { + /* We want a count of zero, but it will be decremented + before it is used. */ + count = 1; + } + else if (l->next->frag->fr_address + l->next->paddr + > l->frag->fr_address + l->paddr) { count = ((l->next->frag->fr_address + l->next->paddr - (l->frag->fr_address + l->paddr)) >> 2); - if (count <= 0) - { - /* Don't change last, so we still get the right delta. */ - continue; - } + } + else + { + /* Don't change last, so we still get the right delta. */ + continue; } if (l->file != file || l->proc != proc) @@ -3518,8 +3745,6 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) if (l->file != file && file != (efdr_t *) NULL) { file->fdr.cbLine = c - file->fdr.cbLineOffset; - /* The cline field is ill-documented. This is a guess - at the right value. */ file->fdr.cline = totcount + count; if (linecntptr != (long *) NULL) *linecntptr += totcount + count; @@ -3528,8 +3753,14 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) if (l->file != file) { + efdr_t *last_file = file; + file = l->file; - file->fdr.ilineBase = iline; + if (last_file != (efdr_t *) NULL) + file->fdr.ilineBase + = last_file->fdr.ilineBase + last_file->fdr.cline; + else + file->fdr.ilineBase = 0; file->fdr.cbLineOffset = c; } if (l->proc != proc) @@ -3539,14 +3770,12 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) { proc->pdr.lnLow = l->lineno; proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset; - /* The iline field is ill-documented. This is a - guess at the right value. */ proc->pdr.iline = totcount; } } last = (lineno_list_t *) NULL; - } + } totcount += count; @@ -3654,14 +3883,13 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) /* 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 *, void *) = backend->swap_sym_out; char *sym_out; long isym; @@ -3729,11 +3957,11 @@ ecoff_build_symbols (backend, buf, bufend, offset) 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) { @@ -3743,26 +3971,29 @@ ecoff_build_symbols (backend, buf, bufend, offset) begin_sym = sym_ptr->proc_ptr->sym->as_sym; if (S_GET_SEGMENT (as_sym) != S_GET_SEGMENT (begin_sym)) - as_warn (".begin/.bend in different segments"); + as_warn (_(".begin/.bend in different segments")); sym_ptr->ecoff_sym.asym.value = S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym); } 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); /* Set st_Proc to st_StaticProc for local functions. */ if (sym_ptr->ecoff_sym.asym.st == st_Proc && S_IS_DEFINED (as_sym) - && ! S_IS_EXTERNAL (as_sym)) + && ! S_IS_EXTERNAL (as_sym) + && ! S_IS_WEAK (as_sym)) 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 @@ -3778,23 +4009,38 @@ ecoff_build_symbols (backend, buf, bufend, offset) seg = S_GET_SEGMENT (as_sym); segname = segment_name (seg); - if (S_IS_EXTERNAL (as_sym) - || ! S_IS_DEFINED (as_sym)) - st = st_Global; + if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym) + && (S_IS_EXTERNAL (as_sym) + || S_IS_WEAK (as_sym) + || ! S_IS_DEFINED (as_sym))) + { + if ((symbol_get_bfdsym (as_sym)->flags + & BSF_FUNCTION) != 0) + st = st_Proc; + else + st = st_Global; + } else if (seg == text_section) st = st_Label; else st = st_Static; - if (! S_IS_DEFINED (as_sym) - || as_sym->ecoff_undefined) + if (! S_IS_DEFINED (as_sym)) { - if (S_GET_VALUE (as_sym) > 0 - && (S_GET_VALUE (as_sym) - <= bfd_get_gp_size (stdoutput))) - sc = sc_SUndefined; - else + 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 = s; + } +#ifdef S_SET_SIZE + S_SET_SIZE (as_sym, s); +#endif } else if (S_IS_COMMON (as_sym)) { @@ -3818,35 +4064,46 @@ ecoff_build_symbols (backend, buf, bufend, offset) 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 - abort (); + { + /* This must be a user named section. + This is not possible in ECOFF, but it + is in ELF. */ + sc = sc_Data; + } sym_ptr->ecoff_sym.asym.st = (int) st; sym_ptr->ecoff_sym.asym.sc = (int) sc; } /* 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)) && sym_ptr->proc_ptr == (proc_t *) NULL && sym_ptr->ecoff_sym.asym.st != (int) st_Nil && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)) local = 0; + /* This is just an external symbol if it is a + 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 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, @@ -3870,7 +4127,7 @@ ecoff_build_symbols (backend, buf, bufend, offset) 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) { @@ -3891,10 +4148,10 @@ ecoff_build_symbols (backend, buf, bufend, offset) } /* 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) { @@ -3902,10 +4159,20 @@ ecoff_build_symbols (backend, buf, bufend, offset) know (begin_ptr->as_sym != (symbolS *) NULL); if (S_GET_SEGMENT (as_sym) != S_GET_SEGMENT (begin_ptr->as_sym)) - as_warn (".begin/.bend in different segments"); + as_warn (_(".begin/.bend in different segments")); sym_ptr->ecoff_sym.asym.value = (S_GET_VALUE (as_sym) - S_GET_VALUE (begin_ptr->as_sym)); + + /* If the size is odd, this is probably a + mips16 function; force it to be even. */ + if ((sym_ptr->ecoff_sym.asym.value & 1) != 0) + ++sym_ptr->ecoff_sym.asym.value; + +#ifdef S_SET_SIZE + S_SET_SIZE (begin_ptr->as_sym, + sym_ptr->ecoff_sym.asym.value); +#endif } else if (begin_type == st_Block && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info) @@ -3917,7 +4184,7 @@ ecoff_build_symbols (backend, buf, bufend, offset) begin_sym = sym_ptr->proc_ptr->sym->as_sym; if (S_GET_SEGMENT (as_sym) != S_GET_SEGMENT (begin_sym)) - as_warn (".begin/.bend in different segments"); + as_warn (_(".begin/.bend in different segments")); sym_ptr->ecoff_sym.asym.value = S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym); } @@ -3934,7 +4201,7 @@ ecoff_build_symbols (backend, buf, bufend, offset) 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); @@ -3954,15 +4221,19 @@ ecoff_build_symbols (backend, buf, bufend, offset) /* Record the local symbol index and file number in case this is an external symbol. Note that this destroys the asym.index field. */ - if (as_sym != (symbolS *) NULL) + if (as_sym != (symbolS *) NULL + && 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) - { - know (local); - sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1; - } + if ((sym_ptr->ecoff_sym.asym.st == st_Proc + || sym_ptr->ecoff_sym.asym.st == st_StaticProc) + && local) + sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1; sym_ptr->ecoff_sym.ifd = fil_ptr->file_index; + + /* Don't try to merge an FDR which has an + external symbol attached to it. */ + if (S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym)) + fil_ptr->fdr.fMerge = 0; } } } @@ -3976,23 +4247,20 @@ ecoff_build_symbols (backend, buf, bufend, offset) /* 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 *, void *) = backend->swap_pdr_out; char *pdr_out; - int first_fil; long iproc; vlinks_t *file_link; pdr_out = *buf + offset; - - first_fil = 1; + iproc = 0; /* The procedures are stored by file. */ @@ -4038,18 +4306,18 @@ ecoff_build_procs (backend, buf, bufend, offset) 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) { - if (first_fil) - first_fil = 0; - else - fil_ptr->fdr.adr = adr; + /* 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. */ + 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); @@ -4068,21 +4336,20 @@ ecoff_build_procs (backend, buf, bufend, offset) /* 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; long iaux; vlinks_t *file_link; - bigendian = stdoutput->xvec->header_byteorder_big_p; + bigendian = bfd_big_endian (stdoutput); aux_out = (union aux_ext *) (*buf + offset); - + iaux = 0; /* The aux entries are stored by file. */ @@ -4122,7 +4389,8 @@ ecoff_build_aux (backend, buf, bufend, offset) 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, @@ -4130,12 +4398,14 @@ ecoff_build_aux (backend, buf, bufend, offset) switch (aux_ptr->type) { case aux_tir: - ecoff_swap_tir_out (bigendian, &aux_ptr->data.ti, - &aux_out->a_ti); + (*backend->swap_tir_out) (bigendian, + &aux_ptr->data.ti, + &aux_out->a_ti); break; case aux_rndx: - ecoff_swap_rndx_out (bigendian, &aux_ptr->data.rndx, - &aux_out->a_rndx); + (*backend->swap_rndx_out) (bigendian, + &aux_ptr->data.rndx, + &aux_out->a_rndx); break; case aux_dnLow: AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow, @@ -4180,11 +4450,10 @@ ecoff_build_aux (backend, buf, bufend, offset) 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; @@ -4205,7 +4474,7 @@ ecoff_build_strings (buf, bufend, offset, vp) 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); @@ -4219,11 +4488,10 @@ ecoff_build_strings (buf, bufend, offset, vp) /* 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; @@ -4263,14 +4531,13 @@ ecoff_build_ss (backend, buf, bufend, offset) /* 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 *, void *) = backend->swap_fdr_out; long ifile; char *fdr_out; @@ -4296,7 +4563,7 @@ ecoff_build_fdr (backend, buf, bufend, offset) 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); @@ -4308,65 +4575,44 @@ ecoff_build_fdr (backend, buf, bufend, offset) return offset + ifile * external_fdr_size; } -/* Swap out the external symbols. These are the symbols that the - machine independent code has put in the symtab for the BFD. */ +/* Set up the external symbols. These are supposed to be handled by + the backend. This routine just gets the right information and + calls a backend function to deal with it. */ -static unsigned long -ecoff_build_ext (backend, buf, bufend, offset, ext_strings, ext_str_hash) - const struct ecoff_debug_swap *backend; - char **buf; - char **bufend; - unsigned long offset; - varray_t *ext_strings; - struct hash_control *ext_str_hash; +static void +ecoff_setup_ext (void) { - const bfd_size_type external_ext_size = backend->external_ext_size; - void (* const swap_ext_out) PARAMS ((bfd *, const EXTR *, PTR)) - = backend->swap_ext_out; - register symbolS *sym; - char *ext_out; - long iext; - - ext_out = *buf + offset; - iext = 0; + 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. */ if (! S_IS_EXTERNAL (sym) + && ! 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; } - sym->ecoff_symbol->ecoff_sym.asym.iss = - add_string (ext_strings, ext_str_hash, S_GET_NAME (sym), - (shash_t **) NULL); - if (*bufend - ext_out < external_ext_size) - ext_out = ecoff_add_bytes (buf, bufend, ext_out, external_ext_size); - (*swap_ext_out) (stdoutput, &sym->ecoff_symbol->ecoff_sym, ext_out); -#ifdef obj_set_sym_index - obj_set_sym_index (as_sym->bsym, iext); -#endif - ext_out += external_ext_size; - ++iext; + obj_ecoff_set_ext (sym, &symbol_get_obj (sym)->ecoff_symbol->ecoff_sym); } - - return offset + iext * external_ext_size; } -/* Build the ECOFF dbeugging information. */ +/* 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; @@ -4374,21 +4620,15 @@ ecoff_build_debug (hdr, bufp, backend) 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; unsigned long offset; - char *extbuf; - char *extbufend; - unsigned long extoffset; - varray_t ext_strings; - static varray_t init_ext_strings = INIT_VARRAY (char); - struct hash_control *ext_str_hash; /* Make sure we have a file. */ if (first_file == (efdr_t *) NULL) - add_file ((const char *) NULL, 0); + add_file ((const char *) NULL, 0, 1); /* Handle any top level tags. */ for (ptag = top_tag_head->first_tag; @@ -4412,14 +4652,14 @@ ecoff_build_debug (hdr, bufp, backend) 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, - S_GET_VALUE (sym), indexNil); + (bfd_vma) 0, S_GET_VALUE (sym), indexNil); } cur_proc_ptr = hold_proc_ptr; cur_file_ptr = hold_file_ptr; @@ -4433,25 +4673,28 @@ ecoff_build_debug (hdr, bufp, backend) fil_ptr = fil_ptr->next_file) { cur_file_ptr = fil_ptr; - while (cur_file_ptr->cur_scope->prev != (scope_t *) NULL) + while (cur_file_ptr->cur_scope != (scope_t *) NULL + && cur_file_ptr->cur_scope->prev != (scope_t *) NULL) { cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev; - if (! end_warning) + 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; } } - (void) add_ecoff_symbol ((const char *) NULL, - st_End, sc_Text, - (symbolS *) NULL, - (symint_t) 0, - (symint_t) 0); + if (cur_file_ptr->cur_scope != (scope_t *) NULL) + (void) add_ecoff_symbol ((const char *) NULL, + st_End, sc_Text, + (symbolS *) NULL, + (bfd_vma) 0, + (symint_t) 0, + (symint_t) 0); } /* Build the symbolic information. */ offset = 0; - buf = xmalloc (PAGE_SIZE); + buf = XNEWVEC (char, PAGE_SIZE); bufend = buf + PAGE_SIZE; /* Build the line number information. */ @@ -4469,7 +4712,7 @@ ecoff_build_debug (hdr, bufp, backend) 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; @@ -4497,24 +4740,6 @@ ecoff_build_debug (hdr, bufp, backend) offset = ecoff_build_ss (backend, &buf, &bufend, offset); hdr->issMax = offset - hdr->cbSsOffset; - /* Build the external symbols and external strings. We build these - now because we want to copy out the external strings now. We - copy out the external symbol information down below. */ - extbuf = xmalloc (PAGE_SIZE); - extbufend = extbuf + PAGE_SIZE; - ext_strings = init_ext_strings; - ext_str_hash = hash_new (); - extoffset = ecoff_build_ext (backend, &extbuf, &extbufend, - (unsigned long) 0, &ext_strings, - ext_str_hash); - - /* Copy out the external strings. */ - hdr->cbSsExtOffset = offset; - offset += ecoff_build_strings (&buf, &bufend, offset, &ext_strings); - offset = ecoff_padding_adjust (backend, &buf, &bufend, offset, - (char **) NULL); - hdr->issExtMax = offset - hdr->cbSsExtOffset; - /* We don't use relative file descriptors. */ hdr->crfd = 0; hdr->cbRfdOffset = 0; @@ -4524,19 +4749,23 @@ ecoff_build_debug (hdr, bufp, backend) offset = ecoff_build_fdr (backend, &buf, &bufend, offset); hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size; - /* Copy out the external symbols. */ - hdr->cbExtOffset = offset; - if (bufend - (buf + offset) < extoffset) - (void) ecoff_add_bytes (&buf, &bufend, buf + offset, extoffset); - memcpy (buf + offset, extbuf, extoffset); - offset += extoffset; - hdr->iextMax = (offset - hdr->cbExtOffset) / backend->external_ext_size; + /* Set up the external symbols, which are handled by the BFD back + end. */ + hdr->issExtMax = 0; + hdr->cbSsExtOffset = 0; + hdr->iextMax = 0; + hdr->cbExtOffset = 0; + ecoff_setup_ext (); know ((offset & (backend->debug_align - 1)) == 0); - hdr->magic = backend->sym_magic; - /* FIXME: what should hdr->vstamp be? */ + /* FIXME: This value should be determined from the .verstamp directive, + with reasonable defaults in config files. */ +#ifdef TC_ALPHA + hdr->vstamp = 0x030b; +#else hdr->vstamp = 0x020b; +#endif *bufp = buf; return offset; @@ -4546,11 +4775,10 @@ ecoff_build_debug (hdr, bufp, backend) #ifndef MALLOC_CHECK -static page_t * -allocate_cluster (npages) - unsigned long npages; +static page_type * +allocate_cluster (unsigned long npages) { - register page_t *value = (page_t *) xmalloc (npages * PAGE_USIZE); + page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE); #ifdef ECOFF_DEBUG if (debug > 3) @@ -4562,16 +4790,15 @@ allocate_cluster (npages) return value; } - -static page_t *cluster_ptr = NULL; +static page_type *cluster_ptr = NULL; static unsigned long pages_left = 0; #endif /* MALLOC_CHECK */ /* Allocate one page (which is initialized to 0). */ -static page_t * -allocate_page () +static page_type * +allocate_page (void) { #ifndef MALLOC_CHECK @@ -4584,53 +4811,53 @@ allocate_page () pages_left--; return cluster_ptr++; -#else /* MALLOC_CHECK */ +#else /* MALLOC_CHECK */ - page_t *ptr; + page_type *ptr; ptr = xmalloc (PAGE_USIZE); memset (ptr, 0, PAGE_USIZE); return ptr; -#endif /* MALLOC_CHECK */ +#endif /* MALLOC_CHECK */ } /* Allocate scoping information. */ static scope_t * -allocate_scope () +allocate_scope (void) { - register scope_t *ptr; + 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_t *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) { unallocated = PAGE_SIZE / sizeof (scope_t); - alloc_counts[(int)alloc_type_scope].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_scope].total_pages++; + alloc_counts[(int) alloc_type_scope].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_scope].total_pages++; } ptr = &cur_page->scope[--unallocated]; - alloc_counts[(int)alloc_type_scope].unallocated = unallocated; + alloc_counts[(int) alloc_type_scope].unallocated = unallocated; } #else - ptr = (scope_t *) xmalloc (sizeof (scope_t)); + ptr = XNEW (scope_t); #endif - alloc_counts[(int)alloc_type_scope].total_alloc++; + alloc_counts[(int) alloc_type_scope].total_alloc++; *ptr = initial_scope; return ptr; } @@ -4638,49 +4865,48 @@ allocate_scope () /* Free scoping information. */ static void -free_scope (ptr) - scope_t *ptr; +free_scope (scope_t *ptr) { - alloc_counts[(int)alloc_type_scope].total_free++; + alloc_counts[(int) alloc_type_scope].total_free++; #ifndef MALLOC_CHECK - ptr->free = alloc_counts[(int)alloc_type_scope].free_list.f_scope; - alloc_counts[(int)alloc_type_scope].free_list.f_scope = ptr; + ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope; + alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr; #else - free ((PTR) ptr); + free ((void *) ptr); #endif } /* Allocate links for pages in a virtual array. */ static vlinks_t * -allocate_vlinks () +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_t *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) { unallocated = PAGE_SIZE / sizeof (vlinks_t); - alloc_counts[(int)alloc_type_vlinks].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_vlinks].total_pages++; + alloc_counts[(int) alloc_type_vlinks].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_vlinks].total_pages++; } ptr = &cur_page->vlinks[--unallocated]; - alloc_counts[(int)alloc_type_vlinks].unallocated = unallocated; + alloc_counts[(int) alloc_type_vlinks].unallocated = unallocated; #else - ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t)); + ptr = XNEW (vlinks_t); #endif - alloc_counts[(int)alloc_type_vlinks].total_alloc++; + alloc_counts[(int) alloc_type_vlinks].total_alloc++; *ptr = initial_vlinks; return ptr; } @@ -4688,33 +4914,33 @@ allocate_vlinks () /* Allocate string hash buckets. */ static shash_t * -allocate_shash () +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_t *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) { unallocated = PAGE_SIZE / sizeof (shash_t); - alloc_counts[(int)alloc_type_shash].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_shash].total_pages++; + alloc_counts[(int) alloc_type_shash].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_shash].total_pages++; } ptr = &cur_page->shash[--unallocated]; - alloc_counts[(int)alloc_type_shash].unallocated = unallocated; + alloc_counts[(int) alloc_type_shash].unallocated = unallocated; #else - ptr = (shash_t *) xmalloc (sizeof (shash_t)); + ptr = XNEW (shash_t); #endif - alloc_counts[(int)alloc_type_shash].total_alloc++; + alloc_counts[(int) alloc_type_shash].total_alloc++; *ptr = initial_shash; return ptr; } @@ -4722,33 +4948,33 @@ allocate_shash () /* Allocate type hash buckets. */ static thash_t * -allocate_thash () +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_t *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) { unallocated = PAGE_SIZE / sizeof (thash_t); - alloc_counts[(int)alloc_type_thash].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_thash].total_pages++; + alloc_counts[(int) alloc_type_thash].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_thash].total_pages++; } ptr = &cur_page->thash[--unallocated]; - alloc_counts[(int)alloc_type_thash].unallocated = unallocated; + alloc_counts[(int) alloc_type_thash].unallocated = unallocated; #else - ptr = (thash_t *) xmalloc (sizeof (thash_t)); + ptr = XNEW (thash_t); #endif - alloc_counts[(int)alloc_type_thash].total_alloc++; + alloc_counts[(int) alloc_type_thash].total_alloc++; *ptr = initial_thash; return ptr; } @@ -4756,39 +4982,39 @@ allocate_thash () /* Allocate structure, union, or enum tag information. */ static tag_t * -allocate_tag () +allocate_tag (void) { - register tag_t *ptr; + 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_t *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) { unallocated = PAGE_SIZE / sizeof (tag_t); - alloc_counts[(int)alloc_type_tag].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_tag].total_pages++; + alloc_counts[(int) alloc_type_tag].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_tag].total_pages++; } ptr = &cur_page->tag[--unallocated]; - alloc_counts[(int)alloc_type_tag].unallocated = unallocated; + alloc_counts[(int) alloc_type_tag].unallocated = unallocated; } #else - ptr = (tag_t *) xmalloc (sizeof (tag_t)); + ptr = XNEW (tag_t); #endif - alloc_counts[(int)alloc_type_tag].total_alloc++; + alloc_counts[(int) alloc_type_tag].total_alloc++; *ptr = initial_tag; return ptr; } @@ -4796,14 +5022,13 @@ allocate_tag () /* Free scoping information. */ static void -free_tag (ptr) - tag_t *ptr; +free_tag (tag_t *ptr) { - alloc_counts[(int)alloc_type_tag].total_free++; + alloc_counts[(int) alloc_type_tag].total_free++; #ifndef MALLOC_CHECK - ptr->free = alloc_counts[(int)alloc_type_tag].free_list.f_tag; - alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr; + ptr->free = alloc_counts[(int) alloc_type_tag].free_list.f_tag; + alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr; #else free ((PTR_T) ptr); #endif @@ -4812,33 +5037,33 @@ free_tag (ptr) /* Allocate forward reference to a yet unknown tag. */ static forward_t * -allocate_forward () +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_t *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) { unallocated = PAGE_SIZE / sizeof (forward_t); - alloc_counts[(int)alloc_type_forward].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_forward].total_pages++; + alloc_counts[(int) alloc_type_forward].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_forward].total_pages++; } ptr = &cur_page->forward[--unallocated]; - alloc_counts[(int)alloc_type_forward].unallocated = unallocated; + alloc_counts[(int) alloc_type_forward].unallocated = unallocated; #else - ptr = (forward_t *) xmalloc (sizeof (forward_t)); + ptr = XNEW (forward_t); #endif - alloc_counts[(int)alloc_type_forward].total_alloc++; + alloc_counts[(int) alloc_type_forward].total_alloc++; *ptr = initial_forward; return ptr; } @@ -4846,39 +5071,39 @@ allocate_forward () /* Allocate head of type hash list. */ static thead_t * -allocate_thead () +allocate_thead (void) { - register thead_t *ptr; + 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_t *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) { unallocated = PAGE_SIZE / sizeof (thead_t); - alloc_counts[(int)alloc_type_thead].cur_page = cur_page = allocate_page (); - alloc_counts[(int)alloc_type_thead].total_pages++; + alloc_counts[(int) alloc_type_thead].cur_page = cur_page = allocate_page (); + alloc_counts[(int) alloc_type_thead].total_pages++; } ptr = &cur_page->thead[--unallocated]; - alloc_counts[(int)alloc_type_thead].unallocated = unallocated; + alloc_counts[(int) alloc_type_thead].unallocated = unallocated; } #else - ptr = (thead_t *) xmalloc (sizeof (thead_t)); + ptr = XNEW (thead_t); #endif - alloc_counts[(int)alloc_type_thead].total_alloc++; + alloc_counts[(int) alloc_type_thead].total_alloc++; *ptr = initial_thead; return ptr; } @@ -4886,49 +5111,122 @@ allocate_thead () /* Free scoping information. */ static void -free_thead (ptr) - thead_t *ptr; +free_thead (thead_t *ptr) { - alloc_counts[(int)alloc_type_thead].total_free++; + alloc_counts[(int) alloc_type_thead].total_free++; #ifndef MALLOC_CHECK - ptr->free = (thead_t *) alloc_counts[(int)alloc_type_thead].free_list.f_thead; - alloc_counts[(int)alloc_type_thead].free_list.f_thead = ptr; + ptr->free = (thead_t *) alloc_counts[(int) alloc_type_thead].free_list.f_thead; + alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr; #else free ((PTR_T) ptr); #endif } static lineno_list_t * -allocate_lineno_list () +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_t *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) { 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 - ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t)); + ptr = XNEW (lineno_list_t); #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 (int sz) +{ + if (cur_proc_ptr == 0) + return; + + cur_proc_ptr->pdr.gp_prologue = sz; + if (cur_proc_ptr->pdr.gp_prologue != sz) + { + as_warn (_("GP prologue size exceeds field size, using 0 instead")); + cur_proc_ptr->pdr.gp_prologue = 0; + } + + cur_proc_ptr->pdr.gp_used = 1; +} + +int +ecoff_no_current_file (void) +{ + return cur_file_ptr == (efdr_t *) NULL; +} + +void +ecoff_generate_asm_lineno (void) +{ + unsigned int lineno; + const char *filename; + lineno_list_t *list; + + filename = as_where (&lineno); + + if (current_stabs_filename == (char *) NULL + || filename_cmp (current_stabs_filename, filename)) + add_file (filename, 0, 1); + + list = allocate_lineno_list (); + + list->next = (lineno_list_t *) NULL; + list->file = cur_file_ptr; + list->proc = cur_proc_ptr; + list->frag = frag_now; + list->paddr = frag_now_fix (); + list->lineno = lineno; + + /* We don't want to merge files which have line numbers. */ + cur_file_ptr->fdr.fMerge = 0; + + /* A .loc directive will sometimes appear before a .ent directive, + which means that cur_proc_ptr will be NULL here. Arrange to + patch this up. */ + if (cur_proc_ptr == (proc_t *) NULL) + { + lineno_list_t **pl; + + pl = &noproc_lineno; + while (*pl != (lineno_list_t *) NULL) + pl = &(*pl)->next; + *pl = list; + } + else + { + last_lineno = list; + *last_lineno_ptr = list; + last_lineno_ptr = &list->next; + } +} + +#else + +void +ecoff_generate_asm_lineno (void) +{ +} + #endif /* ECOFF_DEBUGGING */