X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gas%2Fecoff.c;h=082192230373e78a43057751a893a8130442e1ce;hb=d476d46aabef1a56af211f59cb7329243720c15a;hp=27890fabd438f5008b254163d06ffc980311df41;hpb=e4fc9376b2a016308ad3d461e4f545b67801d0fe;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/ecoff.c b/gas/ecoff.c index 27890fabd4..0821922303 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, 1994, 1995, 1996 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 @@ -18,8 +18,9 @@ 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, 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ #include "as.h" @@ -778,7 +779,6 @@ enum aux_type { #define MAX_CLUSTER_PAGES 63 #endif - /* Linked list connecting separate page allocations. */ typedef struct vlinks { struct vlinks *prev; /* previous set of pages */ @@ -833,6 +833,7 @@ typedef struct scope { 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 */ @@ -937,6 +938,7 @@ 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 */ @@ -973,13 +975,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 +986,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 */ @@ -1021,6 +1020,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 +1046,13 @@ 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 */ @@ -1391,9 +1391,13 @@ static const st_t map_coff_sym_type[] = { /* Keep track of different sized allocation requests. */ 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 @@ -1402,6 +1406,7 @@ static int debug = 0; /* trace functions */ 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 @@ -1419,7 +1424,7 @@ static symint_t add_string PARAMS ((varray_t *vp, 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, + bfd_vma addend, symint_t value, symint_t indx)); static symint_t add_aux_sym_symint PARAMS ((symint_t aux_word)); static symint_t add_aux_sym_rndx PARAMS ((int file_index, @@ -1431,7 +1436,7 @@ 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_file PARAMS ((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)); @@ -1464,8 +1469,8 @@ static unsigned long ecoff_build_fdr PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend, unsigned long offset)); static void ecoff_setup_ext PARAMS ((void)); -static page_t *allocate_cluster PARAMS ((unsigned long npages)); -static page_t *allocate_page PARAMS ((void)); +static page_type *allocate_cluster PARAMS ((unsigned long npages)); +static page_type *allocate_page PARAMS ((void)); static scope_t *allocate_scope PARAMS ((void)); static void free_scope PARAMS ((scope_t *ptr)); static vlinks_t *allocate_vlinks PARAMS ((void)); @@ -1477,6 +1482,7 @@ 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)); +static void generate_ecoff_stab PARAMS ((int, const char *, int, int, int)); /* This function should be called when the assembler starts up. */ @@ -1497,11 +1503,17 @@ void ecoff_symbol_new_hook (symbolP) symbolS *symbolP; { - if (cur_file_ptr == (efdr_t *) NULL) - add_file ((const char *) NULL, 0); + /* 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); symbolP->ecoff_file = cur_file_ptr; symbolP->ecoff_symbol = NULL; - symbolP->ecoff_undefined = 0; + symbolP->ecoff_extern_size = 0; } /* Add a page to a varray object. */ @@ -1514,7 +1526,7 @@ add_varray_page (vp) #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 (); @@ -1587,11 +1599,12 @@ 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) +add_ecoff_symbol (str, type, storage, sym_value, addend, value, indx) const char *str; /* symbol name */ st_t type; /* symbol type */ sc_t storage; /* storage class */ symbolS *sym_value; /* associated symbol. */ + bfd_vma addend; /* addend to sym_value. */ symint_t value; /* value of symbol */ symint_t indx; /* index to local/aux. syms */ { @@ -1621,6 +1634,7 @@ add_ecoff_symbol (str, type, storage, sym_value, value, indx) psym->as_sym = sym_value; if (sym_value != (symbolS *) NULL) 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; @@ -2091,6 +2105,7 @@ add_unknown_tag (ptag) st_Block, sc_Info, (symbolS *) NULL, + (bfd_vma) 0, (symint_t) 0, (symint_t) 0); @@ -2098,6 +2113,7 @@ add_unknown_tag (ptag) st_End, sc_Info, (symbolS *) NULL, + (bfd_vma) 0, (symint_t) 0, (symint_t) 0); @@ -2115,6 +2131,7 @@ add_procedure (func) { register varray_t *vp; register proc_t *new_proc_ptr; + symbolS *sym; #ifdef ECOFF_DEBUG if (debug) @@ -2131,6 +2148,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; @@ -2138,10 +2158,14 @@ add_procedure (func) new_proc_ptr->pdr.lnLow = -1; new_proc_ptr->pdr.lnHigh = -1; + /* Set the BSF_FUNCTION flag for the symbol. */ + sym = symbol_find_or_make (func); + sym->bsym->flags |= BSF_FUNCTION; + /* 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; @@ -2154,7 +2178,10 @@ 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; } } @@ -2164,9 +2191,10 @@ add_procedure (func) where the current file structure lives. */ static void -add_file (file_name, indx) +add_file (file_name, indx, fake) const char *file_name; /* file name */ int indx; + int fake; { register int first_ch; register efdr_t *fil_ptr; @@ -2186,6 +2214,14 @@ add_file (file_name, indx) as_fatal ("fake .file after real one"); as_where (&file, (unsigned int *) NULL); file_name = (const char *) file; + + /* 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_NONE) + debug_type = DEBUG_ECOFF; } #ifndef NO_LISTING @@ -2193,6 +2229,8 @@ add_file (file_name, indx) 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) @@ -2201,21 +2239,37 @@ add_file (file_name, indx) symbol_new ("L0\001", 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) + && strcmp (file_name, fil_ptr->name) == 0 + && fil_ptr->fdr.fMerge) { cur_file_ptr = fil_ptr; + if (! fake) + cur_file_ptr->fake = 0; break; } } @@ -2233,6 +2287,8 @@ add_file (file_name, 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 (); @@ -2248,7 +2304,7 @@ add_file (file_name, indx) /* 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]; @@ -2268,6 +2324,24 @@ 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 (name) + const char *name; +{ + if (cur_file_ptr != NULL && strcmp (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_NONE) + debug_type = DEBUG_ECOFF; +} #ifdef ECOFF_DEBUG @@ -2377,7 +2451,7 @@ ecoff_directive_begin (ignore) (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; @@ -2422,7 +2496,7 @@ ecoff_directive_bend (ignore) 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; @@ -2442,7 +2516,8 @@ 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. */ @@ -2454,6 +2529,8 @@ ecoff_directive_def (ignore) char *name; char name_end; + ecoff_debugging_seen = 1; + SKIP_WHITESPACE (); name = input_line_pointer; @@ -2478,6 +2555,7 @@ 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; @@ -2640,7 +2718,11 @@ ecoff_directive_type (ignore) { 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)) @@ -2712,6 +2794,8 @@ void ecoff_directive_val (ignore) int ignore; { + expressionS exp; + if (coff_sym_name == (char *) NULL) { as_warn (".val pseudo-op used outside of .def/.endef; ignored"); @@ -2719,26 +2803,20 @@ ecoff_directive_val (ignore) 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 copmlex"); + 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 (); @@ -2806,8 +2884,10 @@ 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 @@ -2900,6 +2980,7 @@ ecoff_directive_endef (ignore) coff_symbol_typ, coff_storage_class, coff_sym_value, + coff_sym_addend, (symint_t) coff_value, indx); @@ -2971,7 +3052,7 @@ ecoff_directive_end (ignore) symbol_new ("L0\001", now_seg, (valueT) frag_now_fix (), frag_now), - (symint_t) 0, (symint_t) 0); + (bfd_vma) 0, (symint_t) 0, (symint_t) 0); cur_proc_ptr = (proc_t *) NULL; @@ -2990,7 +3071,7 @@ ecoff_directive_ent (ignore) 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) { @@ -3031,6 +3112,31 @@ ecoff_directive_ent (ignore) demand_empty_rest_of_line (); } +/* Parse .extern directives. */ + +void +ecoff_directive_extern (ignore) + int ignore; +{ + char *name; + int c; + symbolS *symbolp; + valueT size; + + name = input_line_pointer; + c = get_symbol_end (); + symbolp = symbol_find_or_make (name); + *input_line_pointer = c; + + S_SET_EXTERNAL (symbolp); + + if (*input_line_pointer == ',') + ++input_line_pointer; + size = get_absolute_expression (); + + symbolp->ecoff_extern_size = size; +} + /* Parse .file directives. */ void @@ -3053,7 +3159,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 (); } @@ -3199,7 +3305,7 @@ ecoff_directive_loc (ignore) symbol_new ("L0\001", now_seg, (valueT) frag_now_fix (), frag_now), - 0, lineno); + (bfd_vma) 0, 0, lineno); return; } @@ -3212,6 +3318,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. */ @@ -3226,10 +3335,29 @@ 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 (old_frag, old_frag_offset) + 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. */ @@ -3243,8 +3371,57 @@ mark_stabs (ignore) stabs_seen = 1; (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo, (symbolS *) NULL, - (symint_t) -1, ECOFF_MARK_STAB (0)); + (bfd_vma) 0, (symint_t) -1, + ECOFF_MARK_STAB (0)); + } +} + +/* Parse .weakext directives. */ + +void +ecoff_directive_weakext (ignore) + int ignore; +{ + char *name; + int c; + symbolS *symbolP; + expressionS exp; + + name = input_line_pointer; + c = get_symbol_end (); + symbolP = symbol_find_or_make (name); + *input_line_pointer = c; + + SKIP_WHITESPACE (); + + if (*input_line_pointer == ',') + { + if (S_IS_DEFINED (symbolP)) + { + as_bad ("Ignoring attempt to redefine symbol `%s'.", + 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; + } + symbolP->sy_value = exp; + } } + + S_SET_WEAK (symbolP); + + demand_empty_rest_of_line (); } /* Handle .stabs directives. The actual parsing routine is done by a @@ -3280,7 +3457,8 @@ mark_stabs (ignore) value a numeric value or an address. */ void -ecoff_stab (what, string, type, other, desc) +ecoff_stab (sec, what, string, type, other, desc) + segT sec; int what; const char *string; int type; @@ -3290,11 +3468,14 @@ ecoff_stab (what, string, type, other, 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') { @@ -3313,7 +3494,7 @@ ecoff_stab (what, string, type, other, desc) /* 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; } @@ -3354,6 +3535,7 @@ ecoff_stab (what, string, type, other, desc) *input_line_pointer = name_end; value = 0; + addend = 0; st = st_Label; sc = sc_Text; indx = desc; @@ -3373,6 +3555,7 @@ 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)) { @@ -3381,25 +3564,29 @@ ecoff_stab (what, string, type, other, desc) } 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; } } @@ -3412,7 +3599,7 @@ ecoff_stab (what, string, type, other, desc) if (sym != (symbolS *) NULL) hold = sym->ecoff_symbol; - (void) add_ecoff_symbol (string, st, sc, sym, value, indx); + (void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx); if (sym != (symbolS *) NULL) sym->ecoff_symbol = hold; @@ -3421,19 +3608,16 @@ ecoff_stab (what, string, type, other, desc) cur_file_ptr = save_file_ptr; } -/* Frob an ECOFF symbol. A .extern symbol will have a value, but is - not common. Small common symbols go into a special .scommon - section rather than bfd_com_section. */ +/* Frob an ECOFF symbol. Small common symbols go into a special + .scommon section rather than bfd_com_section. */ void ecoff_frob_symbol (sym) symbolS *sym; { - if (sym->ecoff_undefined) - S_SET_SEGMENT (sym, undefined_section); - else if (S_IS_COMMON (sym) - && S_GET_VALUE (sym) > 0 - && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput)) + 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; @@ -3453,6 +3637,14 @@ ecoff_frob_symbol (sym) } S_SET_SEGMENT (sym, &scom_section); } + + /* Double check weak symbols. */ + if (sym->bsym->flags & BSF_WEAK) + { + 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. */ @@ -3525,6 +3717,7 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) unsigned long c; long iline; long totcount; + lineno_list_t first; if (linecntptr != (long *) NULL) *linecntptr = 0; @@ -3537,6 +3730,31 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) c = offset; iline = 0; totcount = 0; + + /* 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. */ + if (first_proc_ptr != (proc_t *) NULL + && first_lineno != (lineno_list_t *) NULL + && ((S_GET_VALUE (first_proc_ptr->sym->as_sym) + + bfd_get_section_vma (stdoutput, + S_GET_SEGMENT (first_proc_ptr->sym->as_sym))) + != 0)) + { + first.file = first_lineno->file; + first.proc = first_lineno->proc; + first.frag = &zero_address_frag; + first.paddr = 0; + first.lineno = 0; + + first.next = first_lineno; + first_lineno = &first; + } + for (l = first_lineno; l != (lineno_list_t *) NULL; l = l->next) { long count; @@ -3546,17 +3764,22 @@ ecoff_build_lineno (backend, buf, bufend, offset, linecntptr) (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) @@ -3566,8 +3789,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; @@ -3576,8 +3797,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) @@ -3587,8 +3814,6 @@ 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; } } @@ -3799,13 +4024,17 @@ ecoff_build_symbols (backend, buf, bufend, offset) sym_ptr->ecoff_sym.asym.value = (S_GET_VALUE (as_sym) + bfd_get_section_vma (stdoutput, - S_GET_SEGMENT (as_sym))); + 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 @@ -3828,22 +4057,34 @@ ecoff_build_symbols (backend, buf, bufend, offset) if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym) && (S_IS_EXTERNAL (as_sym) + || S_IS_WEAK (as_sym) || ! S_IS_DEFINED (as_sym))) - st = st_Global; + { + if ((as_sym->bsym->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 + if (as_sym->ecoff_extern_size == 0 + || (as_sym->ecoff_extern_size + > bfd_get_gp_size (stdoutput))) sc = sc_Undefined; + else + { + sc = sc_SUndefined; + sym_ptr->ecoff_sym.asym.value = + as_sym->ecoff_extern_size; + } +#ifdef S_SET_SIZE + S_SET_SIZE (as_sym, as_sym->ecoff_extern_size); +#endif } else if (S_IS_COMMON (as_sym)) { @@ -3870,7 +4111,12 @@ ecoff_build_symbols (backend, buf, bufend, offset) else if (seg == &bfd_abs_section) 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; @@ -3883,12 +4129,18 @@ ecoff_build_symbols (backend, buf, bufend, offset) 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 @@ -3955,6 +4207,16 @@ ecoff_build_symbols (backend, buf, bufend, offset) 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) @@ -4006,13 +4268,16 @@ ecoff_build_symbols (backend, buf, bufend, offset) if (as_sym != (symbolS *) NULL && 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; } } } @@ -4036,13 +4301,11 @@ ecoff_build_procs (backend, buf, bufend, offset) void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR)) = 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. */ @@ -4092,10 +4355,11 @@ ecoff_build_procs (backend, buf, bufend, offset) 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; @@ -4129,7 +4393,7 @@ ecoff_build_aux (backend, buf, bufend, offset) 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); @@ -4180,12 +4444,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, @@ -4374,6 +4640,7 @@ ecoff_setup_ext () /* 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; @@ -4386,7 +4653,7 @@ ecoff_setup_ext () } } -/* Build the ECOFF dbeugging information. */ +/* Build the ECOFF debugging information. */ unsigned long ecoff_build_debug (hdr, bufp, backend) @@ -4408,7 +4675,7 @@ ecoff_build_debug (hdr, bufp, backend) /* 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; @@ -4439,7 +4706,7 @@ ecoff_build_debug (hdr, bufp, backend) cur_file_ptr = 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; @@ -4453,20 +4720,23 @@ 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"); 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. */ @@ -4536,9 +4806,13 @@ ecoff_build_debug (hdr, bufp, backend) 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; @@ -4548,11 +4822,11 @@ ecoff_build_debug (hdr, bufp, backend) #ifndef MALLOC_CHECK -static page_t * +static page_type * allocate_cluster (npages) unsigned long npages; { - register page_t *value = (page_t *) xmalloc (npages * PAGE_USIZE); + register page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE); #ifdef ECOFF_DEBUG if (debug > 3) @@ -4565,14 +4839,14 @@ allocate_cluster (npages) } -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 * +static page_type * allocate_page () { #ifndef MALLOC_CHECK @@ -4588,7 +4862,7 @@ allocate_page () #else /* MALLOC_CHECK */ - page_t *ptr; + page_type *ptr; ptr = xmalloc (PAGE_USIZE); memset (ptr, 0, PAGE_USIZE); @@ -4613,7 +4887,7 @@ allocate_scope () else { register int unallocated = alloc_counts[(int)alloc_type_scope].unallocated; - register page_t *cur_page = alloc_counts[(int)alloc_type_scope].cur_page; + register page_type *cur_page = alloc_counts[(int)alloc_type_scope].cur_page; if (unallocated == 0) { @@ -4664,7 +4938,7 @@ allocate_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; + register page_type *cur_page = alloc_counts[(int)alloc_type_vlinks].cur_page; if (unallocated == 0) { @@ -4698,7 +4972,7 @@ allocate_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; + register page_type *cur_page = alloc_counts[(int)alloc_type_shash].cur_page; if (unallocated == 0) { @@ -4732,7 +5006,7 @@ allocate_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; + register page_type *cur_page = alloc_counts[(int)alloc_type_thash].cur_page; if (unallocated == 0) { @@ -4771,7 +5045,7 @@ allocate_tag () else { register int unallocated = alloc_counts[(int)alloc_type_tag].unallocated; - register page_t *cur_page = alloc_counts[(int)alloc_type_tag].cur_page; + register page_type *cur_page = alloc_counts[(int)alloc_type_tag].cur_page; if (unallocated == 0) { @@ -4822,7 +5096,7 @@ allocate_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; + register page_type *cur_page = alloc_counts[(int)alloc_type_forward].cur_page; if (unallocated == 0) { @@ -4861,7 +5135,7 @@ allocate_thead () else { register int unallocated = alloc_counts[(int)alloc_type_thead].unallocated; - register page_t *cur_page = alloc_counts[(int)alloc_type_thead].cur_page; + register page_type *cur_page = alloc_counts[(int)alloc_type_thead].cur_page; if (unallocated == 0) { @@ -4910,7 +5184,7 @@ allocate_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; + register page_type *cur_page = alloc_counts[(int)alloc_type_lineno].cur_page; if (unallocated == 0) { @@ -4938,7 +5212,7 @@ ecoff_set_gp_prolog_size (sz) int sz; { if (cur_proc_ptr == 0) - abort (); + return; cur_proc_ptr->pdr.gp_prologue = sz; if (cur_proc_ptr->pdr.gp_prologue != sz) @@ -4950,4 +5224,150 @@ ecoff_set_gp_prolog_size (sz) cur_proc_ptr->pdr.gp_used = 1; } +static void +generate_ecoff_stab (what, string, type, other, desc) + int what; + const char *string; + int type; + int other; + int desc; +{ + efdr_t *save_file_ptr = cur_file_ptr; + symbolS *sym; + symint_t value; + st_t st; + sc_t sc; + symint_t indx; + localsym_t *hold = NULL; + + /* We don't handle .stabd. */ + if (what != 's' && what != 'n') + { + as_bad (".stab%c is not supported", what); + return; + } + + /* We ignore the other field. */ + if (other != 0) + 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, 1); + save_file_ptr = cur_file_ptr; + } + + /* For stabs in ECOFF, the first symbol must be @stabs. This is a + signal to gdb. */ + if (stabs_seen == 0) + mark_stabs (0); + + /* Line number stabs are handled differently, since they have two + values, the line number and the address of the label. We use the + index field (aka desc) to hold the line number, and the value + field to hold the address. The symbol type is st_Label, which + should be different from the other stabs, so that gdb can + recognize it. */ + if (type == N_SLINE) + { + SYMR dummy_symr; + +#ifndef NO_LISTING + if (listing) + listing_source_line ((unsigned int) desc); +#endif + + 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)", + desc, what); + return; + } + + sym = symbol_find_or_make ((char *)string); + value = 0; + st = st_Label; + sc = sc_Text; + indx = desc; + } + else + { +#ifndef NO_LISTING + if (listing && (type == N_SO || type == N_SOL)) + listing_source_file (string); +#endif + + sym = symbol_find_or_make ((char *)string); + sc = sc_Nil; + st = st_Nil; + value = 0; + indx = ECOFF_MARK_STAB (type); + } + + /* 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 = sym->ecoff_symbol; + + (void) add_ecoff_symbol (string, st, sc, sym, (bfd_vma) 0, value, indx); + + if (sym != (symbolS *) NULL) + sym->ecoff_symbol = hold; + + /* Restore normal file type. */ + cur_file_ptr = save_file_ptr; +} + +int +ecoff_no_current_file () +{ + return cur_file_ptr == (efdr_t *) NULL; +} + +void +ecoff_generate_asm_lineno (filename, lineno) + const char *filename; + int lineno; +{ + lineno_list_t *list; + + if (current_stabs_filename == (char *)NULL + || strcmp (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; + } +} + #endif /* ECOFF_DEBUGGING */