diff options
Diffstat (limited to 'gdb/mipsread.c')
| -rw-r--r-- | gdb/mipsread.c | 2879 |
1 files changed, 2879 insertions, 0 deletions
diff --git a/gdb/mipsread.c b/gdb/mipsread.c new file mode 100644 index 0000000..2c7112f --- /dev/null +++ b/gdb/mipsread.c @@ -0,0 +1,2879 @@ +/* Read a symbol table in MIPS' format (Third-Eye). + Copyright (C) 1986, 1987, 1989-1991 Free Software Foundation, Inc. + Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU + +This file is part of GDB. + +GDB 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 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "param.h" +#include "obstack.h" +#include <sys/param.h> +#include <sys/file.h> +#include <sys/stat.h> +#include "defs.h" +#include "symtab.h" +#include "gdbcore.h" +#include "symfile.h" +#ifdef CMUCS +#include <mips/syms.h> +#endif CMUCS + +/* Since these things are defined differently on various systems I'll + (re)define here what I really need in this module. I only assume the + three standard COFF structure definitions: filehdr, aouthdr, scnhdr */ +#define MIPS /* Kludge to get MIPS version of coff */ +#include "intel-coff.h" + +struct coff_exec { + struct filehdr f; + struct aouthdr a; +}; +#undef a_magic +#undef a_text +#undef a_data +#undef a_bss +#undef a_syms +#undef a_entry +#define a_magic a.magic /* magic number */ +#define a_text a.tsize /* size of text segment */ +#define a_data a.dsize /* size of initialized data */ +#define a_bss a.bsize /* size of uninitialized data */ +#define a_syms f.f_nsyms /* size of symbol table */ +#define a_entry a.entry /* entry point */ + +#undef N_BADMAG +#define N_BADMAG(x) \ + (((x).a_magic)!=OMAGIC && ((x).a_magic)!=NMAGIC && ((x).a_magic)!=ZMAGIC) + +/* Things we import explicitly from other modules */ + +extern int info_verbose; +extern struct block *block_for_pc(); +extern void sort_symtab_syms(); + +/* Forward declarations */ + +static void psymtab_to_symtab_1(); + +/* Macros and extra defs */ + +struct complaint unknown_ext_complaint = + {"unknown external symbol %s", 0, 0}; + +/* Already parsed symbols are marked specially */ + +#define stParsed stType + +/* Puns: hard to find whether -g was used and how */ + +#define MIN_GLEVEL GLEVEL_0 +#define compare_glevel(a,b) \ + (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \ + ((b) == GLEVEL_3) ? -1 : (int)((b) - (a))) + +/* When looking at .o files avoid tripping over bad addresses */ + +#define SAFE_TEXT_ADDR 0x400000 +#define SAFE_DATA_ADDR 0x10000000 + +#define UNSAFE_DATA_ADDR(p) ((unsigned)p < SAFE_DATA_ADDR || (unsigned)p > 2*SAFE_DATA_ADDR) + + +/* Things we export to other modules */ + + +/* Lists of partial symbols */ + +struct psymbol_allocation_list global_psymbols, static_psymbols; + +/* Address bounds for the signal trampoline in inferior, if any */ + +CORE_ADDR sigtramp_address, sigtramp_end; + + +/* Functions that we really export */ + +/* THIS DESCRIPTION IS OBSOLETE POST-BFD; FIXME! */ +/* Basically, this module must provide two functions: symbol_file_command() + which loads the symbol table from a file, and add_file_command() which + adds more symbols to the symbol table (incrementally). + + These two functions only do the minimum work necessary for letting the + user "name" things symbolically, they do not read the entire symtab. + Instead, they read in the external symbols and put them in partial + symbol tables. When more extensive information is requested of a + file the corresponding partial symbol table is mutated into a full + fledged symbol table by going back and reading the relative symbols + for real. mipscoff_psymtab_to_symtab() is the function that does this */ + +/* The entry point (starting address) of the file, if it is an executable. */ + +static CORE_ADDR entry_point; + +extern CORE_ADDR startup_file_start; /* From blockframe.c */ +extern CORE_ADDR startup_file_end; /* From blockframe.c */ + +void +mipscoff_new_init() +{ +} + +void +mipscoff_symfile_init (sf) + struct sym_fns *sf; +{ + bfd *abfd = sf->sym_bfd; + sf->sym_private = NULL; + /* Save startup file's range of PC addresses to help blockframe.c + decide where the bottom of the stack is. */ + if (bfd_get_file_flags (abfd) & EXEC_P) + { + /* Executable file -- record its entry point so we'll recognize + the startup file because it contains the entry point. */ + entry_point = bfd_get_start_address (abfd); + } + else + { + /* Examination of non-executable.o files. Short-circuit this stuff. */ + /* ~0 will not be in any file, we hope. */ + entry_point = ~0; + /* set the startup file to be an empty range. */ + startup_file_start = 0; + startup_file_end = 0; + } +} + +void +mipscoff_symfile_read(sf, addr, mainline) + struct sym_fns *sf; + CORE_ADDR addr; + int mainline; +{ + struct coff_symfile_info *info = (struct coff_symfile_info *)sf->sym_private; + bfd *abfd = sf->sym_bfd; + char *name = bfd_get_filename (abfd); + int desc; + register int val; + int num_symbols; + int symtab_offset; + int stringtab_offset; + +/* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */ + desc = fileno ((FILE *)(abfd->iostream)); /* Raw file descriptor */ + num_symbols = bfd_get_symcount (abfd); /* How many syms */ +/* symtab_offset = obj_sym_filepos (abfd); * Symbol table file offset */ +/* stringtab_offset = symtab_offset + num_symbols * SYMESZ; * String tab */ +/* End of warning */ + +#ifdef TDESC + debug_info = text_hdr.s_relptr; + if (tdesc_handle) + { + dc_terminate (tdesc_handle); + tdesc_handle = 0; + } +#endif + +#if 0 + /* Read the line number table, all at once. */ + info->min_lineno_offset = 0; + info->max_lineno_offset = 0; + bfd_map_over_sections (abfd, find_linenos, info); + + val = init_lineno (desc, info->min_lineno_offset, + info->max_lineno_offset - info->min_lineno_offset); + if (val < 0) + error ("\"%s\": error reading line numbers\n", name); + + /* Now read the string table, all at once. */ + + val = init_stringtab (desc, stringtab_offset); + if (val < 0) + { + free_all_symtabs (); /* FIXME blows whole symtab */ + printf ("\"%s\": can't get string table", name); + fflush (stdout); + return; + } + make_cleanup (free_stringtab, 0); +#endif + /* Position to read the symbol table. Do not read it all at once. */ + val = lseek (desc, (long)symtab_offset, 0); + if (val < 0) + perror_with_name (name); + + init_misc_bunches (); + make_cleanup (discard_misc_bunches, 0); + + /* Now that the executable file is positioned at symbol table, + process it and define symbols accordingly. */ + + printf("Reading symbol data from %s...", name); + fflush(stdout); + read_mips_symtab(desc, 0); + +/* patch_opaque_types ();*/ + + /* Sort symbols alphabetically within each block. */ + + sort_all_symtab_syms (); + + /* Go over the misc symbol bunches and install them in vector. */ + + condense_misc_bunches (0); + + /* Make a default for file to list. */ + + select_source_symtab (0); /* FIXME, this might be too slow, see dbxread */ +} + +void +mipscoff_symfile_discard() +{ +} + + +#if 0 +/* Exported procedure: Reads symbols from file NAME. + Invoked at startup time if executable was given. + When invoked cleans up the world */ + +void +symbol_file_command(name, from_tty) + char *name; + int from_tty; +{ + int desc; + struct coff_exec hdr; + register int val; + extern void close(); + struct cleanup *old_chain; + + dont_repeat(); + + /* + * Make sure s/he means it + */ + if (name == 0) { + if ((symtab_list || partial_symtab_list) + && from_tty + && !query("Discard symbol table? ", 0)) + error("Not confirmed."); + destroy_all_symtabs(); + return; + } + + name = tilde_expand(name); + make_cleanup(free, name); + + if (symtab_list && + !query("Load new symbol table from \"%s\"? ", name)) + error("Not confirmed."); + + /* Open the file */ + { + char *absolute_name; + desc = openp (getenv ("PATH"), 1, name, O_RDONLY, 0, &absolute_name); + if (desc < 0) + perror_with_name (name); + else + name = absolute_name; + } + + old_chain = make_cleanup (close, desc); + make_cleanup (free_current_contents, &name); + + /* + * Check file is indeed executable + */ + val = myread(desc, &hdr, sizeof hdr); + if (val < 0) + perror_with_name(name); + + if (N_BADMAG(hdr)) + error("File \"%s\" not in executable format.", name); + + if (hdr.a.entry < SAFE_TEXT_ADDR && access(name, 1)) + printf_filtered("Warning: %s is not executable!\n", name); + + if (hdr.a_syms == 0) { + printf_filtered("%s does not have a symbol-table.\n", name); + fflush(stdout); + return; + } + + /* Get the modification time. */ + { + struct stat symstat; + + if (fstat (desc, &symstat) < 0) + perror_with_name (name); + + symfile_mtime = symstat.st_mtime; + } + + /* + * Throw away the old symbol table. + */ + + destroy_all_symtabs(); + + /* Make a default for file to list. */ + + symfile = savestring (name, strlen (name)); + + /* Prepare to remember misc symbol values */ + + init_misc_bunches (); + make_cleanup (discard_misc_bunches, 0); + + /* + * Now read the new symbol table + */ + + read_mips_symtab(desc, 0); + + /* Go over the misc symbol bunches and install them in vector. */ + + condense_misc_bunches (0); + + /* Don't allow char * to have a typename (else would get caddr_t.) */ + + TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0; + + /* Force reinit of the sigtramp info */ + sigtramp_address = 0; + + do_cleanups (old_chain); /* Descriptor closed here */ + + if (!partial_symtab_list) + printf ("\n(no debugging symbols found)..."); + + printf ("done.\n"); + fflush(stdout); +} +#endif + +/* C++: + This function allows the addition of incrementally linked object files. + Since this has a fair amount of code in common with symbol_file_command, + it might be worthwhile to consolidate things, as was done with + read_dbx_symtab and condense_misc_bunches. */ + +/* Exported procedure: add more symbols from file NAME. */ + +void +add_file_command(arg_string) + char* arg_string; +{ + int desc; + struct coff_exec hdr; + register int val; + extern void close(); + struct cleanup *old_chain; + char *name; + unsigned text_addr; + + if (arg_string == 0) + error ("add-file takes a file name and an address"); + + if (arg_string == 0) + error ("add-file takes a file name and an address"); + + arg_string = tilde_expand (arg_string); + make_cleanup (free, arg_string); + + for( ; *arg_string == ' '; arg_string++ ); + name = arg_string; + for( ; *arg_string && *arg_string != ' ' ; arg_string++ ); + *arg_string++ = (char) 0; + + if (name[0] == 0) + error ("add-file takes a file name and an address"); + + text_addr = parse_and_eval_address (arg_string); + + dont_repeat(); + + if (!query ("add symbol table from filename \"%s\" at text_addr = 0x%x\n", + name, text_addr)) + error ("Not confirmed."); + + /* + * Open the file + */ + { + char *absolute_name; + + desc = openp(getenv("PATH"), 1, name, O_RDONLY, 0, &absolute_name); + if (desc < 0) + perror_with_name(name); + else + name = absolute_name; + } + old_chain = make_cleanup (close, desc); + + + /* + * Check file is indeed executable + */ + val = myread(desc, &hdr, sizeof hdr); + if (val < 0) + perror_with_name(name); + + if (N_BADMAG(hdr)) + error("File \"%s\" not in executable format.", name); + + if (hdr.a.entry < SAFE_TEXT_ADDR && access(name, 1)) + printf_filtered("Warning: %s is not executable!\n", name); + + if (hdr.a_syms == 0) { + printf_filtered("%s does not have a symbol-table.\n", name); + fflush(stdout); + return; + } + + if (symfile) + free(symfile); + symfile = 0; + + /* + * Now read the new symbol table + */ + + symfile = savestring(name, strlen(name)); + + init_misc_bunches (); + make_cleanup (discard_misc_bunches, 0); + read_mips_symtab(desc, 1); + + /* Go over the misc symbol bunches and install them in vector. */ + + condense_misc_bunches (1); + + /* Don't allow char * to have a typename (else would get caddr_t.) */ + + TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0; + + do_cleanups (old_chain); + + printf_filtered("done.\n"); + fflush(stdout); +} + +/* Exported procedure: Allocate zeroed memory */ + +char *xzalloc(size) +{ + char *p = xmalloc(size); + + bzero(p, size); + return p; +} + +/* Exported procedure: Builds a symtab from the PST partial one. + Restores the environment in effect when PST was created, delegates + most of the work to an ancillary procedure, and sorts + and reorders the symtab list at the end */ + +/* Forward decls */ +static HDRR *cur_hdr; /* MIPS symtab header for the current file */ + +void +mipscoff_psymtab_to_symtab(pst) + struct partial_symtab *pst; +{ + struct symtab *ret; + int i; + + if (!pst) + return; + + if (info_verbose) { + printf_filtered("Reading in symbols for %s...", pst->filename); + fflush(stdout); + } + /* Restore the header and list of pending typedefs */ + cur_hdr = (HDRR *) pst->ldsymlen; + + psymtab_to_symtab_1(pst); + + reorder_symtabs(); + + /* Finish up the debug error message. */ + if (info_verbose) + printf_filtered("done.\n"); +} + +/* Exported procedure: Is PC in the signal trampoline code */ + +int in_sigtramp(pc,name) + CORE_ADDR pc; +{ + if (sigtramp_address == 0) + fixup_sigtramp(); + return (pc >= sigtramp_address && pc < sigtramp_end); +} + + +/* Things that really are local to this module */ + +/* All allocated symtabs and psymtabs */ + +static int all_symtabs_count; +static int all_psymtabs_count; + +/* GDB symtable for the current compilation unit */ + +static struct symtab *cur_stab; + +/* Header for executable/object file we read symbols from */ + +static struct coff_exec filhdr; +#define END_OF_TEXT_SEGMENT(f) ((f).a.text_start + (f).a.tsize) + +/* Pointer to current file decriptor record, and its index */ + +static FDR *cur_fdr; +static int cur_fd; + +/* Index of current symbol */ + +static int cur_sdx; + +/* Note how much "debuggable" this image is. We would like + to see at least one FDR with full symbols */ + +static max_gdbinfo; +static max_glevel; + +/* When examining .o files, report on undefined symbols */ + +static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs; + +/* Extra builtin types */ + +struct type *builtin_type_complex; +struct type *builtin_type_double_complex; +struct type *builtin_type_fixed_dec; +struct type *builtin_type_float_dec; +struct type *builtin_type_string; + +/* Template types */ + +static struct type *builtin_type_ptr; +static struct type *builtin_type_struct; +static struct type *builtin_type_union; +static struct type *builtin_type_enum; +static struct type *builtin_type_range; +static struct type *builtin_type_set; + + +/* Forward decls */ + +static struct symbol *new_symbol(); +static struct type *new_type(); +static struct field *new_field(); +static struct block *new_block(); +static struct symtab *new_symtab(); +static struct linetable *new_linetable(); +static struct blockvector *new_bvect(); + +static struct type *parse_type(); +static struct type *make_type(); +static struct symbol *mylookup_symbol(); +static struct block *shrink_block(); + +static int compare_symtabs(); +static int compare_psymtabs(); +static int compare_blocks(); + +static struct partial_symtab *new_psymtab(); +static struct partial_symbol *new_psymbol(); +static struct partial_symtab *parse_fdr(); +static int compare_psymbols(); + +/* File-level interface functions */ + +/* Read the symtab information from file FSYM into memory */ + +static +read_the_mips_symtab(fsym) +{ + int stsize, st_hdrsize; + unsigned st_filptr; + HDRR st_hdr; + + /* Find and read the symbol table header */ + st_hdrsize = filhdr.f.f_nsyms; + st_filptr = filhdr.f.f_symptr; + if (st_filptr == 0) + return 0; + + lseek(fsym, st_filptr, L_SET); + if (read(fsym, &st_hdr, st_hdrsize) != st_hdrsize) + goto readerr; + + /* Find out how large the symbol table is */ + stsize = (st_hdr.cbExtOffset - (st_filptr + st_hdrsize)) + + st_hdr.iextMax * cbEXTR; + + /* Allocate space for the symbol table. Read it in. */ + cur_hdr = (HDRR *) xmalloc(stsize + st_hdrsize); + + bcopy(&st_hdr, cur_hdr, st_hdrsize); + if (read(fsym, (char *) cur_hdr + st_hdrsize, stsize) != stsize) + goto readerr; + + /* Fixup file_pointers in it */ + fixup_symtab(cur_hdr, (char *) cur_hdr + st_hdrsize, + st_filptr + st_hdrsize); + + return; +readerr: + error("Short read on %s", symfile); +} + + +/* Turn all file-relative pointers in the symtab described by HDR + into memory pointers, given that the symtab itself is located + at DATA in memory and F_PTR in the file. */ + +static +fixup_symtab( hdr, data, f_ptr) + HDRR *hdr; + char *data; +{ + int f_idx, s_idx; + FDR *fh; + SYMR *sh; + OPTR *op; + PDR *pr; + EXTR *esh; + + /* + * These fields are useless (and empty) by now: + * hdr->cbDnOffset, hdr->cbOptOffset + * We use them for other internal purposes. + */ + hdr->cbDnOffset = 0; + hdr->cbOptOffset = 0; + +#define FIX(off) \ + if (hdr->off) hdr->off = (unsigned int)data + (hdr->off - f_ptr); + + FIX(cbLineOffset); + FIX(cbPdOffset); + FIX(cbSymOffset); + FIX(cbOptOffset); + FIX(cbAuxOffset); + FIX(cbSsOffset); + FIX(cbSsExtOffset); + FIX(cbFdOffset); + FIX(cbRfdOffset); + FIX(cbExtOffset); +#undef FIX + + + /* + * Fix all string pointers inside the symtab, and + * the FDR records. Also fix other miscellany. + */ + for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) { + register unsigned code_offset; + + /* Header itself, and strings */ + fh = (FDR *) (hdr->cbFdOffset) + f_idx; + fh->issBase += hdr->cbSsOffset; + if (fh->rss != -1) + fh->rss = (long)fh->rss + fh->issBase; + for (s_idx = 0; s_idx < fh->csym; s_idx++) { + sh = (SYMR*)(hdr->cbSymOffset) + fh->isymBase + s_idx; + sh->iss = (long) sh->iss + fh->issBase; + sh->reserved = 0; + } + + cur_fd = f_idx; + + /* Local symbols */ + fh->isymBase = (int)((SYMR*)(hdr->cbSymOffset)+fh->isymBase); + + /* cannot fix fh->ipdFirst because it is a short */ +#define IPDFIRST(h,fh) \ + ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR)) + + /* Optional symbols (actually used for partial_symtabs) */ + fh->ioptBase = 0; + fh->copt = 0; + + /* Aux symbols */ + if (fh->caux) + fh->iauxBase = hdr->cbAuxOffset + fh->iauxBase * sizeof(AUXU); + /* Relative file descriptor table */ + fh->rfdBase = hdr->cbRfdOffset + fh->rfdBase * sizeof(RFDT); + + /* Line numbers */ + if (fh->cbLine) + fh->cbLineOffset += hdr->cbLineOffset; + + /* Procedure symbols. (XXX This should be done later) */ + code_offset = fh->adr; + for (s_idx = 0; s_idx < fh->cpd; s_idx++) { + unsigned name, only_ext; + + pr = (PDR*)(IPDFIRST(hdr,fh)) + s_idx; + + /* Simple rule to find files linked "-x" */ + only_ext = fh->rss == -1; + if (only_ext) { + if (pr->isym == -1) { + /* static function */ + sh = (SYMR*)-1; + } else { + /* external */ + name = hdr->cbExtOffset + pr->isym * sizeof(EXTR); + sh = &((EXTR*)name)->asym; + } + } else { + /* Full symbols */ + sh = (SYMR*)fh->isymBase + pr->isym; + /* Included code ? */ + if (s_idx == 0 && pr->adr != 0) + code_offset -= pr->adr; + } + + /* Turn index into a pointer */ + pr->isym = (long)sh; + + /* Fix line numbers */ + pr->cbLineOffset += fh->cbLineOffset; + + /* Relocate address */ + if (!only_ext) + pr->adr += code_offset; + } + } + + /* External symbols: fix string */ + for (s_idx = 0; s_idx < hdr->iextMax; s_idx++) { + esh = (EXTR*)(hdr->cbExtOffset) + s_idx; + esh->asym.iss = esh->asym.iss + hdr->cbSsExtOffset; + } +} + + +/* Find a file descriptor given its index RF relative to a file CF */ + +static +FDR *get_rfd( cf, rf) +{ + register FDR *f; + + f = (FDR *) (cur_hdr->cbFdOffset) + cf; + /* Object files do not have the RFD table, all refs are absolute */ + if (f->rfdBase == 0) + return (FDR *) (cur_hdr->cbFdOffset) + rf; + cf = *((pRFDT) f->rfdBase + rf); + return (FDR *) (cur_hdr->cbFdOffset) + cf; +} + +/* Return a safer print NAME for a file descriptor */ + +static +char *fdr_name(name) + char *name; +{ + if (name == (char *) -1) + return "<stripped file>"; + if (UNSAFE_DATA_ADDR(name)) + return "<NFY>"; + return name; +} + + +/* Read in and parse the symtab of the file DESC. INCREMENTAL says + whether we are adding to the general symtab or not */ + +static +read_mips_symtab( desc, incremental) +{ + /* + * We get here with DESC pointing to the symtab header. But we need + * other info from the initial headers + */ + lseek(desc, 0L, 0); + myread(desc, &filhdr, sizeof filhdr); + + read_the_mips_symtab(desc); + + parse_partial_symbols(cur_hdr, incremental); + cur_hdr = 0; + + /* + * Check to make sure file was compiled with -g. + * If not, warn the user of this limitation. + */ + if (compare_glevel(max_glevel, GLEVEL_2) < 0) { + if (max_gdbinfo == 0) + printf("\n%s not compiled with -g, debugging support is limited.", symfile); + printf("\nYou should compile with -g2 or -g3 for best debugging support.\n"); + fflush(stdout); + } + + /* + * Dont allow char * to have a typename (else would get + * caddr_t.) + */ + TYPE_NAME(lookup_pointer_type(builtin_type_char)) = 0; +} + + +/* Local utilities */ + + +/* Map of FDR indexes to partial symtabs */ + +static struct pst_map { + struct partial_symtab *pst; /* the psymtab proper */ + int n_globals; /* globals it exports */ +} * fdr_to_pst; + + +/* Utility stack, used to nest procedures and blocks properly. + It is a doubly linked list, to avoid too many alloc/free. + Since we might need it quite a few times it is NOT deallocated + after use. */ + +static struct parse_stack { + struct parse_stack *next, *prev; + struct symtab *cur_st; /* Current symtab */ + struct block *cur_block; /* Block in it */ + int blocktype; /* What are we parsing */ + int maxsyms; /* Max symbols in this block */ + struct type *cur_type; /* Type we parse fields for */ + int procadr; /* Start addres of this procedure */ + int numargs; /* Its argument count */ +} *top_stack; /* Top stack ptr */ + + +/* Enter a new lexical context */ + +static push_parse_stack() +{ + struct parse_stack *new; + + /* Reuse frames if possible */ + if (top_stack && top_stack->prev) + new = top_stack->prev; + else + new = (struct parse_stack *) xzalloc(sizeof(struct parse_stack)); + /* Initialize new frame with previous content */ + if (top_stack) { + register struct parse_stack *prev = new->prev; + + *new = *top_stack; + top_stack->prev = new; + new->prev = prev; + new->next = top_stack; + } + top_stack = new; +} + +/* Exit a lexical context */ + +static pop_parse_stack() +{ + if (!top_stack) + return; + if (top_stack->next) + top_stack = top_stack->next; +} + + +/* Cross-references might be to things we haven't looked at + yet, e.g. type references. To avoid too many type + duplications we keep a quick fixup table, an array + of lists of references indexed by file descriptor */ + +static struct pending { + struct pending *next; /* link */ + SYMR *s; /* the symbol */ + struct type *t; /* its partial type descriptor */ +} **pending_list; + + +/* Check whether we already saw symbol SH in file FH as undefined */ + +static +struct pending *is_pending_symbol(fh, sh) + FDR *fh; + SYMR *sh; +{ + int f_idx = fh - (FDR *) cur_hdr->cbFdOffset; + register struct pending *p; + + /* Linear search is ok, list is typically no more than 10 deep */ + for (p = pending_list[f_idx]; p; p = p->next) + if (p->s == sh) + break; + return p; +} + +/* Check whether we already saw type T in file FH as undefined */ + +static +struct pending *is_pending_type(fh, t) + FDR *fh; + struct type *t; +{ + int f_idx = fh - (FDR *) cur_hdr->cbFdOffset; + register struct pending *p; + + for (p = pending_list[f_idx]; p; p = p->next) + if (p->t == t) + break; + return p; +} + +/* Add a new undef symbol SH of type T */ + +static +add_pending(fh, sh, t) + FDR *fh; + SYMR *sh; + struct type *t; +{ + int f_idx = fh - (FDR *) cur_hdr->cbFdOffset; + struct pending *p = is_pending_symbol(fh, sh); + + /* Make sure we do not make duplicates */ + if (!p) { + p = (struct pending *) xmalloc(sizeof(*p)); + p->s = sh; + p->t = t; + p->next = pending_list[f_idx]; + pending_list[f_idx] = p; + } + sh->reserved = 1; /* for quick check */ +} + +/* Throw away undef entries when done with file index F_IDX */ + +static +free_pending(f_idx) +{ + register struct pending *p, *q; + + for (p = pending_list[f_idx]; p; p = q) { + q = p->next; + free(p); + } + pending_list[f_idx] = 0; +} + +/* The number of args to a procedure is not explicit in the symtab, + this is the list of all those we know of. + This makes parsing more reasonable and avoids extra passes */ + +static struct numarg { + struct numarg *next; /* link */ + unsigned adr; /* procedure's start address */ + unsigned num; /* arg count */ +} *numargs_list; + +/* Record that the procedure at ADR takes NUM arguments. */ + +static +got_numargs(adr,num) +{ + struct numarg *n = (struct numarg *) xmalloc(sizeof(struct numarg)); + + n->adr = adr; + n->num = num; + n->next = numargs_list; + numargs_list = n; +} + +/* See if we know how many arguments the procedure at ADR takes */ + +static +lookup_numargs(adr) +{ + struct numarg *n = numargs_list; + + while (n && n->adr != adr) + n = n->next; + return (n) ? n->num : -1; +} + +/* Release storage when done with this file */ + +static +free_numargs() +{ + struct numarg *n = numargs_list, *m; + + while (n) { + m = n->next; + free(n); + n = m; + } + numargs_list = 0; +} + + +/* Parsing Routines proper. */ + +/* Parse a single symbol. Mostly just make up a GDB symbol for it. + For blocks, procedures and types we open a new lexical context. + This is basically just a big switch on the symbol's type */ + +static +parse_symbol(sh, ax) + SYMR *sh; + AUXU *ax; +{ + struct symbol *s; + struct block *b; + struct type *t; + struct field *f; + /* When a symbol is cross-referenced from other files/symbols + we mark it explicitly */ + int pend = (sh->reserved == 1); + enum address_class class; + + switch (sh->st) { + + case stNil: + break; + + case stGlobal: /* external symbol, goes into the primary block */ + class = LOC_STATIC; + b = BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack->cur_st), 0); + goto data; + + case stStatic: /* static data, goes into the current block. */ + class = LOC_STATIC; + b = top_stack->cur_block; + goto data; + + case stLocal: /* local variable, goes into the current block */ + if (sh->sc == scRegister) { + class = LOC_REGISTER; + if (sh->value > 31) + sh->value += 6; + } else + class = LOC_LOCAL; + b = top_stack->cur_block; + +data: /* Common code for symbols describing data */ + s = new_symbol(sh->iss); + SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; + SYMBOL_CLASS(s) = class; + add_symbol(s, b); + + /* Type could be missing in a number of cases */ + if (sh->sc == scUndefined || sh->sc == scNil || + sh->index == 0xfffff) + SYMBOL_TYPE(s) = builtin_type_int; /* undefined? */ + else + SYMBOL_TYPE(s) = parse_type(ax + sh->index, sh, 0); + /* Value of a data symbol is its memory address */ + SYMBOL_VALUE(s) = sh->value; + break; + + case stParam: /* argument to procedure, goes into current block */ + max_gdbinfo++; + top_stack->numargs++; + s = new_symbol(sh->iss); + SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; + if (sh->sc == scRegister) { + SYMBOL_CLASS(s) = LOC_REGPARM; + if (sh->value > 31) + sh->value += 6; + } else + SYMBOL_CLASS(s) = LOC_ARG; + SYMBOL_VALUE(s) = sh->value; + SYMBOL_TYPE(s) = parse_type(ax + sh->index, sh, 0); + add_symbol(s, top_stack->cur_block); + break; + + case stLabel: /* label, we do make a symbol for it */ + s = new_symbol(sh->iss); + SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; /* so that it can be used */ + SYMBOL_CLASS(s) = LOC_LABEL; /* but not misused */ + SYMBOL_VALUE(s) = sh->value; + SYMBOL_TYPE(s) = builtin_type_int; + add_symbol(s, top_stack->cur_block); + break; + + case stProc: /* Procedure */ + case stStaticProc: /* Static procedure */ + s = new_symbol(sh->iss); + SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; + SYMBOL_CLASS(s) = LOC_BLOCK; + /* Type of the return value */ + if (sh->sc == scUndefined || sh->sc == scNil) + t = builtin_type_int; + else + t = parse_type(ax + sh->index, sh, 0); + add_symbol(s, top_stack->cur_block); + + /* Make a type for the procedure itself */ + SYMBOL_TYPE(s) = lookup_function_type (t); + + /* Create and enter a new lexical context */ + b = new_block(top_stack->maxsyms); + SYMBOL_BLOCK_VALUE(s) = b; + BLOCK_FUNCTION(b) = s; + BLOCK_START(b) = BLOCK_END(b) = sh->value; + BLOCK_SUPERBLOCK(b) = top_stack->cur_block; + add_block(b, top_stack->cur_st); + + /* Not if we only have partial info */ + if (sh->sc == scUndefined || sh->sc == scNil) + break; + + push_parse_stack(); + top_stack->cur_block = b; + top_stack->blocktype = sh->st; + top_stack->cur_type = SYMBOL_TYPE(s); + top_stack->procadr = sh->value; + top_stack->numargs = 0; + + sh->value = (long) SYMBOL_TYPE(s); + break; + + case stBlock: /* Either a lexical block, or some type */ + push_parse_stack(); + top_stack->blocktype = stBlock; + if (sh->sc == scInfo) { /* structure/union/enum def */ + s = new_symbol(sh->iss); + SYMBOL_NAMESPACE(s) = STRUCT_NAMESPACE; + SYMBOL_CLASS(s) = LOC_TYPEDEF; + SYMBOL_VALUE(s) = 0; + add_symbol(s, top_stack->cur_block); + /* If this type was expected, use its partial definition */ + if (pend) { + t = is_pending_symbol(cur_fdr, sh)->t; + } else { + /* Uhmm, can`t decide yet. Smash later */ + t = new_type(sh->iss); + TYPE_CODE(t) = TYPE_CODE_UNDEF; + add_pending(cur_fdr, sh, t); + } + SYMBOL_TYPE(s) = t; + /* make this the current type */ + top_stack->cur_type = t; + TYPE_LENGTH(t) = sh->value; + /* Mark that symbol has a type, and say which one */ + sh->value = (long) t; + } else { + /* beginnning of (code) block. Value of symbol + is the displacement from procedure start */ + b = new_block(top_stack->maxsyms); + BLOCK_START(b) = sh->value + top_stack->procadr; + BLOCK_SUPERBLOCK(b) = top_stack->cur_block; + top_stack->cur_block = b; + add_block(b, top_stack->cur_st); + } + break; + + case stEnd: /* end (of anything) */ + if (sh->sc == scInfo) { + /* Finished with type */ + top_stack->cur_type = 0; + } else if (sh->sc == scText && + (top_stack->blocktype == stProc || + top_stack->blocktype == stStaticProc)) { + /* Finished with procedure */ + struct blockvector *bv = BLOCKVECTOR(top_stack->cur_st); + struct block *b; + int i; + + BLOCK_END(top_stack->cur_block) += sh->value; /* size */ + got_numargs(top_stack->procadr, top_stack->numargs); + /* Reallocate symbols, saving memory */ + b = shrink_block(top_stack->cur_block, top_stack->cur_st); + + /* f77 emits proc-level with address bounds==[0,0], + So look for such child blocks, and patch them. */ + for (i = 0; i < BLOCKVECTOR_NBLOCKS(bv); i++) { + struct block *b_bad = BLOCKVECTOR_BLOCK(bv,i); + if (BLOCK_SUPERBLOCK(b_bad) == b + && BLOCK_START(b_bad) == top_stack->procadr + && BLOCK_END(b_bad) == top_stack->procadr) { + BLOCK_START(b_bad) = BLOCK_START(b); + BLOCK_END(b_bad) = BLOCK_END(b); + } + } + } else if (sh->sc == scText && top_stack->blocktype == stBlock) { + /* End of (code) block. The value of the symbol + is the displacement from the procedure`s start + address of the end of this block. */ + BLOCK_END(top_stack->cur_block) = sh->value + top_stack->procadr; + (void) shrink_block(top_stack->cur_block, top_stack->cur_st); + } + pop_parse_stack(); /* restore previous lexical context */ + break; + + case stMember: /* member of struct/union/enum.. */ + f = new_field(top_stack->cur_type, sh->iss); + f->bitpos = sh->value; + f->type = parse_type(ax + sh->index, sh, &f->bitsize); + break; + + case stTypedef: /* type definition */ + s = new_symbol(sh->iss); + SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; + SYMBOL_CLASS(s) = LOC_TYPEDEF; + SYMBOL_BLOCK_VALUE(s) = top_stack->cur_block; + add_symbol(s, top_stack->cur_block); + SYMBOL_TYPE(s) = parse_type(ax + sh->index, sh, 0); + sh->value = (long) SYMBOL_TYPE(s); + break; + + case stFile: /* file name */ + push_parse_stack(); + top_stack->blocktype = sh->st; + break; + + /* I`ve never seen these for C */ + case stRegReloc: + break; /* register relocation */ + case stForward: + break; /* forwarding address */ + case stConstant: + break; /* constant */ + default: + error("Unknown symbol type %x.", sh->st); + } + sh->st = stParsed; +} + +/* Parse the type information provided in the AX entries for + the symbol SH. Return the bitfield size in BS, in case. */ + +static struct type *parse_type(ax, sh, bs) + AUXU *ax; + SYMR *sh; + int *bs; +{ + /* Null entries in this map are treated specially */ + static struct type **map_bt[] = + { + &builtin_type_void, /* btNil */ + 0, /* btAdr */ + &builtin_type_char, /* btChar */ + &builtin_type_unsigned_char, /* btUChar */ + &builtin_type_short, /* btShort */ + &builtin_type_unsigned_short, /* btUShort */ + &builtin_type_int, /* btInt */ + &builtin_type_unsigned_int, /* btUInt */ + &builtin_type_long, /* btLong */ + &builtin_type_unsigned_long, /* btULong */ + &builtin_type_float, /* btFloat */ + &builtin_type_double, /* btDouble */ + 0, /* btStruct */ + 0, /* btUnion */ + 0, /* btEnum */ + 0, /* btTypedef */ + 0, /* btRange */ + 0, /* btSet */ + &builtin_type_complex, /* btComplex */ + &builtin_type_double_complex, /* btDComplex */ + 0, /* btIndirect */ + &builtin_type_fixed_dec, /* btFixedDec */ + &builtin_type_float_dec, /* btFloatDec */ + &builtin_type_string, /* btString */ + 0, /* btBit */ + 0, /* btPicture */ + &builtin_type_void, /* btVoid */ + }; + + TIR *t; + struct type *tp = 0, *tp1; + char *fmt = "%s"; + + /* Procedures start off by one */ + if (sh->st == stProc || sh->st == stStaticProc) + ax++; + + /* Undefined ? Should not happen */ + if (ax->rndx.rfd == 0xfff) { + return builtin_type_void; + } + + /* Use aux as a type information record, map its basic type */ + t = &ax->ti; + if (t->bt > 26 || t->bt == btPicture) { + printf_filtered("Internal: cannot map MIPS basic type x%x\n", t->bt); + return builtin_type_int; + } + if (map_bt[t->bt]) + tp = *map_bt[t->bt]; + else { + /* Cannot use builtin types, use templates */ + tp = make_type(TYPE_CODE_VOID, 0, 0, 0); + switch (t->bt) { + case btAdr: + *tp = *builtin_type_ptr; + break; + case btStruct: + *tp = *builtin_type_struct; + fmt = "struct %s"; + break; + case btUnion: + *tp = *builtin_type_union; + fmt = "union %s"; + break; + case btEnum: + *tp = *builtin_type_enum; + fmt = "enum %s"; + break; + case btRange: + *tp = *builtin_type_range; + break; + case btSet: + *tp = *builtin_type_set; + fmt = "set %s"; + break; + } + } + + /* Move on to next aux */ + ax++; + if (t->continued) { + /* This is the way it would work if the compiler worked */ + register TIR *t1 = t; + while (t1->continued) + ax++; + } + + /* For bitfields all we need is the width */ + if (t->fBitfield) { + *bs = ax->width; + return tp; + } + + /* All these types really point to some (common) MIPS type + definition, and only the type-qualifiers fully identify + them. We`ll make the same effort at sharing */ + if (t->bt == btIndirect || + t->bt == btStruct || + t->bt == btUnion || + t->bt == btEnum || + t->bt == btTypedef || + t->bt == btRange || + t->bt == btSet) { + char name[256], *pn; + + /* Try to cross reference this type */ + tp1 = tp; + ax += cross_ref(ax, &tp1, &pn); + /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */ + sprintf(name, fmt, pn); + + /* reading .o file ? */ + if (UNSAFE_DATA_ADDR(tp1)) + tp1 = tp; + if (TYPE_CODE(tp1) == TYPE_CODE_UNDEF) { + /* + * Type was incompletely defined, now we know. + */ + TYPE_CODE(tp1) = TYPE_CODE(tp); + TYPE_NAME(tp1) = obsavestring(name, strlen(name)); + if (TYPE_CODE(tp1) == TYPE_CODE_ENUM) { + int i; + + for (i = 0; i < TYPE_NFIELDS(tp1); i++) + make_enum_constant(&TYPE_FIELD(tp1,i), tp1); + } + } + if (tp1 != tp) { + /* found as cross ref, rid of our template */ + if ((TYPE_FLAGS(tp) & TYPE_FLAG_PERM) == 0) + free(tp); + tp = tp1; + /* stupid idea of prepending "struct" to type names */ + if (t->bt == btStruct && !index(TYPE_NAME(tp), ' ')) { + sprintf(name, fmt, TYPE_NAME(tp)); + TYPE_NAME(tp) = obsavestring(name, strlen(name)); + } + } else + TYPE_NAME(tp) = savestring(name, strlen(name)); + } + + /* Deal with range types */ + if (t->bt == btRange) { + struct field *f; + + f = new_field(tp, "Low"); + f->bitpos = ax->dnLow; + ax++; + f = new_field(tp, "High"); + f->bitpos = ax->dnHigh; + ax++; + } + + /* Parse all the type qualifiers now. If there are more + than 6 the game will continue in the next aux */ + +#define PARSE_TQ(tq) \ + if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, sh); + +again: PARSE_TQ(tq0); + PARSE_TQ(tq1); + PARSE_TQ(tq2); + PARSE_TQ(tq3); + PARSE_TQ(tq4); + PARSE_TQ(tq5); +#undef PARSE_TQ + + if (t->continued) { + t++; + goto again; + } + return tp; +} + +/* Make up a complex type from a basic one. Type is passed by + reference in TPP and side-effected as necessary. The type + qualifier TQ says how to handle the aux symbols at AX for + the symbol SX we are currently analyzing. + Returns the number of aux symbols we parsed. */ + +static +upgrade_type(tpp, tq, ax, sh) + struct type **tpp; + AUXU *ax; + SYMR *sh; +{ + int off = 0; + int ret = 0; + struct type *t; + + if (tq == tqPtr) { + t = lookup_pointer_type (*tpp); + } else if (tq == tqProc) { + t = lookup_function_type (*tpp); + } else if (tq == tqArray) { + int rf, id; + FDR *fh; + struct field *f; + SYMR ss; + + t = make_type(TYPE_CODE_ARRAY, 0, 0, 0); + TYPE_TARGET_TYPE(t) = *tpp; + + /* Pointer to domain type (type of index) */ + id = ax->rndx.index; + if ((rf = ax->rndx.rfd) == 0xfff) + rf = (++ax)->isym, off++; + + fh = get_rfd(cur_fd, rf); + f = new_field(t, 0); + bzero(&ss, sizeof ss); +/* XXX */ f->type = parse_type(fh->iauxBase + id * sizeof(AUXU), + &ss, &f->bitsize); + + /* + * This seems to be a pointer to the end of the Block defining + * the type. Why it is here is magic for me, and I have no + * good use for it anyways. + */ + if (off == 0) { + off++; + id = (++ax)->rndx.index; + if ((rf = ax->rndx.rfd) == 0xfff) + rf = (++ax)->isym, off++; + } + f->bitpos = (++ax)->dnLow; /* ?? */ + f->bitsize = (++ax)->dnHigh; /* ?? */ + rf = (++ax)->width - 1; /* bit alignment */ + id = TYPE_LENGTH(TYPE_TARGET_TYPE(t)) << 3; /* bitsize */ + + if (id == 0) { + /* Most likely an undefined type */ + id = rf + 1; + TYPE_LENGTH(TYPE_TARGET_TYPE(t)) = id >> 3; + } + TYPE_LENGTH(t) = (f->bitsize < 0) ? 0 : + (f->bitsize - f->bitpos + 1) * (id >> 3); + ret = 4 + off; + } else { + if (tq != tqVol) + printf_filtered("Internal: unknown type qualifier %x\n", tq); + return ret; + } + + *tpp = t; + return ret; +} + + +/* Parse a procedure descriptor record PR. Note that the procedure + is parsed _after_ the local symbols, now we just make up the + extra information we need into a special symbol that we insert + in the procedure's main block. Note also that images that + have been partially stripped (ld -x) have been deprived + of local symbols, and we have to cope with them here. + The procedure's code ends at BOUND */ + +static +parse_procedure(pr, bound) + PDR *pr; +{ + struct symbol *s, *i; + SYMR *sh = (SYMR*)pr->isym; + struct block *b; + struct mips_extra_func_info *e; + char name[100]; + char *sh_name; + + /* Reuse the MIPS record */ + e = (struct mips_extra_func_info *) pr; + e->numargs = lookup_numargs(pr->adr); + + /* Make up our special symbol */ + i = new_symbol(".gdbinfo."); + SYMBOL_VALUE(i) = (int)e; + SYMBOL_NAMESPACE(i) = LABEL_NAMESPACE; + SYMBOL_CLASS(i) = LOC_CONST; + SYMBOL_TYPE(i) = builtin_type_void; + + /* Make up a name for static procedures. Sigh. */ + if (sh == (SYMR*)-1) { + sprintf(name,".static_procedure@%x",pr->adr); + sh_name = savestring(name, strlen(name)); + s = NULL; + } + else { + sh_name = (char*)sh->iss; + s = mylookup_symbol(sh_name, top_stack->cur_block, + VAR_NAMESPACE, LOC_BLOCK); + } + if (s != 0) { + b = SYMBOL_BLOCK_VALUE(s); + } else { + s = new_symbol(sh_name); + SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; + SYMBOL_CLASS(s) = LOC_BLOCK; + /* Donno its type, hope int is ok */ + SYMBOL_TYPE(s) = lookup_function_type (builtin_type_int); + add_symbol(s, top_stack->cur_block); + /* Wont have symbols for this one */ + b = new_block(2); + SYMBOL_BLOCK_VALUE(s) = b; + BLOCK_FUNCTION(b) = s; + BLOCK_START(b) = pr->adr; + BLOCK_END(b) = bound; + BLOCK_SUPERBLOCK(b) = top_stack->cur_block; + add_block(b, top_stack->cur_st); + } + e->isym = (long)s; + add_symbol(i,b); +} + +/* Parse the external symbol ES. Just call parse_symbol() after + making sure we know where the aux are for it. For procedures, + parsing of the PDRs has already provided all the needed + information, we only parse them if SKIP_PROCEDURES is false, + and only if this causes no symbol duplication */ + +static +parse_external(es, skip_procedures) + EXTR *es; +{ + AUXU *ax; + + if (es->ifd != ifdNil) { + cur_fd = es->ifd; + cur_fdr = (FDR*)(cur_hdr->cbFdOffset) + cur_fd; + ax = (AUXU*)cur_fdr->iauxBase; + } else { + cur_fdr = (FDR*)(cur_hdr->cbFdOffset); + ax = 0; + } + top_stack->cur_st = cur_stab; + top_stack->cur_block = BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack->cur_st),0); + + /* Reading .o files */ + if (es->asym.sc == scUndefined || es->asym.sc == scNil) { + char *what; + switch (es->asym.st) { + case stStaticProc: + case stProc: what = "Procedure"; n_undef_procs++; break; + case stGlobal: what = "Variable"; n_undef_vars++; break; + case stLabel: what = "Label"; n_undef_labels++; break; + default : what = "Symbol"; break; + } + n_undef_symbols++; + if (info_verbose) + printf_filtered("Warning: %s %s is undefined (in %s)\n", what, + es->asym.iss, fdr_name(cur_fdr->rss)); + return; + } + + switch (es->asym.st) { + case stProc: + /* If we have full symbols we do not need more */ + if (skip_procedures) + return; + if (mylookup_symbol (es->asym.iss, top_stack->cur_block, + VAR_NAMESPACE, LOC_BLOCK)) + break; + /* fall through */ + case stGlobal: + case stLabel: + /* + * Note that the case of a symbol with indexNil + * must be handled anyways by parse_symbol(). + */ + parse_symbol(&es->asym, ax); + break; + default: + break; + } +} + +/* Parse the line number info for file descriptor FH into + GDB's linetable LT. MIPS' encoding requires a little bit + of magic to get things out. Note also that MIPS' line + numbers can go back and forth, apparently we can live + with that and do not need to reorder our linetables */ + +static +parse_lines(fh, lt) + FDR *fh; + struct linetable *lt; +{ + char *base = (char*)fh->cbLineOffset; + int i, j, k; + int delta, count, lineno = 0; + PDR *pr; + + if (base == 0) + return; + + /* Scan by procedure descriptors */ + i = 0; j = 0, k = 0; + for (pr = (PDR*)IPDFIRST(cur_hdr,fh); j < fh->cpd; j++, pr++) { + int l, halt; + + /* No code for this one */ + if (pr->iline == ilineNil || + pr->lnLow == -1 || pr->lnHigh == -1) + continue; + /* + * Aurgh! To know where to stop expanding we + * must look-ahead. + */ + for (l = 1; l < (fh->cpd - j); l++) + if (pr[l].iline != -1) + break; + if (l == (fh->cpd - j)) + halt = fh->cline; + else + halt = pr[l].iline; + /* + * When procedures are moved around the linenumbers + * are attributed to the next procedure up + */ + if (pr->iline >= halt) continue; + + base = (char*)pr->cbLineOffset; + l = pr->adr >> 2; /* in words */ + halt += (pr->adr >> 2) - pr->iline; + for (lineno = pr->lnLow; l < halt;) { + count = *base & 0x0f; + delta = *base++ >> 4; + if (delta == -8) { + delta = (base[0] << 8) | (base[1] & 0xff); + base += 2; + } + lineno += delta;/* first delta is 0 */ + k = add_line(lt, lineno, l, k); + l += count + 1; + } + } +} + + +/* Parse the symbols of the file described by FH, whose index is F_IDX. + BOUND is the highest core address of this file's procedures */ + +static +parse_one_file(fh, f_idx, bound) + FDR *fh; +{ + register int s_idx; + SYMR *sh; + PDR *pr; + + /* Parse local symbols first */ + + for (s_idx = 0; s_idx < fh->csym; s_idx++) { + sh = (SYMR *) (fh->isymBase) + s_idx; + cur_sdx = s_idx; + parse_symbol(sh, fh->iauxBase); + } + + /* Procedures next, note we need to look-ahead to + find out where the procedure's code ends */ + + for (s_idx = 0; s_idx < fh->cpd-1; s_idx++) { + pr = (PDR *) (IPDFIRST(cur_hdr, fh)) + s_idx; + parse_procedure(pr, pr[1].adr); /* next proc up */ + } + if (fh->cpd) { + pr = (PDR *) (IPDFIRST(cur_hdr, fh)) + s_idx; + parse_procedure(pr, bound); /* next file up */ + } + + /* Linenumbers. At the end, check if we can save memory */ + parse_lines(fh, LINETABLE(cur_stab)); + if (LINETABLE(cur_stab)->nitems < fh->cline) + shrink_linetable(cur_stab); +} + + +/* Master parsing procedure. Parses the symtab described by the + symbolic header HDR. If INCREMENTAL is true we are called + by add-file and must preserve the old symtabs */ +static +parse_partial_symbols(hdr, incremental) + HDRR *hdr; +{ + int f_idx, s_idx, h_max; + CORE_ADDR dummy, *prevhigh; + /* Running pointers */ + FDR *fh; + RFDT *rh; + register EXTR *esh; + + /* + * Big plan: + * + * Only parse the External symbols, and the Relative FDR. + * Fixup enough of the loader symtab to be able to use it. + * Allocate space only for the file`s portions we need to + * look at. (XXX) + */ + + cur_hdr = hdr; + max_gdbinfo = 0; + max_glevel = MIN_GLEVEL; + + /* Allocate the map FDR -> PST. + Minor hack: -O3 images might claim some global data belongs + to FDR -1. We`ll go along with that */ + fdr_to_pst = (struct pst_map *)xzalloc((hdr->ifdMax+1) * sizeof *fdr_to_pst); + fdr_to_pst++; + { + struct partial_symtab * pst = new_psymtab(""); + fdr_to_pst[-1].pst = pst; + pst->ldsymoff = -1; + } + + /* Now scan the FDRs, mostly for dependencies */ + for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) + (void) parse_fdr(f_idx, 1); + + /* Take a good guess at how many symbols we might ever need */ + h_max = hdr->iextMax; + + /* Parse externals: two passes because they can be ordered + in any way */ + + /* Pass 1: Presize and partition the list */ + for (s_idx = 0; s_idx < hdr->iextMax; s_idx++) { + esh = (EXTR *) (hdr->cbExtOffset) + s_idx; + fdr_to_pst[esh->ifd].n_globals++; + } + + if (global_psymbols.list) { + global_psymbols.list = (struct partial_symbol *) + xrealloc( global_psymbols.list, (h_max + + global_psymbols.size) * sizeof(struct partial_symbol)); + global_psymbols.next = global_psymbols.list + global_psymbols.size; + global_psymbols.size += h_max; + } else { + global_psymbols.list = (struct partial_symbol *) + xmalloc( h_max * sizeof(struct partial_symbol)); + global_psymbols.size = h_max; + global_psymbols.next = global_psymbols.list; + } + + s_idx = global_psymbols.next - global_psymbols.list; + for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++) { + fdr_to_pst[f_idx].pst->globals_offset = s_idx; + s_idx += fdr_to_pst[f_idx].n_globals; + } + + /* Pass 2: fill in symbols */ + for (s_idx = 0; s_idx < hdr->iextMax; s_idx++) { + register struct partial_symbol *p; + enum misc_function_type misc_type = mf_text; + esh = (EXTR *) (hdr->cbExtOffset) + s_idx; + + if (esh->asym.sc == scUndefined || esh->asym.sc == scNil) + continue; + p = new_psymbol(&global_psymbols, esh->asym.iss, esh->ifd); + SYMBOL_VALUE(p) = esh->asym.value; + SYMBOL_NAMESPACE(p) = VAR_NAMESPACE; + + switch (esh->asym.st) { + case stProc: + SYMBOL_CLASS(p) = LOC_BLOCK; + break; + case stGlobal: + SYMBOL_CLASS(p) = LOC_STATIC; + misc_type = mf_data; + break; + case stLabel: + SYMBOL_CLASS(p) = LOC_LABEL; + break; + default: + misc_type = mf_unknown; + complain (&unknown_ext_complaint, SYMBOL_NAME(p)); + } + prim_record_misc_function (SYMBOL_NAME(p), + SYMBOL_VALUE(p), + misc_type); + } + + + /* The array (of lists) of globals must be sorted. + Take care, since we are at it, of pst->texthigh. + + NOTE: The way we handle textlow/high is incorrect, but good + enough for a first approximation. The case we fail is on a + file "foo.c" that looks like + proc1() {...} + #include "bar.c" -- this contains proc2() + proc3() {...} + where proc3() is attributed to bar.c. But since this is a + dependent file it will cause loading of foo.c as well, so + everything will be fine at the end. */ + + prevhigh = &dummy; + for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) { + struct partial_symtab *pst = fdr_to_pst[f_idx].pst; + if (pst->n_global_syms > 1) + qsort (global_psymbols.list + pst->globals_offset, + pst->n_global_syms, sizeof (struct partial_symbol), + compare_psymbols); + if (pst->textlow) { + *prevhigh = pst->textlow; + prevhigh = &pst->texthigh; + } + } + + /* Mark the last code address, and remember it for later */ + *prevhigh = END_OF_TEXT_SEGMENT(filhdr); + hdr->cbDnOffset = END_OF_TEXT_SEGMENT(filhdr); + + reorder_psymtabs(); + free(&fdr_to_pst[-1]); + fdr_to_pst = 0; +} + + +/* Do the initial analisys of the F_IDX-th file descriptor. + Allocates a partial symtab for it, and builds the list + of dependent files by recursion. LEV says at which level + of recursion we are called (to pretty up debug traces) */ + +static struct partial_symtab * +parse_fdr(f_idx, lev) + int f_idx; +{ + register FDR *fh; + register struct partial_symtab *pst; + int s_idx, s_id0; + + fh = (FDR *) (cur_hdr->cbFdOffset) + f_idx; + + /* Use this to indicate into which symtab this file was parsed */ + if (fh->ioptBase) + return (struct partial_symtab *) fh->ioptBase; + + /* Debuggability level */ + if (compare_glevel(max_glevel, fh->glevel) < 0) + max_glevel = fh->glevel; + + /* Make a new partial_symtab */ + pst = new_psymtab(fh->rss); + if (fh->cpd == 0){ + pst->textlow = 0; + pst->texthigh = 0; + } else { + pst->textlow = fh->adr; + pst->texthigh = fh->cpd; /* To be fixed later */ + } + /* Reverse mapping PST -> FDR */ + pst->ldsymoff = f_idx; + + fdr_to_pst[f_idx].pst = pst; + fh->ioptBase = (int)pst; + + /* Analyze its dependencies */ + if (fh->crfd <= 1) + return pst; + + s_id0 = 0; + if (fh->cpd == 0) { /* If there are no functions defined here ... */ + /* ...then presumably a .h file: drop reverse depends .h->.c */ + for (; s_id0 < fh->crfd; s_id0++) { + RFDT *rh = (RFDT *) (fh->rfdBase) + s_id0; + if (*rh == f_idx) { + s_id0++; /* Skip self-dependency */ + break; + } + } + } + pst->number_of_dependencies = fh->crfd - s_id0; + pst->dependencies = (struct partial_symtab **) + obstack_alloc (psymbol_obstack, + pst->number_of_dependencies * sizeof(char*)); + for (s_idx = s_id0; s_idx < fh->crfd; s_idx++) { + RFDT *rh = (RFDT *) (fh->rfdBase) + s_idx; + + pst->dependencies[s_idx-s_id0] = parse_fdr(*rh, lev+1); + + } + + return pst; +} + + +/* Ancillary function to psymtab_to_symtab(). Does all the work + for turning the partial symtab PST into a symtab, recurring + first on all dependent psymtabs */ + +static void psymtab_to_symtab_1(pst) + struct partial_symtab *pst; +{ + int i, f_max; + struct symtab *st; + FDR *fh; + + if (pst->readin) + return; + pst->readin = 1; + + pending_list = (struct pending **) cur_hdr->cbOptOffset; + if (pending_list == 0) { + pending_list = (struct pending **) + xzalloc(cur_hdr->ifdMax * sizeof(struct pending *)); + cur_hdr->cbOptOffset = (int)pending_list; + } + + /* How many symbols will we need */ + f_max = pst->n_global_syms + pst->n_static_syms; + if (pst->ldsymoff == -1) { + fh = 0; + st = new_symtab( "unknown", f_max, 0); + } else { + fh = (FDR *) (cur_hdr->cbFdOffset) + pst->ldsymoff; + f_max += fh->csym + fh->cpd; + st = new_symtab(pst->filename, 2 * f_max, 2 * fh->cline); + } + + /* + * Read in all partial symbtabs on which this one is dependent. + * NOTE that we do have circular dependencies, sigh. + */ + for (i = 0; i < pst->number_of_dependencies; i++) + if (!pst->dependencies[i]->readin) { + /* + * DO NOT inform about additional files that need to + * be read in, it would only annoy the user. + */ + psymtab_to_symtab_1(pst->dependencies[i]); + } + + /* Now read the symbols for this symtab */ + + cur_fd = pst->ldsymoff; + cur_fdr = fh; + cur_stab = st; + + /* Get a new lexical context */ + + push_parse_stack(); + top_stack->cur_st = cur_stab; + top_stack->cur_block = BLOCKVECTOR_BLOCK(BLOCKVECTOR(cur_stab), 0); + BLOCK_START(top_stack->cur_block) = fh ? fh->adr : 0; + BLOCK_END(top_stack->cur_block) = 0; + top_stack->blocktype = stFile; + top_stack->maxsyms = f_max; + top_stack->cur_type = 0; + top_stack->procadr = 0; + top_stack->numargs = 0; + + /* Parse locals and procedures */ + if (fh) + parse_one_file(fh, cur_fd, (cur_fd == (cur_hdr->ifdMax - 1)) ? + cur_hdr->cbDnOffset : fh[1].adr); + + /* .. and our share of externals. + XXX use the global list to speed up things here. how ? */ + top_stack->blocktype = stFile; + top_stack->maxsyms = cur_hdr->isymMax + cur_hdr->ipdMax + cur_hdr->iextMax; + for (i = 0; i < cur_hdr->iextMax; i++) { + register EXTR *esh = (EXTR *) (cur_hdr->cbExtOffset) + i; + if (esh->ifd == cur_fd) + parse_external(esh, 1); + } + + /* If there are undefined, tell the user */ + if (n_undef_symbols) { + printf_filtered("File %s contains %d unresolved references:", + st->filename, n_undef_symbols); + printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n", + n_undef_vars, n_undef_procs, n_undef_labels); + n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0; + } + + pop_parse_stack(); + + /* + * Sort the symbol table now, we are done adding symbols to it. + */ + sort_symtab_syms(st); +} + + + + +/* Ancillary parsing procedures. */ + +/* Lookup the type at relative index RN. Return it in TPP + if found and in any event come up with its name PNAME. + Return value says how many aux symbols we ate */ + +static +cross_ref(rn, tpp, pname) + RNDXR *rn; + struct type **tpp; + char **pname; +{ + unsigned rf; + + /* Escape index means 'the next one' */ + if (rn->rfd == 0xfff) + rf = *(unsigned *) (rn + 1); + else + rf = rn->rfd; + + if (rf == -1) { + /* Ooops */ + *pname = "<undefined>"; + } else { + /* + * Find the relative file descriptor and the symbol in it + */ + FDR *fh = get_rfd(cur_fd, rf); + SYMR *sh; + struct type *t; + + /* + * If we have processed this symbol then we left a forwarding + * pointer to the corresponding GDB symbol. If not, we`ll put + * it in a list of pending symbols, to be processed later when + * the file f will be. In any event, we collect the name for + * the type here. Which is why we made a first pass at + * strings. + */ + sh = (SYMR *) (fh->isymBase) + rn->index; + + /* Careful, we might be looking at .o files */ + *pname = (UNSAFE_DATA_ADDR(sh->iss)) ? "<undefined>" : + (char *) sh->iss; + + /* Have we parsed it ? */ + if ((!UNSAFE_DATA_ADDR(sh->value)) && (sh->st == stParsed)) { + t = (struct type *) sh->value; + *tpp = t; + } else { + struct pending *p; + + /* Avoid duplicates */ + p = is_pending_symbol(fh, sh); + + if (p) + *tpp = p->t; + else + add_pending(fh, sh, *tpp); + } + } + return (rn->rfd == 0xfff); +} + + +/* Quick&dirty lookup procedure, to avoid the MI ones that require + keeping the symtab sorted */ + +static struct symbol * +mylookup_symbol (name, block, namespace, class) + char *name; + register struct block *block; + enum namespace namespace; + enum address_class class; +{ + register int bot, top, inc; + register struct symbol *sym; + + bot = 0; + top = BLOCK_NSYMS(block); + inc = name[0]; + while (bot < top) { + sym = BLOCK_SYM(block, bot); + if (SYMBOL_NAME(sym)[0] == inc + && SYMBOL_NAMESPACE(sym) == namespace + && SYMBOL_CLASS(sym) == class + && !strcmp(SYMBOL_NAME(sym), name)) + return sym; + bot++; + } + if (block = BLOCK_SUPERBLOCK (block)) + return mylookup_symbol (name, block, namespace, class); + return 0; +} + + +/* Add a new symbol S to a block B */ + +static +add_symbol(s,b) + struct symbol *s; + struct block *b; +{ + BLOCK_SYM(b,BLOCK_NSYMS(b)++) = s; + if (b == top_stack->cur_block && + BLOCK_NSYMS(b) > top_stack->maxsyms) + printf_filtered("Internal: block at @%x overfilled (by %d)\n", + b, BLOCK_NSYMS(b) - top_stack->maxsyms); +} + +/* Add a new block B to a symtab S */ + +static +add_block(b,s) + struct block *b; + struct symtab *s; +{ + struct blockvector *bv = BLOCKVECTOR(s); + + bv = (struct blockvector *)xrealloc(bv, sizeof(struct blockvector) + + BLOCKVECTOR_NBLOCKS(bv) * sizeof(bv->block)); + if (bv != BLOCKVECTOR(s)) + BLOCKVECTOR(s) = bv; + + BLOCKVECTOR_BLOCK(bv, BLOCKVECTOR_NBLOCKS(bv)++) = b; +} + +/* Add a new linenumber entry (LINENO,ADR) to a linevector LT. + MIPS' linenumber encoding might need more than one byte + to describe it, LAST is used to detect these continuation lines */ + +static +add_line(lt, lineno, adr, last) + struct linetable *lt; + CORE_ADDR adr; +{ + if (last == 0) + last = -2; /* make sure we record first line */ + + if (last == lineno) /* skip continuation lines */ + return lineno; + + lt->item[lt->nitems].line = lineno; + lt->item[lt->nitems++].pc = adr << 2; + return lineno; +} + + + +/* Comparison functions, used when sorting things */ + +/* Symtabs must be ordered viz the code segments they cover */ + +static int +compare_symtabs( s1, s2) + struct symtab **s1, **s2; +{ + /* "most specific" first */ + + register struct block *b1, *b2; + b1 = BLOCKVECTOR_BLOCK(BLOCKVECTOR(*s1),0); + b2 = BLOCKVECTOR_BLOCK(BLOCKVECTOR(*s2),0); + if (BLOCK_END(b1) == BLOCK_END(b2)) + return BLOCK_START(b1) - BLOCK_START(b2); + return BLOCK_END(b1) - BLOCK_END(b2); +} + + +/* Partial Symtabs, same */ + +static int +compare_psymtabs( s1, s2) + struct partial_symtab **s1, **s2; +{ + /* Perf twist: put the ones with no code at the end */ + + register int a = (*s1)->textlow; + register int b = (*s2)->textlow; + if (a == 0) + return b; + if (b == 0) + return -a; + return a - b; +} + + +/* Partial symbols are compared lexicog by their print names */ + +static int +compare_psymbols (s1, s2) + register struct partial_symbol *s1, *s2; +{ + register char + *st1 = SYMBOL_NAME(s1), + *st2 = SYMBOL_NAME(s2); + + return (st1[0] - st2[0] ? st1[0] - st2[0] : + strcmp(st1 + 1, st2 + 1)); +} + +/* Blocks with a smaller low bound should come first */ + +static int compare_blocks(b1,b2) + struct block **b1, **b2; +{ + register int addr_diff; + + addr_diff = (BLOCK_START((*b1))) - (BLOCK_START((*b2))); + if (addr_diff == 0) + return (BLOCK_END((*b1))) - (BLOCK_END((*b2))); + return addr_diff; +} + + +/* Sorting and reordering procedures */ + +/* Sort the blocks of a symtab S. + Reorder the blocks in the blockvector by code-address, + as required by some MI search routines */ + +static +sort_blocks(s) + struct symtab *s; +{ + struct blockvector *bv = BLOCKVECTOR(s); + + if (BLOCKVECTOR_NBLOCKS(bv) <= 2) { + /* Cosmetic */ + if (BLOCK_END(BLOCKVECTOR_BLOCK(bv,0)) == 0) + BLOCK_START(BLOCKVECTOR_BLOCK(bv,0)) = 0; + return; + } + /* + * This is very unfortunate: normally all functions are compiled in + * the order they are found, but if the file is compiled -O3 things + * are very different. It would be nice to find a reliable test + * to detect -O3 images in advance. + */ + if (BLOCKVECTOR_NBLOCKS(bv) > 3) + qsort(&BLOCKVECTOR_BLOCK(bv,2), + BLOCKVECTOR_NBLOCKS(bv) - 2, + sizeof(struct block *), + compare_blocks); + + { + register CORE_ADDR high = 0; + register int i, j = BLOCKVECTOR_NBLOCKS(bv); + + for (i = 2; i < j; i++) + if (high < BLOCK_END(BLOCKVECTOR_BLOCK(bv,i))) + high = BLOCK_END(BLOCKVECTOR_BLOCK(bv,i)); + BLOCK_END(BLOCKVECTOR_BLOCK(bv,0)) = high; + } + + BLOCK_START(BLOCKVECTOR_BLOCK(bv,0)) = BLOCK_START(BLOCKVECTOR_BLOCK(bv,2)); + + BLOCK_START(BLOCKVECTOR_BLOCK(bv,1)) = BLOCK_START(BLOCKVECTOR_BLOCK(bv,0)); + BLOCK_END (BLOCKVECTOR_BLOCK(bv,1)) = BLOCK_END (BLOCKVECTOR_BLOCK(bv,0)); +} + +/* Sort the symtab list, as required by some search procedures. + We want files ordered to make them look right to users, and for + searching (see block_for_pc). */ + +static +reorder_symtabs() +{ + register int i; + struct symtab *stab; + struct symtab **all_symtabs = (struct symtab **) + obstack_alloc (psymbol_obstack, + all_symtabs_count * sizeof (struct symtab *)); + + /* Create an array of pointers to all the symtabs. */ + for (i = 0, stab = symtab_list; + i < all_symtabs_count; + i++, stab = stab->next) { + all_symtabs[i] = stab; + /* FIXME: Only do this for new symtabs ??? */ + sort_blocks(all_symtabs[i]); + } + + qsort(all_symtabs, all_symtabs_count, + sizeof(struct symtab *), compare_symtabs); + + /* Re-construct the symtab list, but now it is sorted. */ + for (i = 0; i < all_symtabs_count-1; i++) + all_symtabs[i]->next = all_symtabs[i+1]; + all_symtabs[i]->next = 0; + symtab_list = all_symtabs[0]; + obstack_free (psymbol_obstack, all_symtabs); +} + +/* Sort the partial symtab list, as required by some search procedures */ + +static reorder_psymtabs() +{ + register int i; + struct partial_symtab *pstab; + + /* + * PC lookups stop at the first psymtab such that + * textlow <= PC < texthigh + */ + /* Create an array of pointers to all the partial_symtabs. */ + struct partial_symtab **all_psymtabs = (struct partial_symtab **) + obstack_alloc (psymbol_obstack, + all_psymtabs_count*sizeof(struct partial_symtab*)); + for (i = 0, pstab = partial_symtab_list; + i < all_psymtabs_count; + i++, pstab = pstab->next) + all_psymtabs[i] = pstab; + + qsort(all_psymtabs, all_psymtabs_count, + sizeof(struct partial_symtab *), compare_psymtabs); + + /* Re-construct the partial_symtab_list, but now it is sorted. */ + + for (i = 0; i < all_psymtabs_count-1; i++) + all_psymtabs[i]->next = all_psymtabs[i+1]; + all_psymtabs[i]->next = 0; + partial_symtab_list = all_psymtabs[0]; + + obstack_free (psymbol_obstack, all_psymtabs); +} + + + +/* Constructor/restructor/destructor procedures */ + +/* Allocate a new symtab for NAME. Needs an estimate of how many symbols + MAXSYMS and linenumbers MAXLINES we'll put in it */ + +static +struct symtab * +new_symtab(name, maxsyms, maxlines) + char *name; +{ + struct symtab *s = (struct symtab *) xzalloc(sizeof(struct symtab)); + int i; + + LINETABLE(s) = new_linetable(maxlines); + + s->filename = name; + + /* All symtabs must have at least two blocks */ + BLOCKVECTOR(s) = new_bvect(2); + BLOCKVECTOR_BLOCK(BLOCKVECTOR(s), 0) = new_block(maxsyms); + BLOCKVECTOR_BLOCK(BLOCKVECTOR(s), 1) = new_block(maxsyms); + BLOCK_SUPERBLOCK( BLOCKVECTOR_BLOCK(BLOCKVECTOR(s),1)) = + BLOCKVECTOR_BLOCK(BLOCKVECTOR(s), 0); + + s->free_code = free_linetable; + + /* Link the new symtab into the list of such. */ + s->next = symtab_list; + symtab_list = s; + + all_symtabs_count++; + + return s; +} + +/* Cleanup before loading a fresh image */ + +static destroy_all_symtabs() +{ + if (symfile) + free(symfile); + symfile = 0; + + free_all_symtabs(); + all_symtabs_count = 0; + current_source_symtab = 0; + /* psymtabs! */ +} + +/* Allocate a new partial_symtab NAME */ + +static struct partial_symtab * +new_psymtab(name) + char *name; +{ + struct partial_symtab *pst; + + pst = (struct partial_symtab *) + obstack_alloc (psymbol_obstack, sizeof (*pst)); + bzero (pst, sizeof (*pst)); + + if (name == (char*)-1) /* FIXME -- why not null here? */ + pst->filename = "<no name>"; + else + pst->filename = name; + + pst->next = partial_symtab_list; + partial_symtab_list = pst; + all_psymtabs_count++; + + /* Keep a backpointer to the file`s symbols */ + pst->ldsymlen = (int)cur_hdr; + + /* The way to turn this into a symtab is to call... */ + pst->read_symtab = mipscoff_psymtab_to_symtab; + + return pst; +} + + +/* Allocate a new NAME psymbol from LIST, extending it if necessary. + The psymbol belongs to the psymtab at index PST_IDX */ + +static struct partial_symbol * +new_psymbol(list, name, pst_idx) + struct psymbol_allocation_list *list; + char *name; +{ + struct partial_symbol *p; + struct partial_symtab *pst = fdr_to_pst[pst_idx].pst; + + /* Lists are pre-sized, we won`t overflow */ + + p = list->list + pst->globals_offset + pst->n_global_syms++; + SYMBOL_NAME(p) = name; + return p; +} + + +/* Allocate a linetable array of the given SIZE */ + +static +struct linetable *new_linetable(size) +{ + struct linetable *l; + + size = size * sizeof(l->item) + sizeof(struct linetable); + l = (struct linetable *)xmalloc(size); + l->nitems = 0; + return l; +} + +/* Oops, too big. Shrink it. This was important with the 2.4 linetables, + I am not so sure about the 3.4 ones */ + +static shrink_linetable(s) + struct symtab *s; +{ + struct linetable *l = new_linetable(LINETABLE(s)->nitems); + + bcopy(LINETABLE(s), l, + LINETABLE(s)->nitems * sizeof(l->item) + sizeof(struct linetable)); + free (LINETABLE(s)); + LINETABLE(s) = l; +} + +/* Allocate and zero a new blockvector of NBLOCKS blocks. */ + +static +struct blockvector *new_bvect(nblocks) +{ + struct blockvector *bv; + int size; + + size = sizeof(struct blockvector) + nblocks * sizeof(struct block*); + bv = (struct blockvector *) xzalloc(size); + + BLOCKVECTOR_NBLOCKS(bv) = nblocks; + + return bv; +} + +/* Allocate and zero a new block of MAXSYMS symbols */ + +static +struct block *new_block(maxsyms) +{ + int size = sizeof(struct block) + (maxsyms-1) * sizeof(struct symbol *); + struct block *b = (struct block *)xzalloc(size); + + return b; +} + +/* Ooops, too big. Shrink block B in symtab S to its minimal size */ + +static struct block * +shrink_block(b, s) + struct block *b; + struct symtab *s; +{ + struct block *new; + struct blockvector *bv = BLOCKVECTOR(s); + int i; + + /* Just get a new one, copy, and fix references to the old one */ + + new = (struct block *)xmalloc(sizeof(struct block) + + (BLOCK_NSYMS(b)-1) * sizeof(struct symbol *)); + + bcopy(b, new, sizeof(*new) + (BLOCK_NSYMS(b) - 1) * sizeof(struct symbol*)); + + /* Should chase pointers to old one. Fortunately, that`s just + the block`s function and inferior blocks */ + if (BLOCK_FUNCTION(b) && SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(b)) == b) + SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(b)) = new; + for (i = 0; i < BLOCKVECTOR_NBLOCKS(bv); i++) + if (BLOCKVECTOR_BLOCK(bv,i) == b) + BLOCKVECTOR_BLOCK(bv,i) = new; + else if (BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv,i)) == b) + BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv,i)) = new; + free(b); + return new; +} + +/* Create a new symbol with printname NAME */ + +static +struct symbol * +new_symbol(name) + char *name; +{ + struct symbol *s = (struct symbol *) + obstack_alloc (symbol_obstack, sizeof (struct symbol)); + + bzero (s, sizeof (*s)); + SYMBOL_NAME(s) = name; + return s; +} + +/* Create a new type with printname NAME */ + +static +struct type * +new_type(name) + char *name; +{ + struct type *t = (struct type *) + obstack_alloc (symbol_obstack, sizeof (struct type)); + + bzero (t, sizeof (*t)); + TYPE_NAME(t) = name; + return t; +} + +/* Create and initialize a new type with printname NAME. + CODE and LENGTH are the initial info we put in, + UNS says whether the type is unsigned or not. */ + +static +struct type * +make_type(code, length, uns, name) + enum type_code code; + int length, uns; + char *name; +{ + register struct type *type; + + type = (struct type *) xzalloc(sizeof(struct type)); + TYPE_CODE(type) = code; + TYPE_LENGTH(type) = length; + TYPE_FLAGS(type) = uns ? TYPE_FLAG_UNSIGNED : 0; + TYPE_NAME(type) = name; + + return type; +} + +/* Allocate a new field named NAME to the type TYPE */ + +static +struct field *new_field(type,name) + struct type *type; + char *name; +{ + struct field *f; + + /* Fields are kept in an array */ + if (TYPE_NFIELDS(type)) + TYPE_FIELDS(type) = (struct field*)xrealloc(TYPE_FIELDS(type), + (TYPE_NFIELDS(type)+1) * sizeof(struct field)); + else + TYPE_FIELDS(type) = (struct field*)xzalloc(2*sizeof(struct field)); + f = &(TYPE_FIELD(type,TYPE_NFIELDS(type)++)); + bzero(f, sizeof(struct field)); + if (name) + f->name = name; + return f; +} + +/* Make an enum constant for a member F of an enumerated type T */ + +static +make_enum_constant(f,t) + struct field *f; + struct type *t; +{ + struct symbol *s; + /* + * This is awful, but that`s the way it is supposed to be + * (BTW, no need to free the real 'type', it's a builtin) + */ + f->type = (struct type *) f->bitpos; + + s = new_symbol(f->name); + SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; + SYMBOL_CLASS(s) = LOC_CONST; + SYMBOL_TYPE(s) = t; + SYMBOL_VALUE(s) = f->bitpos; + add_symbol(s, top_stack->cur_block); +} + + + +/* Things used for calling functions in the inferior. + These functions are exported to our companion + mips-dep.c file and are here because they play + with the symbol-table explicitly. */ + +#if 0 +/* Need to make a new symbol on the fly for the dummy + frame we put on the stack. Which goes in the.. */ + +static struct symtab *dummy_symtab; + +/* Make up a dummy symbol for the code we put at END_PC, + of size SIZE, invoking a function with NARGS arguments + and using a frame of FRAMESIZE bytes */ + +mips_create_dummy_symbol(end_pc, size, nargs, framesize) +{ + struct block *bl; + struct symbol *g; + struct mips_extra_func_info *gdbinfo; + + /* Allocate symtab if not done already */ + if (dummy_symtab == 0) + dummy_symtab = new_symtab(".dummy_symtab.", 100, 0); + + /* Make a new block. Only needs one symbol */ + bl = new_block(1); + BLOCK_START(bl) = end_pc - size; + BLOCK_END(bl) = end_pc; + + BLOCK_SUPERBLOCK(bl) = BLOCKVECTOR_BLOCK(BLOCKVECTOR(dummy_symtab),0); + add_block(bl, dummy_symtab); + sort_blocks(dummy_symtab); + + BLOCK_FUNCTION(bl) = new_symbol("??"); + SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(bl)) = bl; + g = new_symbol(".gdbinfo."); + BLOCK_SYM(bl,BLOCK_NSYMS(bl)++) = g; + + SYMBOL_NAMESPACE(g) = LABEL_NAMESPACE; + SYMBOL_CLASS(g) = LOC_CONST; + SYMBOL_TYPE(g) = builtin_type_void; + gdbinfo = (struct mips_extra_func_info *) + xzalloc(sizeof(struct mips_extra_func_info)); + + SYMBOL_VALUE(g) = (long) gdbinfo; + + gdbinfo->numargs = nargs; + gdbinfo->framesize = framesize; + gdbinfo->framereg = 29; + gdbinfo->pcreg = 31; + gdbinfo->regmask = -2; + gdbinfo->regoffset = -4; + gdbinfo->fregmask = 0; /* XXX */ + gdbinfo->fregoffset = 0; /* XXX */ +} + +/* We just returned from the dummy code at END_PC, drop its symbol */ + +mips_destroy_dummy_symbol(end_pc) +{ + struct block *bl; + struct blockvector *bv = BLOCKVECTOR(dummy_symtab); + int i; + + bl = block_for_pc(end_pc); + free(BLOCK_FUNCTION(bl)); + free(SYMBOL_VALUE(BLOCK_SYM(bl,0))); + free(BLOCK_SYM(bl,0)); + + for (i = 2; i < BLOCKVECTOR_NBLOCKS(bv); i++) + if (BLOCKVECTOR_BLOCK(bv,i) == bl) + break; + for (; i < BLOCKVECTOR_NBLOCKS(bv) - 1; i++) + BLOCKVECTOR_BLOCK(bv,i) = BLOCKVECTOR_BLOCK(bv,i+1); + BLOCKVECTOR_NBLOCKS(bv)--; + sort_blocks(dummy_symtab); + free(bl); +} +#endif + +/* Sigtramp: make sure we have all the necessary information + about the signal trampoline code. Since the official code + from MIPS does not do so, we make up that information ourselves. + If they fix the library (unlikely) this code will neutralize itself. */ + +static +fixup_sigtramp() +{ + struct symbol *s; + struct symtab *st; + struct block *b, *b0; + + sigtramp_address = -1; + + /* We know it is sold as sigvec */ + s = lookup_symbol("sigvec", 0, VAR_NAMESPACE, 0, NULL); + + /* Most programs do not play with signals */ + if (s == 0) + return; + + b0 = SYMBOL_BLOCK_VALUE(s); + + /* A label of sigvec, to be more precise */ + s = lookup_symbol("sigtramp", b0, VAR_NAMESPACE, 0, NULL); + + /* But maybe this program uses its own version of sigvec */ + if (s == 0) + return; + + sigtramp_address = SYMBOL_VALUE(s); + sigtramp_end = sigtramp_address + 0x88; /* black magic */ + + /* Did we or MIPSco fix the library ? */ + if (SYMBOL_CLASS(s) == LOC_BLOCK) + return; + + /* But what symtab does it live in ? */ + st = find_pc_symtab(SYMBOL_VALUE(s)); + + /* + * Ok, there goes the fix: turn it into a procedure, with all the + * needed info. Note we make it a nested procedure of sigvec, + * which is the way the (assembly) code is actually written. + */ + SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; + SYMBOL_CLASS(s) = LOC_BLOCK; + SYMBOL_TYPE(s) = make_type(TYPE_CODE_FUNC, 4, 0, 0); + TYPE_TARGET_TYPE(SYMBOL_TYPE(s)) = builtin_type_void; + + /* Need a block to allocate .gdbinfo. in */ + b = new_block(1); + SYMBOL_BLOCK_VALUE(s) = b; + BLOCK_START(b) = sigtramp_address; + BLOCK_END(b) = sigtramp_end; + BLOCK_FUNCTION(b) = s; + BLOCK_SUPERBLOCK(b) = BLOCK_SUPERBLOCK(b0); + add_block(b, st); + sort_blocks(st); + + /* Make a .gdbinfo. for it */ + { + struct mips_extra_func_info *e = + (struct mips_extra_func_info *) + xzalloc(sizeof(struct mips_extra_func_info)); + + e->numargs = 0; /* the kernel thinks otherwise */ + /* align_longword(sigcontext + SIGFRAME) */ + e->framesize = 0x150; + e->framereg = SP_REGNUM; + e->pcreg = 31; + e->regmask = -2; + e->regoffset = -(41 * sizeof(int)); + e->fregmask = -1; + e->fregoffset = -(37 * sizeof(int)); + e->isym = (long)s; + + s = new_symbol(".gdbinfo."); + SYMBOL_VALUE(s) = (int) e; + SYMBOL_NAMESPACE(s) = LABEL_NAMESPACE; + SYMBOL_CLASS(s) = LOC_CONST; + SYMBOL_TYPE(s) = builtin_type_void; + } + + BLOCK_SYM(b,BLOCK_NSYMS(b)++) = s; +} + + +/* Initialization */ + +static struct sym_fns ecoff_sym_fns = {"ecoff", 5, + mipscoff_new_init, mipscoff_symfile_init, + mipscoff_symfile_read, mipscoff_symfile_discard}; + +_initialize_mipsread () +{ + add_symtab_fns (&ecoff_sym_fns); + + bzero (&global_psymbols, sizeof (global_psymbols)); + bzero (&static_psymbols, sizeof (static_psymbols)); + + add_com("add-file", class_files, add_file_command, + "Add a new symbol table (in mips format) from file FILE."); + + /* Missing basic types */ + builtin_type_string = make_type(TYPE_CODE_PASCAL_ARRAY, + 1, 0, "string"); + builtin_type_complex = make_type(TYPE_CODE_FLT, + 2 * sizeof(float), 0, "complex"); + builtin_type_double_complex = make_type(TYPE_CODE_FLT, + 2 * sizeof(double), 0, "double_complex"); + builtin_type_fixed_dec = make_type(TYPE_CODE_INT, sizeof(int), + 0, "fixed_decimal"); + builtin_type_float_dec = make_type(TYPE_CODE_FLT, sizeof(double), + 0, "floating_decimal"); + + /* Templates types */ + builtin_type_ptr = lookup_pointer_type (builtin_type_void); + builtin_type_struct = make_type(TYPE_CODE_STRUCT, 0, 0, 0); + builtin_type_union = make_type(TYPE_CODE_UNION, 0, 0, 0); + builtin_type_enum = make_type(TYPE_CODE_ENUM, 0, 0, 0); + builtin_type_range = make_type(TYPE_CODE_RANGE, 0, 0, 0); + builtin_type_set = make_type(TYPE_CODE_SET, 0, 0, 0); +} |