X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmdebugread.c;h=ceffc012c11f7fca6aa19567e7436277d2da2d65;hb=c1b5c1ebc938b6dc0277363b8c47d75b0b5a621f;hp=dffef8fd1a4cac5c4b6f22eb4a2459c080b3bc8a;hpb=67547d896b0593b0fa62e23ac68c483a7e8566e2;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index dffef8fd1a..ceffc012c1 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -68,6 +68,8 @@ #include "expression.h" +#include + /* Provide a way to test if we have both ECOFF and ELF symbol tables. We use this define in order to know whether we should override a symbol's ECOFF section with its ELF section. This is necessary in @@ -187,7 +189,7 @@ static const struct ecoff_debug_swap *debug_swap; static struct ecoff_debug_info *debug_info; -/* Pointer to current file decriptor record, and its index. */ +/* Pointer to current file descriptor record, and its index. */ static FDR *cur_fdr; static int cur_fd; @@ -539,7 +541,7 @@ mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch) if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch)) { reg_value_complaint (regno, gdbarch_num_cooked_regs (gdbarch), - SYMBOL_PRINT_NAME (sym)); + sym->print_name ()); regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */ } @@ -632,7 +634,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, b = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st), GLOBAL_BLOCK); s = new_symbol (name); - SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; + SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value); add_data_symbol (sh, ax, bigend, s, LOC_STATIC, b, objfile, name); break; @@ -644,12 +646,12 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, /* It is a FORTRAN common block. At least for SGI Fortran the address is not in the symbol; we need to fix it later in scan_file_globals. */ - int bucket = hashname (SYMBOL_LINKAGE_NAME (s)); + int bucket = hashname (s->linkage_name ()); SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket]; global_sym_chain[bucket] = s; } else - SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; + SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value); add_data_symbol (sh, ax, bigend, s, LOC_STATIC, b, objfile, name); break; @@ -706,7 +708,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, s = new_symbol (name); SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* So that it can be used */ SYMBOL_ACLASS_INDEX (s) = LOC_LABEL; /* but not misused. */ - SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; + SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value); SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int; add_symbol (s, top_stack->cur_st, top_stack->cur_block); break; @@ -792,11 +794,11 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, /* All functions in C++ have prototypes. For C we don't have enough information in the debug info. */ - if (SYMBOL_LANGUAGE (s) == language_cplus) + if (s->language () == language_cplus) TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1; /* Create and enter a new lexical context. */ - b = new_block (FUNCTION_BLOCK, SYMBOL_LANGUAGE (s)); + b = new_block (FUNCTION_BLOCK, s->language ()); SYMBOL_BLOCK_VALUE (s) = b; BLOCK_FUNCTION (b) = s; BLOCK_START (b) = BLOCK_END (b) = sh->value; @@ -1064,9 +1066,8 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, FIELD_BITSIZE (*f) = 0; enum_sym = allocate_symbol (mdebugread_objfile); - SYMBOL_SET_LINKAGE_NAME - (enum_sym, - obstack_strdup (&mdebugread_objfile->objfile_obstack, + 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; @@ -1332,7 +1333,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, for anything except pointers or functions. */ } else - TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s); + TYPE_NAME (SYMBOL_TYPE (s)) = s->linkage_name (); } break; @@ -1993,7 +1994,7 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab, s = new_symbol (sh_name); SYMBOL_DOMAIN (s) = VAR_DOMAIN; SYMBOL_CLASS (s) = LOC_BLOCK; - /* Donno its type, hope int is ok. */ + /* Don't know its type, hope int is ok. */ SYMBOL_TYPE (s) = lookup_function_type (objfile_type (pst->objfile)->builtin_int); add_symbol (s, top_stack->cur_st, top_stack->cur_block); @@ -2338,7 +2339,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, the text section (and fh->adr) really starts at zero. */ text_sect = bfd_get_section_by_name (cur_bfd, ".text"); if (text_sect != NULL - && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC)) + && (bfd_section_flags (text_sect) & SEC_RELOC)) relocatable = 1; extern_tab = XOBNEWVEC (&objfile->objfile_obstack, EXTR, hdr->iextMax); @@ -2442,7 +2443,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, (inefficient; assumes no side-effects result from ignoring ECOFF symbol) 3) create it, but lookup ELF's minimal symbol and use it's section - during relocation, then modify "uniqify" phase to merge and + during relocation, then modify "uniquify" phase to merge and eliminate the duplicate symbol (highly inefficient) @@ -3048,8 +3049,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, namestring = gdbarch_static_transform_name (gdbarch, namestring); - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_STATIC, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_STATIC, SECT_OFF_DATA (objfile), psymbol_placement::STATIC, sh.value, @@ -3059,8 +3061,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, /* The addresses in these entries are reported to be wrong. See the code that reads 'G's for symtabs. */ - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_STATIC, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_STATIC, SECT_OFF_DATA (objfile), psymbol_placement::GLOBAL, sh.value, @@ -3078,21 +3081,20 @@ parse_partial_symbols (minimal_symbol_reader &reader, || (p == namestring + 1 && namestring[0] != ' ')) { - add_psymbol_to_list (namestring, p - namestring, true, - STRUCT_DOMAIN, LOC_TYPEDEF, - -1, - psymbol_placement::STATIC, - 0, psymtab_language, objfile); + add_psymbol_to_list + (gdb::string_view (namestring, p - namestring), + true, STRUCT_DOMAIN, LOC_TYPEDEF, -1, + psymbol_placement::STATIC, 0, psymtab_language, + objfile); if (p[2] == 't') { /* Also a typedef with the same name. */ - add_psymbol_to_list (namestring, - p - namestring, true, - VAR_DOMAIN, LOC_TYPEDEF, - -1, - psymbol_placement::STATIC, - 0, psymtab_language, - objfile); + add_psymbol_to_list + (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_TYPEDEF, -1, + psymbol_placement::STATIC, 0, + psymtab_language, objfile); p += 1; } } @@ -3101,11 +3103,12 @@ parse_partial_symbols (minimal_symbol_reader &reader, if (p != namestring) /* a name is there, not just :T... */ { - add_psymbol_to_list (namestring, p - namestring, - true, VAR_DOMAIN, LOC_TYPEDEF, - -1, - psymbol_placement::STATIC, - 0, psymtab_language, objfile); + add_psymbol_to_list + (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_TYPEDEF, -1, + psymbol_placement::STATIC, 0, psymtab_language, + objfile); } check_enum: /* If this is an enumerated type, we need to add @@ -3166,9 +3169,10 @@ 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 (p, q - p, true, - VAR_DOMAIN, LOC_CONST, - -1, + add_psymbol_to_list (gdb::string_view (p, + q - p), + true, VAR_DOMAIN, + LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); @@ -3185,8 +3189,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, continue; case 'c': /* Constant, e.g. from "const" in Pascal. */ - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_CONST, -1, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); continue; @@ -3198,8 +3203,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, function_outside_compilation_unit_complaint (copy.c_str ()); } - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_BLOCK, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), psymbol_placement::STATIC, sh.value, @@ -3217,8 +3223,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, function_outside_compilation_unit_complaint (copy.c_str ()); } - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_BLOCK, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), psymbol_placement::GLOBAL, sh.value, @@ -3442,7 +3449,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, /* Usually there is a local and a global stProc symbol for a function. This means that the function name - has already been entered into the mimimal symbol table + has already been entered into the minimal symbol table while processing the global symbols in pass 2 above. One notable exception is the PROGRAM name from f77 compiled executables, it is only put out as @@ -3452,13 +3459,13 @@ 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, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, VAR_DOMAIN, LOC_BLOCK, section, psymbol_placement::GLOBAL, sh.value, psymtab_language, objfile); else - add_psymbol_to_list (sym_name, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, VAR_DOMAIN, LOC_BLOCK, section, psymbol_placement::STATIC, @@ -3525,7 +3532,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, && sh.iss != 0 && sh.index != cur_sdx + 2) { - add_psymbol_to_list (sym_name, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, STRUCT_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); @@ -3565,7 +3572,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, continue; } /* Use this gdb symbol. */ - add_psymbol_to_list (sym_name, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, VAR_DOMAIN, theclass, section, psymbol_placement::STATIC, sh.value, psymtab_language, objfile); @@ -3644,7 +3651,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, break; } char *sym_name = debug_info->ssext + psh->iss; - add_psymbol_to_list (sym_name, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, VAR_DOMAIN, theclass, section, psymbol_placement::GLOBAL, @@ -3729,7 +3736,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, if (rh == f_idx) continue; - /* Do not add to dependeny list if psymtab was empty. */ + /* Do not add to dependency list if psymtab was empty. */ if (fdr_to_pst[rh].pst == NULL) continue; pst->dependencies[pst->number_of_dependencies++] @@ -3807,7 +3814,7 @@ handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype, /* Note that the value doesn't matter for enum constants in psymtabs, just in symtabs. */ - add_psymbol_to_list (name, strlen (name), true, + add_psymbol_to_list (name, true, VAR_DOMAIN, LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); @@ -3861,7 +3868,7 @@ psymtab_to_symtab_1 (struct objfile *objfile, return; pst->readin = 1; - /* Read in all partial symbtabs on which this one is dependent. + /* Read in all partial symtabs on which this one is dependent. NOTE that we do have circular dependencies, sigh. We solved that by setting pst->readin before this point. */ @@ -4481,10 +4488,10 @@ mylookup_symbol (const char *name, const struct block *block, inc = name[0]; ALL_BLOCK_SYMBOLS (block, iter, sym) { - if (SYMBOL_LINKAGE_NAME (sym)[0] == inc + if (sym->linkage_name ()[0] == inc && SYMBOL_DOMAIN (sym) == domain && SYMBOL_CLASS (sym) == theclass - && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0) + && strcmp (sym->linkage_name (), name) == 0) return sym; } @@ -4560,17 +4567,16 @@ add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last) /* Blocks with a smaller low bound should come first. */ -static int -compare_blocks (const void *arg1, const void *arg2) +static bool +block_is_less_than (const struct block *b1, const struct block *b2) { - LONGEST addr_diff; - struct block **b1 = (struct block **) arg1; - struct block **b2 = (struct block **) arg2; - - addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2))); - if (addr_diff == 0) - return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1))); - return addr_diff; + CORE_ADDR start1 = BLOCK_START (b1); + CORE_ADDR start2 = BLOCK_START (b2); + + if (start1 != start2) + return start1 < start2; + + return (BLOCK_END (b2)) < (BLOCK_END (b1)); } /* Sort the blocks of a symtab S. @@ -4600,10 +4606,9 @@ sort_blocks (struct symtab *s) * to detect -O3 images in advance. */ if (BLOCKVECTOR_NBLOCKS (bv) > FIRST_LOCAL_BLOCK + 1) - qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK), - BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK, - sizeof (struct block *), - compare_blocks); + std::sort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK), + &BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)), + block_is_less_than); { CORE_ADDR high = 0; @@ -4758,7 +4763,7 @@ new_symbol (const char *name) SYMBOL_SET_LANGUAGE (s, psymtab_language, &mdebugread_objfile->objfile_obstack); - SYMBOL_SET_NAMES (s, name, strlen (name), 1, mdebugread_objfile); + SYMBOL_SET_NAMES (s, name, true, mdebugread_objfile); return s; }