X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fmdebugread.c;h=ca7c15ee63fd746f4c932396a86e616fc9e9badc;hb=62ec8e6dad018082e33e7dcb0633f28332f3520c;hp=aeecb14f19e02ded117389e02617306847a7cdae;hpb=3cabb6b0694b65c7b5ed800822ca08bd899fc1d1;p=binutils-gdb.git diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index aeecb14f19e..ca7c15ee63f 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -1,6 +1,6 @@ /* Read a symbol table in ECOFF format (Third-Eye). - Copyright (C) 1986-2020 Free Software Foundation, Inc. + Copyright (C) 1986-2022 Free Software Foundation, Inc. Original version contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor @@ -45,7 +45,7 @@ #include "gdbcore.h" #include "filenames.h" #include "objfiles.h" -#include "gdb_obstack.h" +#include "gdbsupport/gdb_obstack.h" #include "buildsym-legacy.h" #include "stabsread.h" #include "complaints.h" @@ -111,8 +111,8 @@ struct symloc #define SC_IS_TEXT(sc) ((sc) == scText \ || (sc) == scRConst \ - || (sc) == scInit \ - || (sc) == scFini) + || (sc) == scInit \ + || (sc) == scFini) #define SC_IS_DATA(sc) ((sc) == scData \ || (sc) == scSData \ || (sc) == scRData \ @@ -222,6 +222,7 @@ static int upgrade_type (int, struct type **, int, union aux_ext *, int, const char *); static void parse_partial_symbols (minimal_symbol_reader &, + psymtab_storage *, struct objfile *); static int has_opaque_xref (FDR *, SYMR *); @@ -251,7 +252,8 @@ static struct symbol *mylookup_symbol (const char *, const struct block *, static void sort_blocks (struct symtab *); -static legacy_psymtab *new_psymtab (const char *, struct objfile *); +static legacy_psymtab *new_psymtab (const char *, psymtab_storage *, + struct objfile *); static void mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile); @@ -264,8 +266,9 @@ static int add_line (struct linetable *, int, CORE_ADDR, int); static struct linetable *shrink_linetable (struct linetable *); -static void handle_psymbol_enumerators (struct objfile *, FDR *, int, - CORE_ADDR); +static void handle_psymbol_enumerators (struct objfile *, psymtab_storage *, + partial_symtab *, + FDR *, int, CORE_ADDR); static const char *mdebug_next_symbol_text (struct objfile *); @@ -339,7 +342,7 @@ mdebug_build_psymtabs (minimal_symbol_reader &reader, stabsread_new_init (); free_header_files (); init_header_files (); - + /* Make sure all the FDR information is swapped in. */ if (info->fdr == NULL) { @@ -357,7 +360,10 @@ mdebug_build_psymtabs (minimal_symbol_reader &reader, (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr); } - parse_partial_symbols (reader, objfile); + psymbol_functions *psf = new psymbol_functions (); + psymtab_storage *partial_symtabs = psf->get_partial_symtabs ().get (); + objfile->qf.emplace_front (psf); + parse_partial_symbols (reader, partial_symtabs, objfile); #if 0 /* Check to make sure file was compiled with -g. If not, warn the @@ -365,11 +371,11 @@ mdebug_build_psymtabs (minimal_symbol_reader &reader, if (compare_glevel (max_glevel, GLEVEL_2) < 0) { if (max_gdbinfo == 0) - printf_unfiltered (_("\n%s not compiled with -g, " - "debugging support is limited.\n"), - objfile->name); - printf_unfiltered (_("You should compile with -g2 or " - "-g3 for best debugging support.\n")); + gdb_printf (_("\n%s not compiled with -g, " + "debugging support is limited.\n"), + objfile->name); + gdb_printf (_("You should compile with -g2 or " + "-g3 for best debugging support.\n")); } #endif } @@ -380,9 +386,9 @@ mdebug_build_psymtabs (minimal_symbol_reader &reader, struct pst_map { - legacy_psymtab *pst; /* the psymtab proper */ - long n_globals; /* exported globals (external symbols) */ - long globals_offset; /* cumulative */ + legacy_psymtab *pst = nullptr; /* the psymtab proper */ + long n_globals = 0; /* exported globals (external symbols) */ + long globals_offset = 0; /* cumulative */ }; @@ -512,7 +518,7 @@ static void reg_value_complaint (int regnum, int num_regs, const char *sym) { complaint (_("bad register number %d (max %d) in symbol %s"), - regnum, num_regs - 1, sym); + regnum, num_regs - 1, sym); } /* Parse a single symbol. Mostly just make up a GDB symbol for it. @@ -527,7 +533,7 @@ reg_value_complaint (int regnum, int num_regs, const char *sym) static int mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch) { - int regno = gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym)); + int regno = gdbarch_ecoff_reg_to_regnum (gdbarch, sym->value_longest ()); if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch)) { @@ -556,16 +562,16 @@ add_data_symbol (SYMR *sh, union aux_ext *ax, int bigend, struct symbol *s, int aclass_index, struct block *b, struct objfile *objfile, const char *name) { - SYMBOL_DOMAIN (s) = VAR_DOMAIN; - SYMBOL_ACLASS_INDEX (s) = aclass_index; + s->set_domain (VAR_DOMAIN); + s->set_aclass_index (aclass_index); add_symbol (s, top_stack->cur_st, b); /* Type could be missing if file is compiled without debugging info. */ if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil || sh->index == indexNil) - SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol; + s->set_type (objfile_type (objfile)->nodebug_data_symbol); else - SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name); + s->set_type (parse_type (cur_fd, ax, sh->index, 0, bigend, name)); /* Value of a data symbol is its memory address. */ } @@ -596,10 +602,10 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, case scText: case scRConst: /* Do not relocate relative values. - The value of a stEnd symbol is the displacement from the - corresponding start symbol value. - The value of a stBlock symbol is the displacement from the - procedure address. */ + The value of a stEnd symbol is the displacement from the + corresponding start symbol value. + The value of a stBlock symbol is the displacement from the + procedure address. */ if (sh->st != stEnd && sh->st != stBlock) sh->value += section_offsets[SECT_OFF_TEXT (objfile)]; break; @@ -622,10 +628,9 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, break; case stGlobal: /* External symbol, goes into global block. */ - b = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st), - GLOBAL_BLOCK); + b = top_stack->cur_st->compunit ()->blockvector ()->global_block (); s = new_symbol (name); - SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value); + s->set_value_address (sh->value); add_data_symbol (sh, ax, bigend, s, LOC_STATIC, b, objfile, name); break; @@ -638,18 +643,18 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, address is not in the symbol; we need to fix it later in scan_file_globals. */ int bucket = hashname (s->linkage_name ()); - SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket]; + s->set_value_chain (global_sym_chain[bucket]); global_sym_chain[bucket] = s; } else - SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value); + s->set_value_address (sh->value); add_data_symbol (sh, ax, bigend, s, LOC_STATIC, b, objfile, name); break; case stLocal: /* Local variable, goes into current block. */ b = top_stack->cur_block; s = new_symbol (name); - SYMBOL_VALUE (s) = svalue; + s->set_value_longest (svalue); if (sh->sc == scRegister) add_data_symbol (sh, ax, bigend, s, mdebug_register_index, b, objfile, name); @@ -669,77 +674,77 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, name = "this"; /* FIXME, not alloc'd in obstack. */ s = new_symbol (name); - SYMBOL_DOMAIN (s) = VAR_DOMAIN; - SYMBOL_IS_ARGUMENT (s) = 1; + s->set_domain (VAR_DOMAIN); + s->set_is_argument (1); switch (sh->sc) { case scRegister: /* Pass by value in register. */ - SYMBOL_ACLASS_INDEX (s) = mdebug_register_index; + s->set_aclass_index (mdebug_register_index); break; case scVar: /* Pass by reference on stack. */ - SYMBOL_ACLASS_INDEX (s) = LOC_REF_ARG; + s->set_aclass_index (LOC_REF_ARG); break; case scVarRegister: /* Pass by reference in register. */ - SYMBOL_ACLASS_INDEX (s) = mdebug_regparm_index; + s->set_aclass_index (mdebug_regparm_index); break; default: /* Pass by value on stack. */ - SYMBOL_ACLASS_INDEX (s) = LOC_ARG; + s->set_aclass_index (LOC_ARG); break; } - SYMBOL_VALUE (s) = svalue; - SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name); + s->set_value_longest (svalue); + s->set_type (parse_type (cur_fd, ax, sh->index, 0, bigend, name)); add_symbol (s, top_stack->cur_st, top_stack->cur_block); break; case stLabel: /* label, goes into current block. */ s = new_symbol (name); - SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* So that it can be used */ - SYMBOL_ACLASS_INDEX (s) = LOC_LABEL; /* but not misused. */ - SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value); - SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int; + s->set_domain (VAR_DOMAIN); /* So that it can be used */ + s->set_aclass_index (LOC_LABEL); /* but not misused. */ + s->set_value_address (sh->value); + s->set_type (objfile_type (objfile)->builtin_int); add_symbol (s, top_stack->cur_st, top_stack->cur_block); break; case stProc: /* Procedure, usually goes into global block. */ case stStaticProc: /* Static procedure, goes into current block. */ /* For stProc symbol records, we need to check the storage class - as well, as only (stProc, scText) entries represent "real" - procedures - See the Compaq document titled "Object File / - Symbol Table Format Specification" for more information. - If the storage class is not scText, we discard the whole block - of symbol records for this stProc. */ + as well, as only (stProc, scText) entries represent "real" + procedures - See the Compaq document titled "Object File / + Symbol Table Format Specification" for more information. + If the storage class is not scText, we discard the whole block + of symbol records for this stProc. */ if (sh->st == stProc && sh->sc != scText) - { - char *ext_tsym = ext_sh; - int keep_counting = 1; - SYMR tsym; - - while (keep_counting) - { - ext_tsym += external_sym_size; - (*swap_sym_in) (cur_bfd, ext_tsym, &tsym); - count++; - switch (tsym.st) - { - case stParam: - break; - case stEnd: - keep_counting = 0; - break; - default: - complaint (_("unknown symbol type 0x%x"), sh->st); - break; - } - } - break; - } + { + char *ext_tsym = ext_sh; + int keep_counting = 1; + SYMR tsym; + + while (keep_counting) + { + ext_tsym += external_sym_size; + (*swap_sym_in) (cur_bfd, ext_tsym, &tsym); + count++; + switch (tsym.st) + { + case stParam: + break; + case stEnd: + keep_counting = 0; + break; + default: + complaint (_("unknown symbol type 0x%x"), sh->st); + break; + } + } + break; + } s = new_symbol (name); - SYMBOL_DOMAIN (s) = VAR_DOMAIN; - SYMBOL_ACLASS_INDEX (s) = LOC_BLOCK; + s->set_domain (VAR_DOMAIN); + s->set_aclass_index (LOC_BLOCK); /* Type of the return value. */ if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil) t = objfile_type (objfile)->builtin_int; @@ -750,50 +755,51 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, && t->code () == TYPE_CODE_VOID) { /* I don't know why, but, at least under Alpha GNU/Linux, - when linking against a malloc without debugging - symbols, its read as a function returning void---this - is bad because it means we cannot call functions with - string arguments interactively; i.e., "call - printf("howdy\n")" would fail with the error message - "program has no memory available". To avoid this, we - patch up the type and make it void* - instead. (davidm@azstarnet.com). */ + when linking against a malloc without debugging + symbols, its read as a function returning void---this + is bad because it means we cannot call functions with + string arguments interactively; i.e., "call + printf("howdy\n")" would fail with the error message + "program has no memory available". To avoid this, we + patch up the type and make it void* + instead. (davidm@azstarnet.com). */ t = make_pointer_type (t, NULL); } } b = top_stack->cur_block; if (sh->st == stProc) { - const struct blockvector *bv - = SYMTAB_BLOCKVECTOR (top_stack->cur_st); + struct blockvector *bv + = top_stack->cur_st->compunit ()->blockvector (); /* The next test should normally be true, but provides a hook for nested functions (which we don't want to make global). */ - if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) - b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); + if (b == bv->static_block ()) + b = bv->global_block (); /* Irix 5 sometimes has duplicate names for the same function. We want to add such names up at the global level, not as a nested function. */ else if (sh->value == top_stack->procadr) - b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); + b = bv->global_block (); } add_symbol (s, top_stack->cur_st, b); /* Make a type for the procedure itself. */ - SYMBOL_TYPE (s) = lookup_function_type (t); + s->set_type (lookup_function_type (t)); /* All functions in C++ have prototypes. For C we don't have enough - information in the debug info. */ + information in the debug info. */ if (s->language () == language_cplus) - TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1; + s->type ()->set_is_prototyped (true); /* Create and enter a new lexical context. */ b = new_block (FUNCTION_BLOCK, s->language ()); - SYMBOL_BLOCK_VALUE (s) = b; - BLOCK_FUNCTION (b) = s; - BLOCK_START (b) = BLOCK_END (b) = sh->value; - BLOCK_SUPERBLOCK (b) = top_stack->cur_block; + s->set_value_block (b); + b->set_function (s); + b->set_start (sh->value); + b->set_end (sh->value); + b->set_superblock (top_stack->cur_block); add_block (b, top_stack->cur_st); /* Not if we only have partial info. */ @@ -803,14 +809,14 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, push_parse_stack (); top_stack->cur_block = b; top_stack->blocktype = sh->st; - top_stack->cur_type = SYMBOL_TYPE (s); + top_stack->cur_type = s->type (); top_stack->cur_field = -1; top_stack->procadr = sh->value; top_stack->numargs = 0; break; /* Beginning of code for structure, union, and enum definitions. - They all share a common set of local variables, defined here. */ + They all share a common set of local variables, defined here. */ { enum type_code type_code; char *ext_tsym; @@ -858,28 +864,28 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, switch (tsym.st) { case stEnd: - /* C++ encodes class types as structures where there the - methods are encoded as stProc. The scope of stProc - symbols also ends with stEnd, thus creating a risk of - taking the wrong stEnd symbol record as the end of - the current struct, which would cause GDB to undercount - the real number of fields in this struct. To make sure - we really reached the right stEnd symbol record, we - check the associated name, and match it against the - struct name. Since method names are mangled while - the class name is not, there is no risk of having a - method whose name is identical to the class name - (in particular constructor method names are different - from the class name). There is therefore no risk that - this check stops the count on the StEnd of a method. + /* C++ encodes class types as structures where there the + methods are encoded as stProc. The scope of stProc + symbols also ends with stEnd, thus creating a risk of + taking the wrong stEnd symbol record as the end of + the current struct, which would cause GDB to undercount + the real number of fields in this struct. To make sure + we really reached the right stEnd symbol record, we + check the associated name, and match it against the + struct name. Since method names are mangled while + the class name is not, there is no risk of having a + method whose name is identical to the class name + (in particular constructor method names are different + from the class name). There is therefore no risk that + this check stops the count on the StEnd of a method. Also, assume that we're really at the end when tsym.iss is 0 (issNull). */ - if (tsym.iss == issNull + if (tsym.iss == issNull || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss, - name) == 0) - goto end_of_fields; - break; + name) == 0) + goto end_of_fields; + break; case stMember: if (nfields == 0 && type_code == TYPE_CODE_UNDEF) @@ -923,9 +929,9 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, if (tsym.index != 0) { /* This is something like a struct within a - struct. Skip over the fields of the inner - struct. The -1 is because the for loop will - increment ext_tsym. */ + struct. Skip over the fields of the inner + struct. The -1 is because the for loop will + increment ext_tsym. */ ext_tsym = ((char *) debug_info->external_sym + ((cur_fdr->isymBase + tsym.index - 1) * external_sym_size)); @@ -1050,20 +1056,20 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, if (tsym.st != stMember) break; - SET_FIELD_ENUMVAL (*f, tsym.value); - FIELD_TYPE (*f) = t; - FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss; + f->set_loc_enumval (tsym.value); + f->set_type (t); + f->set_name (debug_info->ss + cur_fdr->issBase + tsym.iss); FIELD_BITSIZE (*f) = 0; enum_sym = new (&mdebugread_objfile->objfile_obstack) symbol; enum_sym->set_linkage_name (obstack_strdup (&mdebugread_objfile->objfile_obstack, - f->name)); - SYMBOL_ACLASS_INDEX (enum_sym) = LOC_CONST; - SYMBOL_TYPE (enum_sym) = t; - SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN; - SYMBOL_VALUE (enum_sym) = tsym.value; - if (SYMBOL_VALUE (enum_sym) < 0) + f->name ())); + enum_sym->set_aclass_index (LOC_CONST); + enum_sym->set_type (t); + enum_sym->set_domain (VAR_DOMAIN); + enum_sym->set_value_longest (tsym.value); + if (enum_sym->value_longest () < 0) unsigned_enum = 0; add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block); @@ -1072,7 +1078,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, f++; } if (unsigned_enum) - TYPE_UNSIGNED (t) = 1; + t->set_is_unsigned (true); } /* Make this the current type. */ top_stack->cur_type = t; @@ -1086,15 +1092,15 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, do not create a symbol for it either. */ if (t->num_fields () == 0) { - TYPE_STUB (t) = 1; + t->set_is_stub (true); break; } s = new_symbol (name); - SYMBOL_DOMAIN (s) = STRUCT_DOMAIN; - SYMBOL_ACLASS_INDEX (s) = LOC_TYPEDEF; - SYMBOL_VALUE (s) = 0; - SYMBOL_TYPE (s) = t; + s->set_domain (STRUCT_DOMAIN); + s->set_aclass_index (LOC_TYPEDEF); + s->set_value_longest (0); + s->set_type (t); add_symbol (s, top_stack->cur_st, top_stack->cur_block); break; @@ -1105,12 +1111,12 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, case_stBlock_code: found_ecoff_debugging_info = 1; /* Beginnning of (code) block. Value of symbol - is the displacement from procedure start. */ + is the displacement from procedure start. */ push_parse_stack (); /* Do not start a new block if this is the outermost block of a - procedure. This allows the LOC_BLOCK symbol to point to the - block with the local variables, so funcname::var works. */ + procedure. This allows the LOC_BLOCK symbol to point to the + block with the local variables, so funcname::var works. */ if (top_stack->blocktype == stProc || top_stack->blocktype == stStaticProc) { @@ -1120,8 +1126,8 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, top_stack->blocktype = stBlock; b = new_block (NON_FUNCTION_BLOCK, psymtab_language); - BLOCK_START (b) = sh->value + top_stack->procadr; - BLOCK_SUPERBLOCK (b) = top_stack->cur_block; + b->set_start (sh->value + top_stack->procadr); + b->set_superblock (top_stack->cur_block); top_stack->cur_block = b; add_block (b, top_stack->cur_st); break; @@ -1137,46 +1143,44 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, top_stack->blocktype == stStaticProc)) { /* Finished with procedure */ - const struct blockvector *bv - = SYMTAB_BLOCKVECTOR (top_stack->cur_st); + struct blockvector *bv + = top_stack->cur_st->compunit ()->blockvector (); struct mdebug_extra_func_info *e; struct block *cblock = top_stack->cur_block; struct type *ftype = top_stack->cur_type; - int i; - BLOCK_END (top_stack->cur_block) += sh->value; /* size */ + top_stack->cur_block->set_end + (top_stack->cur_block->end () + sh->value); /* size */ /* Make up special symbol to contain procedure specific info. */ s = new_symbol (MDEBUG_EFI_SYMBOL_NAME); - SYMBOL_DOMAIN (s) = LABEL_DOMAIN; - SYMBOL_ACLASS_INDEX (s) = LOC_CONST; - SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->builtin_void; + s->set_domain (LABEL_DOMAIN); + s->set_aclass_index (LOC_CONST); + s->set_type (objfile_type (mdebugread_objfile)->builtin_void); e = OBSTACK_ZALLOC (&mdebugread_objfile->objfile_obstack, mdebug_extra_func_info); - SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e; + s->set_value_bytes ((gdb_byte *) e); e->numargs = top_stack->numargs; e->pdr.framereg = -1; add_symbol (s, top_stack->cur_st, top_stack->cur_block); /* 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++) + for (block *b_bad : bv->blocks ()) { - struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i); - - if (BLOCK_SUPERBLOCK (b_bad) == cblock - && BLOCK_START (b_bad) == top_stack->procadr - && BLOCK_END (b_bad) == top_stack->procadr) + if (b_bad->superblock () == cblock + && b_bad->start () == top_stack->procadr + && b_bad->end () == top_stack->procadr) { - BLOCK_START (b_bad) = BLOCK_START (cblock); - BLOCK_END (b_bad) = BLOCK_END (cblock); + b_bad->set_start (cblock->start ()); + b_bad->set_end (cblock->end ()); } } if (ftype->num_fields () <= 0) { /* No parameter type information is recorded with the function's - type. Set that from the type of the parameter symbols. */ + type. Set that from the type of the parameter symbols. */ int nparams = top_stack->numargs; int iparams; struct symbol *sym; @@ -1196,9 +1200,9 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, if (iparams == nparams) break; - if (SYMBOL_IS_ARGUMENT (sym)) + if (sym->is_argument ()) { - TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym); + ftype->field (iparams).set_type (sym->type ()); TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; iparams++; } @@ -1211,7 +1215,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, /* 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; + top_stack->cur_block->set_end (sh->value + top_stack->procadr); } else if (sh->sc == scText && top_stack->blocktype == stNil) { @@ -1233,27 +1237,27 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, case stMember: /* member of struct or union */ { - struct field *f - = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++]; - FIELD_NAME (*f) = name; - SET_FIELD_BITPOS (*f, sh->value); + struct field *f = &top_stack->cur_type->field (top_stack->cur_field); + top_stack->cur_field++; + f->set_name (name); + f->set_loc_bitpos (sh->value); bitsize = 0; - FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, - &bitsize, bigend, name); + f->set_type (parse_type (cur_fd, ax, sh->index, &bitsize, bigend, + name)); FIELD_BITSIZE (*f) = bitsize; } break; case stIndirect: /* forward declaration on Irix5 */ /* Forward declarations from Irix5 cc are handled by cross_ref, - skip them. */ + skip them. */ break; case stTypedef: /* type definition */ found_ecoff_debugging_info = 1; /* Typedefs for forward declarations and opaque structs from alpha cc - are handled by cross_ref, skip them. */ + are handled by cross_ref, skip them. */ if (sh->iss == 0) break; @@ -1268,63 +1272,63 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, t = pend->t; /* Mips cc puts out a typedef with the name of the struct for forward - declarations. These should not go into the symbol table and - TYPE_NAME should not be set for them. - They can't be distinguished from an intentional typedef to - the same name however: - x.h: - struct x { int ix; int jx; }; - struct xx; - x.c: - typedef struct x x; - struct xx {int ixx; int jxx; }; - generates a cross referencing stTypedef for x and xx. - The user visible effect of this is that the type of a pointer - to struct foo sometimes is given as `foo *' instead of `struct foo *'. - The problem is fixed with alpha cc and Irix5 cc. */ + declarations. These should not go into the symbol table and + TYPE_NAME should not be set for them. + They can't be distinguished from an intentional typedef to + the same name however: + x.h: + struct x { int ix; int jx; }; + struct xx; + x.c: + typedef struct x x; + struct xx {int ixx; int jxx; }; + generates a cross referencing stTypedef for x and xx. + The user visible effect of this is that the type of a pointer + to struct foo sometimes is given as `foo *' instead of `struct foo *'. + The problem is fixed with alpha cc and Irix5 cc. */ /* However if the typedef cross references to an opaque aggregate, it - is safe to omit it from the symbol table. */ + is safe to omit it from the symbol table. */ if (has_opaque_xref (cur_fdr, sh)) break; s = new_symbol (name); - SYMBOL_DOMAIN (s) = VAR_DOMAIN; - SYMBOL_ACLASS_INDEX (s) = LOC_TYPEDEF; - SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block; - SYMBOL_TYPE (s) = t; + s->set_domain (VAR_DOMAIN); + s->set_aclass_index (LOC_TYPEDEF); + s->set_value_block (top_stack->cur_block); + s->set_type (t); add_symbol (s, top_stack->cur_st, top_stack->cur_block); /* Incomplete definitions of structs should not get a name. */ - if (SYMBOL_TYPE (s)->name () == NULL - && (SYMBOL_TYPE (s)->num_fields () != 0 - || (SYMBOL_TYPE (s)->code () != TYPE_CODE_STRUCT - && SYMBOL_TYPE (s)->code () != TYPE_CODE_UNION))) + if (s->type ()->name () == NULL + && (s->type ()->num_fields () != 0 + || (s->type ()->code () != TYPE_CODE_STRUCT + && s->type ()->code () != TYPE_CODE_UNION))) { - if (SYMBOL_TYPE (s)->code () == TYPE_CODE_PTR - || SYMBOL_TYPE (s)->code () == TYPE_CODE_FUNC) + if (s->type ()->code () == TYPE_CODE_PTR + || s->type ()->code () == TYPE_CODE_FUNC) { /* If we are giving a name to a type such as "pointer to - foo" or "function returning foo", we better not set - the TYPE_NAME. If the program contains "typedef char - *caddr_t;", we don't want all variables of type char - * to print as caddr_t. This is not just a - consequence of GDB's type management; CC and GCC (at - least through version 2.4) both output variables of - either type char * or caddr_t with the type - refering to the stTypedef symbol for caddr_t. If a future - compiler cleans this up it GDB is not ready for it - yet, but if it becomes ready we somehow need to - disable this check (without breaking the PCC/GCC2.4 - case). - - Sigh. - - Fortunately, this check seems not to be necessary - for anything except pointers or functions. */ + foo" or "function returning foo", we better not set + the TYPE_NAME. If the program contains "typedef char + *caddr_t;", we don't want all variables of type char + * to print as caddr_t. This is not just a + consequence of GDB's type management; CC and GCC (at + least through version 2.4) both output variables of + either type char * or caddr_t with the type + refering to the stTypedef symbol for caddr_t. If a future + compiler cleans this up it GDB is not ready for it + yet, but if it becomes ready we somehow need to + disable this check (without breaking the PCC/GCC2.4 + case). + + Sigh. + + Fortunately, this check seems not to be necessary + for anything except pointers or functions. */ } else - SYMBOL_TYPE (s)->set_name (s->linkage_name ()); + s->type ()->set_name (s->linkage_name ()); } break; @@ -1387,7 +1391,7 @@ basic_type (int bt, struct objfile *objfile) case btChar: tp = init_integer_type (objfile, 8, 0, "char"); - TYPE_NOSIGN (tp) = 1; + tp->set_has_no_signedness (true); break; case btUChar: @@ -1638,14 +1642,14 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, tp = init_type (mdebugread_objfile, type_code, 0, NULL); /* DEC c89 produces cross references to qualified aggregate types, - dereference them. */ + dereference them. */ while (tp->code () == TYPE_CODE_PTR || tp->code () == TYPE_CODE_ARRAY) tp = TYPE_TARGET_TYPE (tp); /* Make sure that TYPE_CODE(tp) has an expected type code. - Any type may be returned from cross_ref if file indirect entries - are corrupted. */ + Any type may be returned from cross_ref if file indirect entries + are corrupted. */ if (tp->code () != TYPE_CODE_STRUCT && tp->code () != TYPE_CODE_UNION && tp->code () != TYPE_CODE_ENUM) @@ -1696,8 +1700,8 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, tp = init_type (mdebugread_objfile, type_code, 0, NULL); /* Make sure that TYPE_CODE(tp) has an expected type code. - Any type may be returned from cross_ref if file indirect entries - are corrupted. */ + Any type may be returned from cross_ref if file indirect entries + are corrupted. */ if (tp->code () != TYPE_CODE_RANGE) { unexpected_type_code_complaint (sym_name); @@ -1734,11 +1738,11 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, if (t->bt == btRange) { tp->set_num_fields (0); - TYPE_RANGE_DATA (tp) = ((struct range_bounds *) - TYPE_ZALLOC (tp, sizeof (struct range_bounds))); - TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax); + tp->set_bounds (((struct range_bounds *) + TYPE_ZALLOC (tp, sizeof (struct range_bounds)))); + tp->bounds ()->low.set_const_val (AUX_GET_DNLOW (bigend, ax)); ax++; - TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax); + tp->bounds ()->high.set_const_val (AUX_GET_DNHIGH (bigend, ax)); ax++; } @@ -1830,7 +1834,7 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend, id, NULL, bigend, sym_name); /* The bounds type should be an integer type, but might be anything - else due to corrupt aux entries. */ + else due to corrupt aux entries. */ if (indx->code () != TYPE_CODE_INT) { complaint (_("illegal array index type for %s, assuming int"), @@ -1851,22 +1855,22 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend, t = create_array_type (NULL, *tpp, range); /* We used to fill in the supplied array element bitsize - here if the TYPE_LENGTH of the target type was zero. - This happens for a `pointer to an array of anonymous structs', - but in this case the array element bitsize is also zero, - so nothing is gained. - And we used to check the TYPE_LENGTH of the target type against - the supplied array element bitsize. - gcc causes a mismatch for `pointer to array of object', - since the sdb directives it uses do not have a way of - specifying the bitsize, but it does no harm (the - TYPE_LENGTH should be correct) and we should be able to - ignore the erroneous bitsize from the auxiliary entry safely. - dbx seems to ignore it too. */ + here if the TYPE_LENGTH of the target type was zero. + This happens for a `pointer to an array of anonymous structs', + but in this case the array element bitsize is also zero, + so nothing is gained. + And we used to check the TYPE_LENGTH of the target type against + the supplied array element bitsize. + gcc causes a mismatch for `pointer to array of object', + since the sdb directives it uses do not have a way of + specifying the bitsize, but it does no harm (the + TYPE_LENGTH should be correct) and we should be able to + ignore the erroneous bitsize from the auxiliary entry safely. + dbx seems to ignore it too. */ /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */ if (TYPE_LENGTH (*tpp) == 0) - TYPE_TARGET_STUB (t) = 1; + t->set_target_is_stub (true); *tpp = t; return 4 + off; @@ -1946,12 +1950,12 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab, { #if 0 /* This loses both in the case mentioned (want a static, find a global), - but also if we are looking up a non-mangled name which happens to - match the name of a mangled function. */ + but also if we are looking up a non-mangled name which happens to + match the name of a mangled function. */ /* We have to save the cur_fdr across the call to lookup_symbol. - If the pdr is for a static function and if a global function with - the same name exists, lookup_symbol will eventually read in the symtab - for the global function and clobber cur_fdr. */ + If the pdr is for a static function and if a global function with + the same name exists, lookup_symbol will eventually read in the symtab + for the global function and clobber cur_fdr. */ FDR *save_cur_fdr = cur_fdr; s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0); @@ -1959,8 +1963,7 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab, #else s = mylookup_symbol (sh_name, - BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (search_symtab), - STATIC_BLOCK), + search_symtab->blockvector ()->static_block (), VAR_DOMAIN, LOC_BLOCK); #endif @@ -1971,7 +1974,7 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab, if (s != 0) { - b = SYMBOL_BLOCK_VALUE (s); + b = s->value_block (); } else { @@ -1981,10 +1984,10 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab, #else /* FIXME -- delete. We can't do symbol allocation now; it's all done. */ s = new_symbol (sh_name); - SYMBOL_DOMAIN (s) = VAR_DOMAIN; + s->set_domain (VAR_DOMAIN); SYMBOL_CLASS (s) = LOC_BLOCK; /* Don't know its type, hope int is ok. */ - SYMBOL_TYPE (s) + s->type () = lookup_function_type (objfile_type (pst->objfile)->builtin_int); add_symbol (s, top_stack->cur_st, top_stack->cur_block); /* Won't have symbols for this one. */ @@ -1993,7 +1996,7 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab, BLOCK_FUNCTION (b) = s; BLOCK_START (b) = pr->adr; /* BOUND used to be the end of procedure's text, but the - argument is no longer passed in. */ + argument is no longer passed in. */ BLOCK_END (b) = bound; BLOCK_SUPERBLOCK (b) = top_stack->cur_block; add_block (b, top_stack->cur_st); @@ -2006,19 +2009,19 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab, { struct mdebug_extra_func_info *e; - e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i); + e = (struct mdebug_extra_func_info *) i->value_bytes (); e->pdr = *pr; /* GDB expects the absolute function start address for the - procedure descriptor in e->pdr.adr. - As the address in the procedure descriptor is usually relative, - we would have to relocate e->pdr.adr with cur_fdr->adr. - Unfortunately cur_fdr->adr and e->pdr.adr are both absolute - in shared libraries on some systems, and on other systems - e->pdr.adr is sometimes offset by a bogus value. - To work around these problems, we replace e->pdr.adr with - the start address of the function. */ - e->pdr.adr = BLOCK_START (b); + procedure descriptor in e->pdr.adr. + As the address in the procedure descriptor is usually relative, + we would have to relocate e->pdr.adr with cur_fdr->adr. + Unfortunately cur_fdr->adr and e->pdr.adr are both absolute + in shared libraries on some systems, and on other systems + e->pdr.adr is sometimes offset by a bogus value. + To work around these problems, we replace e->pdr.adr with + the start address of the function. */ + e->pdr.adr = b->start (); } /* It would be reasonable that functions that have been compiled @@ -2038,8 +2041,8 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab, if (processing_gcc_compilation == 0 && found_ecoff_debugging_info == 0 - && TYPE_TARGET_TYPE (SYMBOL_TYPE (s))->code () == TYPE_CODE_VOID) - SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->nodebug_text_symbol; + && TYPE_TARGET_TYPE (s->type ())->code () == TYPE_CODE_VOID) + s->set_type (objfile_type (mdebugread_objfile)->nodebug_text_symbol); } /* Parse the external symbol ES. Just call parse_symbol() after @@ -2096,9 +2099,9 @@ parse_external (EXTR *es, int bigend, const section_offsets §ion_offsets, n_undef_symbols++; /* FIXME: Turn this into a complaint? */ if (info_verbose) - printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"), - what, debug_info->ssext + es->asym.iss, - fdr_name (cur_fdr)); + gdb_printf (_("Warning: %s `%s' is undefined (in %s)\n"), + what, debug_info->ssext + es->asym.iss, + fdr_name (cur_fdr)); return; } @@ -2107,24 +2110,24 @@ parse_external (EXTR *es, int bigend, const section_offsets §ion_offsets, case stProc: case stStaticProc: /* There is no need to parse the external procedure symbols. - If they are from objects compiled without -g, their index will - be indexNil, and the symbol definition from the minimal symbol - is preferrable (yielding a function returning int instead of int). - If the index points to a local procedure symbol, the local - symbol already provides the correct type. - Note that the index of the external procedure symbol points - to the local procedure symbol in the local symbol table, and - _not_ to the auxiliary symbol info. */ + If they are from objects compiled without -g, their index will + be indexNil, and the symbol definition from the minimal symbol + is preferrable (yielding a function returning int instead of int). + If the index points to a local procedure symbol, the local + symbol already provides the correct type. + Note that the index of the external procedure symbol points + to the local procedure symbol in the local symbol table, and + _not_ to the auxiliary symbol info. */ break; case stGlobal: case stLabel: /* Global common symbols are resolved by the runtime loader, - ignore them. */ + ignore them. */ if (SC_IS_COMMON (es->asym.sc)) break; /* Note that the case of a symbol with indexNil must be handled - anyways by parse_symbol(). */ + anyways by parse_symbol(). */ parse_symbol (&es->asym, ax, NULL, bigend, section_offsets, objfile); break; @@ -2164,7 +2167,7 @@ parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines, continue; /* Determine start and end address of compressed line bytes for - this procedure. */ + this procedure. */ base = debug_info->line + fh->cbLineOffset; if (j != (fh->cpd - 1)) halt = base + pr[1].cbLineOffset; @@ -2218,59 +2221,59 @@ function_outside_compilation_unit_complaint (const char *arg1) static void record_minimal_symbol (minimal_symbol_reader &reader, const char *name, const CORE_ADDR address, - enum minimal_symbol_type ms_type, int storage_class, - struct objfile *objfile) + enum minimal_symbol_type ms_type, int storage_class, + struct objfile *objfile) { int section; switch (storage_class) { case scText: - section = SECT_OFF_TEXT (objfile); - break; + section = SECT_OFF_TEXT (objfile); + break; case scData: - section = SECT_OFF_DATA (objfile); - break; + section = SECT_OFF_DATA (objfile); + break; case scBss: - section = SECT_OFF_BSS (objfile); - break; + section = SECT_OFF_BSS (objfile); + break; case scSData: - section = get_section_index (objfile, ".sdata"); - break; + section = get_section_index (objfile, ".sdata"); + break; case scSBss: - section = get_section_index (objfile, ".sbss"); - break; + section = get_section_index (objfile, ".sbss"); + break; case scRData: - section = get_section_index (objfile, ".rdata"); - break; + section = get_section_index (objfile, ".rdata"); + break; case scInit: - section = get_section_index (objfile, ".init"); - break; + section = get_section_index (objfile, ".init"); + break; case scXData: - section = get_section_index (objfile, ".xdata"); - break; + section = get_section_index (objfile, ".xdata"); + break; case scPData: - section = get_section_index (objfile, ".pdata"); - break; + section = get_section_index (objfile, ".pdata"); + break; case scFini: - section = get_section_index (objfile, ".fini"); - break; + section = get_section_index (objfile, ".fini"); + break; case scRConst: - section = get_section_index (objfile, ".rconst"); - break; + section = get_section_index (objfile, ".rconst"); + break; #ifdef scTlsData case scTlsData: - section = get_section_index (objfile, ".tlsdata"); - break; + section = get_section_index (objfile, ".tlsdata"); + break; #endif #ifdef scTlsBss case scTlsBss: - section = get_section_index (objfile, ".tlsbss"); - break; + section = get_section_index (objfile, ".tlsbss"); + break; #endif default: - /* This kind of symbol is not associated to a section. */ - section = -1; + /* This kind of symbol is not associated to a section. */ + section = -1; } reader.record_with_info (name, address, ms_type, section); @@ -2281,6 +2284,7 @@ record_minimal_symbol (minimal_symbol_reader &reader, static void parse_partial_symbols (minimal_symbol_reader &reader, + psymtab_storage *partial_symtabs, struct objfile *objfile) { struct gdbarch *gdbarch = objfile->arch (); @@ -2358,11 +2362,11 @@ parse_partial_symbols (minimal_symbol_reader &reader, /* Allocate the map FDR -> PST. Minor hack: -O3 images might claim some global data belongs to FDR -1. We`ll go along with that. */ - gdb::def_vector fdr_to_pst_holder (hdr->ifdMax + 1); + std::vector fdr_to_pst_holder (hdr->ifdMax + 1); fdr_to_pst = fdr_to_pst_holder.data (); fdr_to_pst++; { - legacy_psymtab *new_pst = new_psymtab ("", objfile); + legacy_psymtab *new_pst = new_psymtab ("", partial_symtabs, objfile); fdr_to_pst[-1].pst = new_pst; FDR_IDX (new_pst) = -1; @@ -2445,7 +2449,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, CORE_ADDR svalue = ext_in->asym.value; /* The Irix 5 native tools seem to sometimes generate bogus - external symbols. */ + external symbols. */ if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax) { complaint (_("bad ifd for external symbol: %d (max %ld)"), @@ -2485,7 +2489,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, if (SC_IS_COMMON (ext_in->asym.sc)) { /* The value of a common symbol is its size, not its address. - Ignore it. */ + Ignore it. */ continue; } else if (SC_IS_DATA (ext_in->asym.sc)) @@ -2496,65 +2500,65 @@ parse_partial_symbols (minimal_symbol_reader &reader, { ms_type = mst_bss; } - else if (SC_IS_SBSS (ext_in->asym.sc)) - { - ms_type = mst_bss; - } + else if (SC_IS_SBSS (ext_in->asym.sc)) + { + ms_type = mst_bss; + } else ms_type = mst_abs; break; case stLabel: /* Label */ - /* On certain platforms, some extra label symbols can be - generated by the linker. One possible usage for this kind - of symbols is to represent the address of the begining of a - given section. For instance, on Tru64 5.1, the address of - the _ftext label is the start address of the .text section. - - The storage class of these symbols is usually directly - related to the section to which the symbol refers. For - instance, on Tru64 5.1, the storage class for the _fdata - label is scData, refering to the .data section. - - It is actually possible that the section associated to the - storage class of the label does not exist. On True64 5.1 - for instance, the libm.so shared library does not contain - any .data section, although it contains a _fpdata label - which storage class is scData... Since these symbols are - usually useless for the debugger user anyway, we just - discard these symbols. */ - + /* On certain platforms, some extra label symbols can be + generated by the linker. One possible usage for this kind + of symbols is to represent the address of the begining of a + given section. For instance, on Tru64 5.1, the address of + the _ftext label is the start address of the .text section. + + The storage class of these symbols is usually directly + related to the section to which the symbol refers. For + instance, on Tru64 5.1, the storage class for the _fdata + label is scData, refering to the .data section. + + It is actually possible that the section associated to the + storage class of the label does not exist. On True64 5.1 + for instance, the libm.so shared library does not contain + any .data section, although it contains a _fpdata label + which storage class is scData... Since these symbols are + usually useless for the debugger user anyway, we just + discard these symbols. */ + if (SC_IS_TEXT (ext_in->asym.sc)) { - if (objfile->sect_index_text == -1) - continue; - + if (objfile->sect_index_text == -1) + continue; + ms_type = mst_file_text; } else if (SC_IS_DATA (ext_in->asym.sc)) { - if (objfile->sect_index_data == -1) - continue; + if (objfile->sect_index_data == -1) + continue; ms_type = mst_file_data; } else if (SC_IS_BSS (ext_in->asym.sc)) { - if (objfile->sect_index_bss == -1) - continue; + if (objfile->sect_index_bss == -1) + continue; ms_type = mst_file_bss; } - else if (SC_IS_SBSS (ext_in->asym.sc)) - { - const int sbss_sect_index = get_section_index (objfile, ".sbss"); + else if (SC_IS_SBSS (ext_in->asym.sc)) + { + const int sbss_sect_index = get_section_index (objfile, ".sbss"); - if (sbss_sect_index == -1) - continue; + if (sbss_sect_index == -1) + continue; - ms_type = mst_file_bss; - } + ms_type = mst_file_bss; + } else ms_type = mst_abs; break; @@ -2573,8 +2577,8 @@ parse_partial_symbols (minimal_symbol_reader &reader, unknown_ext_complaint (name); } if (!ECOFF_IN_ELF (cur_bfd)) - record_minimal_symbol (reader, name, svalue, ms_type, ext_in->asym.sc, - objfile); + record_minimal_symbol (reader, name, svalue, ms_type, ext_in->asym.sc, + objfile); } /* Pass 3 over files, over local syms: fill in static symbols. */ @@ -2593,12 +2597,13 @@ parse_partial_symbols (minimal_symbol_reader &reader, } /* Determine the start address for this object file from the - file header and relocate it, except for Irix 5.2 zero fh->adr. */ + file header and relocate it, except for Irix 5.2 zero fh->adr. */ if (fh->cpd) textlow = fh->adr; else textlow = 0; - pst = new legacy_psymtab (fdr_name (fh), objfile, textlow); + pst = new legacy_psymtab (fdr_name (fh), partial_symtabs, + objfile->per_bfd, textlow); pst->read_symtab_private = XOBNEW (&objfile->objfile_obstack, symloc); memset (pst->read_symtab_private, 0, sizeof (struct symloc)); @@ -2614,16 +2619,16 @@ parse_partial_symbols (minimal_symbol_reader &reader, pst->legacy_expand_psymtab = mdebug_expand_psymtab; /* Set up language for the pst. - The language from the FDR is used if it is unambigious (e.g. cfront - with native cc and g++ will set the language to C). - Otherwise we have to deduce the language from the filename. - Native ecoff has every header file in a separate FDR, so - deduce_language_from_filename will return language_unknown for - a header file, which is not what we want. - But the FDRs for the header files are after the FDR for the source - file, so we can assign the language of the source file to the - following header files. Then we save the language in the private - pst data so that we can reuse it when building symtabs. */ + The language from the FDR is used if it is unambigious (e.g. cfront + with native cc and g++ will set the language to C). + Otherwise we have to deduce the language from the filename. + Native ecoff has every header file in a separate FDR, so + deduce_language_from_filename will return language_unknown for + a header file, which is not what we want. + But the FDRs for the header files are after the FDR for the source + file, so we can assign the language of the source file to the + following header files. Then we save the language in the private + pst data so that we can reuse it when building symtabs. */ prev_language = psymtab_language; switch (fh->lang) @@ -2642,11 +2647,11 @@ parse_partial_symbols (minimal_symbol_reader &reader, pst->set_text_high (pst->raw_text_low ()); /* For stabs-in-ecoff files, the second symbol must be @stab. - This symbol is emitted by mips-tfile to signal that the - current object file uses encapsulated stabs instead of mips - ecoff for local symbols. (It is the second symbol because - the first symbol is the stFile used to signal the start of a - file). */ + This symbol is emitted by mips-tfile to signal that the + current object file uses encapsulated stabs instead of mips + ecoff for local symbols. (It is the second symbol because + the first symbol is the stFile used to signal the start of a + file). */ processing_gcc_compilation = 0; if (fh->csym >= 2) { @@ -2681,9 +2686,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, if (sh.st == stStaticProc) { namestring = debug_info->ss + fh->issBase + sh.iss; - record_minimal_symbol (reader, namestring, sh.value, - mst_file_text, sh.sc, - objfile); + record_minimal_symbol (reader, namestring, sh.value, + mst_file_text, sh.sc, + objfile); } procaddr = sh.value; @@ -2725,18 +2730,18 @@ parse_partial_symbols (minimal_symbol_reader &reader, case scPData: case scXData: namestring = debug_info->ss + fh->issBase + sh.iss; - record_minimal_symbol (reader, namestring, sh.value, - mst_file_data, sh.sc, - objfile); + record_minimal_symbol (reader, namestring, sh.value, + mst_file_data, sh.sc, + objfile); break; default: /* FIXME! Shouldn't this use cases for bss, then have the default be abs? */ namestring = debug_info->ss + fh->issBase + sh.iss; - record_minimal_symbol (reader, namestring, sh.value, - mst_file_bss, sh.sc, - objfile); + record_minimal_symbol (reader, namestring, sh.value, + mst_file_bss, sh.sc, + objfile); break; } } @@ -3029,29 +3034,27 @@ parse_partial_symbols (minimal_symbol_reader &reader, switch (p[1]) { case 'S': - if (gdbarch_static_transform_name_p (gdbarch)) - namestring = gdbarch_static_transform_name - (gdbarch, namestring); - - add_psymbol_to_list (gdb::string_view (namestring, - p - namestring), - true, VAR_DOMAIN, LOC_STATIC, - SECT_OFF_DATA (objfile), - psymbol_placement::STATIC, - sh.value, - psymtab_language, objfile); + pst->add_psymbol (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_STATIC, + SECT_OFF_DATA (objfile), + psymbol_placement::STATIC, + sh.value, + psymtab_language, + partial_symtabs, objfile); continue; case 'G': /* The addresses in these entries are reported to be wrong. See the code that reads 'G's for symtabs. */ - add_psymbol_to_list (gdb::string_view (namestring, - p - namestring), - true, VAR_DOMAIN, LOC_STATIC, - SECT_OFF_DATA (objfile), - psymbol_placement::GLOBAL, - sh.value, - psymtab_language, objfile); + pst->add_psymbol (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_STATIC, + SECT_OFF_DATA (objfile), + psymbol_placement::GLOBAL, + sh.value, + psymtab_language, + partial_symtabs, objfile); continue; case 'T': @@ -3065,20 +3068,21 @@ parse_partial_symbols (minimal_symbol_reader &reader, || (p == namestring + 1 && namestring[0] != ' ')) { - add_psymbol_to_list + pst->add_psymbol (gdb::string_view (namestring, p - namestring), true, STRUCT_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, - objfile); + partial_symtabs, objfile); if (p[2] == 't') { /* Also a typedef with the same name. */ - add_psymbol_to_list + pst->add_psymbol (gdb::string_view (namestring, p - namestring), true, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, - psymtab_language, objfile); + psymtab_language, + partial_symtabs, objfile); p += 1; } } @@ -3087,12 +3091,12 @@ parse_partial_symbols (minimal_symbol_reader &reader, if (p != namestring) /* a name is there, not just :T... */ { - add_psymbol_to_list + pst->add_psymbol (gdb::string_view (namestring, p - namestring), true, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, - objfile); + partial_symtabs, objfile); } check_enum: /* If this is an enumerated type, we need to add @@ -3153,13 +3157,13 @@ parse_partial_symbols (minimal_symbol_reader &reader, /* Note that the value doesn't matter for enum constants in psymtabs, just in symtabs. */ - add_psymbol_to_list (gdb::string_view (p, - q - p), - true, VAR_DOMAIN, - LOC_CONST, -1, - psymbol_placement::STATIC, - 0, psymtab_language, - objfile); + pst->add_psymbol (gdb::string_view (p, + q - p), + true, VAR_DOMAIN, + LOC_CONST, -1, + psymbol_placement::STATIC, + 0, psymtab_language, + partial_symtabs, objfile); /* Point past the name. */ p = q; /* Skip over the value. */ @@ -3173,11 +3177,12 @@ parse_partial_symbols (minimal_symbol_reader &reader, continue; case 'c': /* Constant, e.g. from "const" in Pascal. */ - add_psymbol_to_list (gdb::string_view (namestring, - p - namestring), - true, VAR_DOMAIN, LOC_CONST, -1, - psymbol_placement::STATIC, - 0, psymtab_language, objfile); + pst->add_psymbol (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_CONST, -1, + psymbol_placement::STATIC, + 0, psymtab_language, + partial_symtabs, objfile); continue; case 'f': @@ -3187,13 +3192,14 @@ parse_partial_symbols (minimal_symbol_reader &reader, function_outside_compilation_unit_complaint (copy.c_str ()); } - add_psymbol_to_list (gdb::string_view (namestring, - p - namestring), - true, VAR_DOMAIN, LOC_BLOCK, - SECT_OFF_TEXT (objfile), - psymbol_placement::STATIC, - sh.value, - psymtab_language, objfile); + pst->add_psymbol (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_BLOCK, + SECT_OFF_TEXT (objfile), + psymbol_placement::STATIC, + sh.value, + psymtab_language, + partial_symtabs, objfile); continue; /* Global functions were ignored here, but now they @@ -3207,13 +3213,14 @@ parse_partial_symbols (minimal_symbol_reader &reader, function_outside_compilation_unit_complaint (copy.c_str ()); } - add_psymbol_to_list (gdb::string_view (namestring, - p - namestring), - true, VAR_DOMAIN, LOC_BLOCK, - SECT_OFF_TEXT (objfile), - psymbol_placement::GLOBAL, - sh.value, - psymtab_language, objfile); + pst->add_psymbol (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_BLOCK, + SECT_OFF_TEXT (objfile), + psymbol_placement::GLOBAL, + sh.value, + psymtab_language, + partial_symtabs, objfile); continue; /* Two things show up here (hopefully); static @@ -3403,7 +3410,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, if (sh.index >= hdr->iauxMax) { /* Should not happen, but does when cross-compiling - with the MIPS compiler. FIXME -- pull later. */ + with the MIPS compiler. FIXME -- pull later. */ index_complaint (sym_name); new_sdx = cur_sdx + 1; /* Don't skip at all. */ } @@ -3421,15 +3428,15 @@ parse_partial_symbols (minimal_symbol_reader &reader, new_sdx = cur_sdx + 1; /* Don't skip backward. */ } - /* For stProc symbol records, we need to check the - storage class as well, as only (stProc, scText) - entries represent "real" procedures - See the - Compaq document titled "Object File / Symbol Table - Format Specification" for more information. If the - storage class is not scText, we discard the whole - block of symbol records for this stProc. */ - if (sh.st == stProc && sh.sc != scText) - goto skip; + /* For stProc symbol records, we need to check the + storage class as well, as only (stProc, scText) + entries represent "real" procedures - See the + Compaq document titled "Object File / Symbol Table + Format Specification" for more information. If the + storage class is not scText, we discard the whole + block of symbol records for this stProc. */ + if (sh.st == stProc && sh.sc != scText) + goto skip; /* Usually there is a local and a global stProc symbol for a function. This means that the function name @@ -3443,17 +3450,19 @@ parse_partial_symbols (minimal_symbol_reader &reader, symbol table, and the MAIN__ symbol via the minimal symbol table. */ if (sh.st == stProc) - add_psymbol_to_list (sym_name, true, - VAR_DOMAIN, LOC_BLOCK, - section, - psymbol_placement::GLOBAL, - sh.value, psymtab_language, objfile); + pst->add_psymbol (sym_name, true, + VAR_DOMAIN, LOC_BLOCK, + section, + psymbol_placement::GLOBAL, + sh.value, psymtab_language, + partial_symtabs, objfile); else - add_psymbol_to_list (sym_name, true, - VAR_DOMAIN, LOC_BLOCK, - section, - psymbol_placement::STATIC, - sh.value, psymtab_language, objfile); + pst->add_psymbol (sym_name, true, + VAR_DOMAIN, LOC_BLOCK, + section, + psymbol_placement::STATIC, + sh.value, psymtab_language, + partial_symtabs, objfile); procaddr = sh.value; @@ -3516,12 +3525,14 @@ parse_partial_symbols (minimal_symbol_reader &reader, && sh.iss != 0 && sh.index != cur_sdx + 2) { - add_psymbol_to_list (sym_name, true, - STRUCT_DOMAIN, LOC_TYPEDEF, -1, - psymbol_placement::STATIC, - 0, psymtab_language, objfile); + pst->add_psymbol (sym_name, true, + STRUCT_DOMAIN, LOC_TYPEDEF, -1, + psymbol_placement::STATIC, + 0, psymtab_language, + partial_symtabs, objfile); } - handle_psymbol_enumerators (objfile, fh, sh.st, sh.value); + handle_psymbol_enumerators (objfile, partial_symtabs, + pst, fh, sh.st, sh.value); /* Skip over the block. */ new_sdx = sh.index; @@ -3556,10 +3567,11 @@ parse_partial_symbols (minimal_symbol_reader &reader, continue; } /* Use this gdb symbol. */ - add_psymbol_to_list (sym_name, true, - VAR_DOMAIN, theclass, section, - psymbol_placement::STATIC, - sh.value, psymtab_language, objfile); + pst->add_psymbol (sym_name, true, + VAR_DOMAIN, theclass, section, + psymbol_placement::STATIC, + sh.value, psymtab_language, + partial_symtabs, objfile); skip: cur_sdx++; /* Go to next file symbol. */ } @@ -3634,18 +3646,19 @@ parse_partial_symbols (minimal_symbol_reader &reader, break; } char *sym_name = debug_info->ssext + psh->iss; - add_psymbol_to_list (sym_name, true, - VAR_DOMAIN, theclass, - section, - psymbol_placement::GLOBAL, - svalue, psymtab_language, objfile); + pst->add_psymbol (sym_name, true, + VAR_DOMAIN, theclass, + section, + psymbol_placement::GLOBAL, + svalue, psymtab_language, + partial_symtabs, objfile); } } /* Link pst to FDR. dbx_end_psymtab returns NULL if the psymtab was - empty and put on the free list. */ + empty and put on the free list. */ fdr_to_pst[f_idx].pst - = dbx_end_psymtab (objfile, save_pst, + = dbx_end_psymtab (objfile, partial_symtabs, save_pst, psymtab_include_list, includes_used, -1, save_pst->raw_text_high (), dependency_list, dependencies_used, @@ -3654,22 +3667,22 @@ parse_partial_symbols (minimal_symbol_reader &reader, dependencies_used = 0; /* The objfile has its functions reordered if this partial symbol - table overlaps any other partial symbol table. - We cannot assume a reordered objfile if a partial symbol table - is contained within another partial symbol table, as partial symbol - tables for include files with executable code are contained - within the partial symbol table for the including source file, - and we do not want to flag the objfile reordered for these cases. - - This strategy works well for Irix-5.2 shared libraries, but we - might have to use a more elaborate (and slower) algorithm for - other cases. */ + table overlaps any other partial symbol table. + We cannot assume a reordered objfile if a partial symbol table + is contained within another partial symbol table, as partial symbol + tables for include files with executable code are contained + within the partial symbol table for the including source file, + and we do not want to flag the objfile reordered for these cases. + + This strategy works well for Irix-5.2 shared libraries, but we + might have to use a more elaborate (and slower) algorithm for + other cases. */ save_pst = fdr_to_pst[f_idx].pst; if (save_pst != NULL && save_pst->text_low_valid && !(objfile->flags & OBJF_REORDERED)) { - for (partial_symtab *iter : objfile->psymtabs ()) + for (partial_symtab *iter : partial_symtabs->range ()) { if (save_pst != iter && save_pst->raw_text_low () >= iter->raw_text_low () @@ -3697,10 +3710,10 @@ parse_partial_symbols (minimal_symbol_reader &reader, continue; /* Skip the first file indirect entry as it is a self dependency for - source files or a reverse .h -> .c dependency for header files. */ + source files or a reverse .h -> .c dependency for header files. */ pst->number_of_dependencies = 0; pst->dependencies - = objfile->partial_symtabs->allocate_dependencies (fh->crfd - 1); + = partial_symtabs->allocate_dependencies (fh->crfd - 1); for (s_idx = 1; s_idx < fh->crfd; s_idx++) { RFDT rh; @@ -3729,20 +3742,21 @@ parse_partial_symbols (minimal_symbol_reader &reader, /* Remove the dummy psymtab created for -O3 images above, if it is still empty, to enable the detection of stripped executables. */ - partial_symtab *pst_del = objfile->partial_symtabs->psymtabs; + partial_symtab *pst_del = partial_symtabs->psymtabs; if (pst_del->next == NULL && pst_del->number_of_dependencies == 0 - && pst_del->n_global_syms == 0 - && pst_del->n_static_syms == 0) - objfile->partial_symtabs->discard_psymtab (pst_del); + && pst_del->empty ()) + partial_symtabs->discard_psymtab (pst_del); } /* If the current psymbol has an enumerated type, we need to add all the enum constants to the partial symbol table. */ static void -handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype, - CORE_ADDR svalue) +handle_psymbol_enumerators (struct objfile *objfile, + psymtab_storage *partial_symtabs, + partial_symtab *pst, + FDR *fh, int stype, CORE_ADDR svalue) { const bfd_size_type external_sym_size = debug_swap->external_sym_size; void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; @@ -3758,12 +3772,12 @@ handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype, case stBlock: /* It is an enumerated type if the next symbol entry is a stMember - and its auxiliary index is indexNil or its auxiliary entry - is a plain btNil or btVoid. - Alpha cc -migrate enums are recognized by a zero index and - a zero symbol value. - DU 4.0 cc enums are recognized by a member type of btEnum without - qualifiers and a zero symbol value. */ + and its auxiliary index is indexNil or its auxiliary entry + is a plain btNil or btVoid. + Alpha cc -migrate enums are recognized by a zero index and + a zero symbol value. + DU 4.0 cc enums are recognized by a member type of btEnum without + qualifiers and a zero symbol value. */ (*swap_sym_in) (cur_bfd, ext_sym, &sh); if (sh.st != stMember) return; @@ -3796,11 +3810,11 @@ handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype, name = debug_info->ss + cur_fdr->issBase + sh.iss; /* Note that the value doesn't matter for enum constants - in psymtabs, just in symtabs. */ - add_psymbol_to_list (name, true, - VAR_DOMAIN, LOC_CONST, -1, - psymbol_placement::STATIC, 0, - psymtab_language, objfile); + in psymtabs, just in symtabs. */ + pst->add_psymbol (name, true, + VAR_DOMAIN, LOC_CONST, -1, + psymbol_placement::STATIC, 0, + psymtab_language, partial_symtabs, objfile); ext_sym += external_sym_size; } } @@ -3857,8 +3871,7 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile) /* Do nothing if this is a dummy psymtab. */ - if (pst->n_global_syms == 0 && pst->n_static_syms == 0 - && !pst->text_low_valid && !pst->text_high_valid) + if (pst->empty () && !pst->text_low_valid && !pst->text_high_valid) return; /* Now read the symbols for this symtab. */ @@ -3929,15 +3942,15 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile) enum language language = PST_PRIVATE (pst)->pst_language; /* We should never get non N_STAB symbols here, but they - should be harmless, so keep process_one_symbol from - complaining about them. */ + should be harmless, so keep process_one_symbol from + complaining about them. */ if (type_code & N_STAB) { /* If we found a trailing N_SO with no name, process - it here instead of in process_one_symbol, so we - can keep a handle to its symtab. The symtab - would otherwise be ended twice, once in - process_one_symbol, and once after this loop. */ + it here instead of in process_one_symbol, so we + can keep a handle to its symtab. The symtab + would otherwise be ended twice, once in + process_one_symbol, and once after this loop. */ if (type_code == N_SO && get_last_source_file () && previous_stab_code != (unsigned char) N_SO @@ -3945,7 +3958,7 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile) { valu += section_offsets[SECT_OFF_TEXT (objfile)]; previous_stab_code = N_SO; - cust = end_symtab (valu, SECT_OFF_TEXT (objfile)); + cust = end_compunit_symtab (valu, SECT_OFF_TEXT (objfile)); end_stabs (); last_symtab_ended = 1; } @@ -3971,10 +3984,10 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile) mdebug_extra_func_info); struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME); - SYMBOL_DOMAIN (s) = LABEL_DOMAIN; - SYMBOL_ACLASS_INDEX (s) = LOC_CONST; - SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_void; - SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e; + s->set_domain (LABEL_DOMAIN); + s->set_aclass_index (LOC_CONST); + s->set_type (objfile_type (objfile)->builtin_void); + s->set_value_bytes ((gdb_byte *) e); e->pdr.framereg = -1; add_symbol_to_list (s, get_local_symbols ()); } @@ -4005,15 +4018,16 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile) if (! last_symtab_ended) { - cust = end_symtab (pst->raw_text_high (), SECT_OFF_TEXT (objfile)); + cust = end_compunit_symtab (pst->raw_text_high (), + SECT_OFF_TEXT (objfile)); end_stabs (); } /* There used to be a call to sort_blocks here, but this should not - be necessary for stabs symtabs. And as sort_blocks modifies the - start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK, - it did the wrong thing if the first procedure in a file was - generated via asm statements. */ + be necessary for stabs symtabs. And as sort_blocks modifies the + start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK, + it did the wrong thing if the first procedure in a file was + generated via asm statements. */ /* Fill in procedure info next. */ if (fh->cpd > 0) @@ -4036,7 +4050,7 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile) (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in); /* Determine lowest PDR address, the PDRs are not always - sorted. */ + sorted. */ if (pdr_in == pr_block.data ()) lowest_pdr_addr = pdr_in->adr; else if (pdr_in->adr < lowest_pdr_addr) @@ -4068,21 +4082,21 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile) /* The proper language was already determined when building the psymtab, use it. */ - COMPUNIT_FILETABS (cust)->language = PST_PRIVATE (pst)->pst_language; + cust->primary_filetab ()->set_language + (PST_PRIVATE (pst)->pst_language); } - psymtab_language = COMPUNIT_FILETABS (cust)->language; + psymtab_language = cust->primary_filetab ()->language (); - lines = SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)); + lines = cust->primary_filetab ()->linetable (); /* Get a new lexical context. */ push_parse_stack (); - top_stack->cur_st = COMPUNIT_FILETABS (cust); - top_stack->cur_block - = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK); - BLOCK_START (top_stack->cur_block) = pst->text_low (objfile); - BLOCK_END (top_stack->cur_block) = 0; + top_stack->cur_st = cust->primary_filetab (); + top_stack->cur_block = cust->blockvector ()->static_block (); + top_stack->cur_block->set_start (pst->text_low (objfile)); + top_stack->cur_block->set_end (0); top_stack->blocktype = stFile; top_stack->cur_type = 0; top_stack->procadr = 0; @@ -4157,20 +4171,19 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile) size = lines->nitems; if (size > 1) --size; - SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)) - = ((struct linetable *) - obstack_copy (&mdebugread_objfile->objfile_obstack, - lines, (sizeof (struct linetable) - + size * sizeof (lines->item)))); + cust->primary_filetab ()->set_linetable + ((struct linetable *) + obstack_copy (&mdebugread_objfile->objfile_obstack, + lines, (sizeof (struct linetable) + + size * sizeof (lines->item)))); xfree (lines); /* .. and our share of externals. - XXX use the global list to speed up things here. How? - FIXME, Maybe quit once we have found the right number of ext's? */ - top_stack->cur_st = COMPUNIT_FILETABS (cust); + XXX use the global list to speed up things here. How? + FIXME, Maybe quit once we have found the right number of ext's? */ + top_stack->cur_st = cust->primary_filetab (); top_stack->cur_block - = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st), - GLOBAL_BLOCK); + = top_stack->cur_st->compunit ()->blockvector ()->global_block (); top_stack->blocktype = stFile; ext_ptr = PST_PRIVATE (pst)->extern_tab; @@ -4179,23 +4192,23 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile) section_offsets, objfile); /* If there are undefined symbols, tell the user. - The alpha has an undefined symbol for every symbol that is - from a shared library, so tell the user only if verbose is on. */ + The alpha has an undefined symbol for every symbol that is + from a shared library, so tell the user only if verbose is on. */ if (info_verbose && n_undef_symbols) { - printf_filtered (_("File %s contains %d unresolved references:"), - symtab_to_filename_for_display - (COMPUNIT_FILETABS (cust)), - 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); + gdb_printf (_("File %s contains %d unresolved references:"), + symtab_to_filename_for_display + (cust->primary_filetab ()), + n_undef_symbols); + gdb_printf ("\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_blocks (COMPUNIT_FILETABS (cust)); + sort_blocks (cust->primary_filetab ()); } /* Now link the psymtab and the symtab. */ @@ -4278,7 +4291,7 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, { *pname = ""; *tpp = init_type (mdebugread_objfile, type_code, 0, NULL); - TYPE_STUB (*tpp) = 1; + (*tpp)->set_is_stub (true); return result; } @@ -4379,12 +4392,12 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, case btTypedef: /* Follow a forward typedef. This might recursively - call cross_ref till we get a non typedef'ed type. - FIXME: This is not correct behaviour, but gdb currently - cannot handle typedefs without type copying. Type - copying is impossible as we might have mutual forward - references between two files and the copied type would not - get filled in when we later parse its definition. */ + call cross_ref till we get a non typedef'ed type. + FIXME: This is not correct behaviour, but gdb currently + cannot handle typedefs without type copying. Type + copying is impossible as we might have mutual forward + references between two files and the copied type would not + get filled in when we later parse its definition. */ *tpp = parse_type (xref_fd, debug_info->external_aux + fh->iauxBase, sh.index, @@ -4450,13 +4463,13 @@ mylookup_symbol (const char *name, const struct block *block, ALL_BLOCK_SYMBOLS (block, iter, sym) { if (sym->linkage_name ()[0] == inc - && SYMBOL_DOMAIN (sym) == domain - && SYMBOL_CLASS (sym) == theclass + && sym->domain () == domain + && sym->aclass () == theclass && strcmp (sym->linkage_name (), name) == 0) return sym; } - block = BLOCK_SUPERBLOCK (block); + block = block->superblock (); if (block) return mylookup_symbol (name, block, domain, theclass); return 0; @@ -4468,8 +4481,8 @@ mylookup_symbol (const char *name, const struct block *block, static void add_symbol (struct symbol *s, struct symtab *symtab, struct block *b) { - symbol_set_symtab (s, symtab); - mdict_add_symbol (BLOCK_MULTIDICT (b), s); + s->set_symtab (symtab); + mdict_add_symbol (b->multidict (), s); } /* Add a new block B to a symtab S. */ @@ -4479,16 +4492,18 @@ add_block (struct block *b, struct symtab *s) { /* Cast away "const", but that's ok because we're building the symtab and blockvector here. */ - struct blockvector *bv = (struct blockvector *) SYMTAB_BLOCKVECTOR (s); + struct blockvector *bv + = (struct blockvector *) s->compunit ()->blockvector (); bv = (struct blockvector *) xrealloc ((void *) bv, (sizeof (struct blockvector) - + BLOCKVECTOR_NBLOCKS (bv) - * sizeof (bv->block))); - if (bv != SYMTAB_BLOCKVECTOR (s)) - SYMTAB_BLOCKVECTOR (s) = bv; + + bv->num_blocks () + * sizeof (struct block))); + if (bv != s->compunit ()->blockvector ()) + s->compunit ()->set_blockvector (bv); - BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b; + bv->set_block (bv->num_blocks (), b); + bv->set_num_blocks (bv->num_blocks () + 1); } /* Add a new linenumber entry (LINENO,ADR) to a linevector LT. @@ -4531,13 +4546,13 @@ add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last) static bool block_is_less_than (const struct block *b1, const struct block *b2) { - CORE_ADDR start1 = BLOCK_START (b1); - CORE_ADDR start2 = BLOCK_START (b2); + CORE_ADDR start1 = b1->start (); + CORE_ADDR start2 = b2->start (); if (start1 != start2) return start1 < start2; - return (BLOCK_END (b2)) < (BLOCK_END (b1)); + return (b2->end ()) < (b1->end ()); } /* Sort the blocks of a symtab S. @@ -4549,15 +4564,16 @@ sort_blocks (struct symtab *s) { /* We have to cast away const here, but this is ok because we're constructing the blockvector in this code. */ - struct blockvector *bv = (struct blockvector *) SYMTAB_BLOCKVECTOR (s); + struct blockvector *bv + = (struct blockvector *) s->compunit ()->blockvector (); - if (BLOCKVECTOR_NBLOCKS (bv) <= FIRST_LOCAL_BLOCK) + if (bv->num_blocks () <= FIRST_LOCAL_BLOCK) { /* Cosmetic */ - if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0) - BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0; - if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0) - BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0; + if (bv->global_block ()->end () == 0) + bv->global_block ()->set_start (0); + if (bv->static_block ()->end () == 0) + bv->static_block ()->set_start (0); return; } /* @@ -4566,28 +4582,27 @@ sort_blocks (struct symtab *s) * are very different. It would be nice to find a reliable test * to detect -O3 images in advance. */ - if (BLOCKVECTOR_NBLOCKS (bv) > FIRST_LOCAL_BLOCK + 1) - std::sort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK), - &BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)), - block_is_less_than); + if (bv->num_blocks () > FIRST_LOCAL_BLOCK + 1) + { + gdb::array_view blocks_view = bv->blocks (); + + std::sort (blocks_view.begin () + FIRST_LOCAL_BLOCK, + blocks_view.end (), block_is_less_than); + } { CORE_ADDR high = 0; - int i, j = BLOCKVECTOR_NBLOCKS (bv); + int i, j = bv->num_blocks (); for (i = FIRST_LOCAL_BLOCK; i < j; i++) - if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i))) - high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)); - BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high; + if (high < bv->block (i)->end ()) + high = bv->block (i)->end (); + bv->global_block ()->set_end (high); } - BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = - BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK)); - - BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = - BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); - BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = - BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); + bv->global_block ()->set_start (bv->block (FIRST_LOCAL_BLOCK)->start ()); + bv->static_block ()->set_start (bv->global_block ()->start ()); + bv->static_block ()->set_end (bv->global_block ()->end ()); } @@ -4607,29 +4622,29 @@ new_symtab (const char *name, int maxlines, struct objfile *objfile) add_compunit_symtab_to_objfile (cust); symtab = allocate_symtab (cust, name); - SYMTAB_LINETABLE (symtab) = new_linetable (maxlines); + symtab->set_linetable (new_linetable (maxlines)); lang = compunit_language (cust); /* All symtabs must have at least two blocks. */ bv = new_bvect (2); - BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = new_block (NON_FUNCTION_BLOCK, lang); - BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = new_block (NON_FUNCTION_BLOCK, lang); - BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = - BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - COMPUNIT_BLOCKVECTOR (cust) = bv; + bv->set_block (GLOBAL_BLOCK, new_block (NON_FUNCTION_BLOCK, lang)); + bv->set_block (STATIC_BLOCK, new_block (NON_FUNCTION_BLOCK, lang)); + bv->static_block ()->set_superblock (bv->global_block ()); + cust->set_blockvector (bv); - COMPUNIT_DEBUGFORMAT (cust) = "ECOFF"; + cust->set_debugformat ("ECOFF"); return cust; } /* Allocate a new partial_symtab NAME. */ static legacy_psymtab * -new_psymtab (const char *name, struct objfile *objfile) +new_psymtab (const char *name, psymtab_storage *partial_symtabs, + struct objfile *objfile) { legacy_psymtab *psymtab; - psymtab = new legacy_psymtab (name, objfile); + psymtab = new legacy_psymtab (name, partial_symtabs, objfile->per_bfd); /* Keep a backpointer to the file's symbols. */ @@ -4689,8 +4704,7 @@ new_bvect (int nblocks) size = sizeof (struct blockvector) + nblocks * sizeof (struct block *); bv = (struct blockvector *) xzalloc (size); - - BLOCKVECTOR_NBLOCKS (bv) = nblocks; + bv->set_num_blocks (nblocks); return bv; } @@ -4709,9 +4723,9 @@ new_block (enum block_type type, enum language language) struct block *retval = XCNEW (struct block); if (type == FUNCTION_BLOCK) - BLOCK_MULTIDICT (retval) = mdict_create_linear_expandable (language); + retval->set_multidict (mdict_create_linear_expandable (language)); else - BLOCK_MULTIDICT (retval) = mdict_create_hashed_expandable (language); + retval->set_multidict (mdict_create_hashed_expandable (language)); return retval; }