X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsymtab.c;h=cdd9f2e4c12c737b74f1a7eda33111039e8a8769;hb=60318db6c5459d73ac6fa1ff6d44ca17d797a1aa;hp=a082ee21a90898cc3f1b3310940175ccf12fceac;hpb=c1b5c1ebc938b6dc0277363b8c47d75b0b5a621f;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/symtab.c b/gdb/symtab.c index a082ee21a9..cdd9f2e4c1 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -1,6 +1,6 @@ /* Symbol table lookup for the GNU debugger, GDB. - Copyright (C) 1986-2019 Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -712,28 +712,26 @@ symbol_get_demangled_name (const struct general_symbol_info *gsymbol) depending upon the language for the symbol. */ void -symbol_set_language (struct general_symbol_info *gsymbol, - enum language language, - struct obstack *obstack) +general_symbol_info::set_language (enum language language, + struct obstack *obstack) { - gsymbol->m_language = language; + m_language = language; if (language == language_cplus || language == language_d || language == language_go || language == language_objc || language == language_fortran) { - symbol_set_demangled_name (gsymbol, NULL, obstack); + symbol_set_demangled_name (this, NULL, obstack); } else if (language == language_ada) { - gdb_assert (gsymbol->ada_mangled == 0); - gsymbol->language_specific.obstack = obstack; + gdb_assert (ada_mangled == 0); + language_specific.obstack = obstack; } else { - memset (&gsymbol->language_specific, 0, - sizeof (gsymbol->language_specific)); + memset (&language_specific, 0, sizeof (language_specific)); } } @@ -857,19 +855,19 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol, so the pointer can be discarded after calling this function. */ void -symbol_set_names (struct general_symbol_info *gsymbol, - gdb::string_view linkage_name, bool copy_name, - struct objfile_per_bfd_storage *per_bfd, - gdb::optional hash) +general_symbol_info::compute_and_set_names (gdb::string_view linkage_name, + bool copy_name, + objfile_per_bfd_storage *per_bfd, + gdb::optional hash) { struct demangled_name_entry **slot; - if (gsymbol->language () == language_ada) + if (language () == language_ada) { /* In Ada, we do the symbol lookups using the mangled name, so we can save some space by not storing the demangled name. */ if (!copy_name) - gsymbol->name = linkage_name.data (); + m_name = linkage_name.data (); else { char *name = (char *) obstack_alloc (&per_bfd->storage_obstack, @@ -877,9 +875,9 @@ symbol_set_names (struct general_symbol_info *gsymbol, memcpy (name, linkage_name.data (), linkage_name.length ()); name[linkage_name.length ()] = '\0'; - gsymbol->name = name; + m_name = name; } - symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack); + symbol_set_demangled_name (this, NULL, &per_bfd->storage_obstack); return; } @@ -894,11 +892,21 @@ symbol_set_names (struct general_symbol_info *gsymbol, htab_find_slot_with_hash (per_bfd->demangled_names_hash.get (), &entry, *hash, INSERT)); + /* The const_cast is safe because the only reason it is already + initialized is if we purposefully set it from a background + thread to avoid doing the work here. However, it is still + allocated from the heap and needs to be freed by us, just + like if we called symbol_find_demangled_name here. If this is + nullptr, we call symbol_find_demangled_name below, but we put + this smart pointer here to be sure that we don't leak this name. */ + gdb::unique_xmalloc_ptr demangled_name + (const_cast (language_specific.demangled_name)); + /* If this name is not in the hash table, add it. */ if (*slot == NULL /* A C version of the symbol may have already snuck into the table. This happens to, e.g., main.init (__go_init_main). Cope. */ - || (gsymbol->language () == language_go && (*slot)->demangled == nullptr)) + || (language () == language_go && (*slot)->demangled == nullptr)) { /* A 0-terminated copy of the linkage name. Callers must set COPY_NAME to true if the string might not be nullterminated. We have to make @@ -916,15 +924,9 @@ symbol_set_names (struct general_symbol_info *gsymbol, else linkage_name_copy = linkage_name; - /* The const_cast is safe because the only reason it is already - initialized is if we purposefully set it from a background - thread to avoid doing the work here. However, it is still - allocated from the heap and needs to be freed by us, just - like if we called symbol_find_demangled_name here. */ - gdb::unique_xmalloc_ptr demangled_name - (gsymbol->language_specific.demangled_name - ? const_cast (gsymbol->language_specific.demangled_name) - : symbol_find_demangled_name (gsymbol, linkage_name_copy.data ())); + if (demangled_name.get () == nullptr) + demangled_name.reset + (symbol_find_demangled_name (this, linkage_name_copy.data ())); /* Suppose we have demangled_name==NULL, copy_name==0, and linkage_name_copy==linkage_name. In this case, we already have the @@ -959,18 +961,17 @@ symbol_set_names (struct general_symbol_info *gsymbol, (gdb::string_view (mangled_ptr, linkage_name.length ())); } (*slot)->demangled = std::move (demangled_name); - (*slot)->language = gsymbol->language (); + (*slot)->language = language (); } - else if (gsymbol->language () == language_unknown - || gsymbol->language () == language_auto) - gsymbol->m_language = (*slot)->language; + else if (language () == language_unknown || language () == language_auto) + m_language = (*slot)->language; - gsymbol->name = (*slot)->mangled.data (); + m_name = (*slot)->mangled.data (); if ((*slot)->demangled != nullptr) - symbol_set_demangled_name (gsymbol, (*slot)->demangled.get (), + symbol_set_demangled_name (this, (*slot)->demangled.get (), &per_bfd->storage_obstack); else - symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack); + symbol_set_demangled_name (this, NULL, &per_bfd->storage_obstack); } /* See symtab.h. */ @@ -993,7 +994,7 @@ general_symbol_info::natural_name () const default: break; } - return name; + return linkage_name (); } /* See symtab.h. */ @@ -1027,7 +1028,7 @@ const char * general_symbol_info::search_name () const { if (language () == language_ada) - return name; + return linkage_name (); else return natural_name (); } @@ -1672,7 +1673,8 @@ fixup_section (struct general_symbol_info *ginfo, e.g. on PowerPC64, where the minimal symbol for a function will point to the function descriptor, while the debug symbol will point to the actual function code. */ - msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile); + msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->linkage_name (), + objfile); if (msym) ginfo->section = MSYMBOL_SECTION (msym); else @@ -1689,11 +1691,10 @@ fixup_section (struct general_symbol_info *ginfo, So, instead, search the section table when lookup by name has failed. The ``addr'' and ``endaddr'' fields may have already - been relocated. If so, the relocation offset (i.e. the - ANOFFSET value) needs to be subtracted from these values when - performing the comparison. We unconditionally subtract it, - because, when no relocation has been performed, the ANOFFSET - value will simply be zero. + been relocated. If so, the relocation offset needs to be + subtracted from these values when performing the comparison. + We unconditionally subtract it, because, when no relocation + has been performed, the value will simply be zero. The address of the symbol whose section we're fixing up HAS NOT BEEN adjusted (relocated) yet. It can't have been since @@ -1719,7 +1720,7 @@ fixup_section (struct general_symbol_info *ginfo, ALL_OBJFILE_OSECTIONS (objfile, s) { int idx = s - objfile->sections; - CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx); + CORE_ADDR offset = objfile->section_offsets[idx]; if (fallback == -1) fallback = idx; @@ -6375,8 +6376,7 @@ get_msymbol_address (struct objfile *objf, const struct minimal_symbol *minsym) return BMSYMBOL_VALUE_ADDRESS (found); } } - return (minsym->value.address - + ANOFFSET (objf->section_offsets, minsym->section)); + return minsym->value.address + objf->section_offsets[minsym->section]; }