CORE_ADDR,
struct obj_section *);
-static void fixup_psymbol_section (struct partial_symbol *psym,
- struct objfile *objfile);
-
static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
struct partial_symtab *pst);
{
struct partial_symtab *tpst;
struct partial_symtab *best_pst = pst;
- CORE_ADDR best_addr = pst->textlow;
+ CORE_ADDR best_addr = pst->text_low (objfile);
gdb_assert (!pst->psymtabs_addrmap_supported);
that is closest and still less than the given PC. */
for (tpst = pst; tpst != NULL; tpst = tpst->next)
{
- if (pc >= tpst->textlow && pc < tpst->texthigh)
+ if (pc >= tpst->text_low (objfile) && pc < tpst->text_high (objfile))
{
struct partial_symbol *p;
CORE_ADDR this_addr;
object's symbol table. */
p = find_pc_sect_psymbol (objfile, tpst, pc, section);
if (p != NULL
- && (SYMBOL_VALUE_ADDRESS (p)
- == BMSYMBOL_VALUE_ADDRESS (msymbol)))
+ && (p->address (objfile) == BMSYMBOL_VALUE_ADDRESS (msymbol)))
return tpst;
/* Also accept the textlow value of a psymtab as a
symbol tables with line information but no debug
symbols (e.g. those produced by an assembler). */
if (p != NULL)
- this_addr = SYMBOL_VALUE_ADDRESS (p);
+ this_addr = p->address (objfile);
else
- this_addr = tpst->textlow;
+ this_addr = tpst->text_low (objfile);
/* Check whether it is closer than our current
BEST_ADDR. Since this symbol address is
struct bound_minimal_symbol msymbol)
{
struct partial_symtab *pst;
+ CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
+ SECT_OFF_TEXT (objfile));
/* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
than the later used TEXTLOW/TEXTHIGH one. */
if (objfile->psymtabs_addrmap != NULL)
{
pst = ((struct partial_symtab *)
- addrmap_find (objfile->psymtabs_addrmap, pc));
+ addrmap_find (objfile->psymtabs_addrmap, pc - baseaddr));
if (pst != NULL)
{
/* FIXME: addrmaps currently do not handle overlayed sections,
object's symbol table. */
p = find_pc_sect_psymbol (objfile, pst, pc, section);
if (p == NULL
- || (SYMBOL_VALUE_ADDRESS (p)
+ || (p->address (objfile)
!= BMSYMBOL_VALUE_ADDRESS (msymbol)))
goto next;
}
ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
if (!pst->psymtabs_addrmap_supported
- && pc >= pst->textlow && pc < pst->texthigh)
+ && pc >= pst->text_low (objfile) && pc < pst->text_high (objfile))
{
struct partial_symtab *best_pst;
{
struct partial_symbol *best = NULL;
CORE_ADDR best_pc;
+ const CORE_ADDR textlow = psymtab->text_low (objfile);
gdb_assert (psymtab != NULL);
/* Cope with programs that start at address 0. */
- best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
+ best_pc = (textlow != 0) ? textlow - 1 : 0;
/* Search the global symbols as well as the static symbols, so that
find_pc_partial_function doesn't use a minimal symbol and thus
{
partial_symbol *p = objfile->global_psymbols[psymtab->globals_offset + i];
- if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
- && PSYMBOL_CLASS (p) == LOC_BLOCK
- && pc >= SYMBOL_VALUE_ADDRESS (p)
- && (SYMBOL_VALUE_ADDRESS (p) > best_pc
- || (psymtab->textlow == 0
- && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
+ if (p->domain == VAR_DOMAIN
+ && p->aclass == LOC_BLOCK
+ && pc >= p->address (objfile)
+ && (p->address (objfile) > best_pc
+ || (psymtab->text_low (objfile) == 0
+ && best_pc == 0 && p->address (objfile) == 0)))
{
if (section != NULL) /* Match on a specific section. */
{
- fixup_psymbol_section (p, objfile);
- if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+ if (!matching_obj_sections (p->obj_section (objfile),
section))
continue;
}
- best_pc = SYMBOL_VALUE_ADDRESS (p);
+ best_pc = p->address (objfile);
best = p;
}
}
{
partial_symbol *p = objfile->static_psymbols[psymtab->statics_offset + i];
- if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
- && PSYMBOL_CLASS (p) == LOC_BLOCK
- && pc >= SYMBOL_VALUE_ADDRESS (p)
- && (SYMBOL_VALUE_ADDRESS (p) > best_pc
- || (psymtab->textlow == 0
- && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
+ if (p->domain == VAR_DOMAIN
+ && p->aclass == LOC_BLOCK
+ && pc >= p->address (objfile)
+ && (p->address (objfile) > best_pc
+ || (psymtab->text_low (objfile) == 0
+ && best_pc == 0 && p->address (objfile) == 0)))
{
if (section != NULL) /* Match on a specific section. */
{
- fixup_psymbol_section (p, objfile);
- if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
+ if (!matching_obj_sections (p->obj_section (objfile),
section))
continue;
}
- best_pc = SYMBOL_VALUE_ADDRESS (p);
+ best_pc = p->address (objfile);
best = p;
}
}
return best;
}
-static void
-fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
-{
- CORE_ADDR addr;
-
- if (psym == NULL)
- return;
-
- if (SYMBOL_SECTION (psym) >= 0)
- return;
-
- gdb_assert (objfile);
-
- switch (PSYMBOL_CLASS (psym))
- {
- case LOC_STATIC:
- case LOC_LABEL:
- case LOC_BLOCK:
- addr = SYMBOL_VALUE_ADDRESS (psym);
- break;
- default:
- /* Nothing else will be listed in the minsyms -- no use looking
- it up. */
- return;
- }
-
- fixup_section (&psym->ginfo, addr, objfile);
-}
-
/* Psymtab version of lookup_symbol. See its definition in
the definition of quick_symbol_functions in symfile.h. */
psymbol_name_matches (partial_symbol *psym,
const lookup_name_info &lookup_name)
{
- const language_defn *lang = language_def (SYMBOL_LANGUAGE (psym));
+ const language_defn *lang = language_def (psym->language);
symbol_name_matcher_ftype *name_match
- = language_get_symbol_name_matcher (lang, lookup_name);
- return name_match (SYMBOL_SEARCH_NAME (psym), lookup_name, NULL);
+ = get_symbol_name_matcher (lang, lookup_name);
+ return name_match (symbol_search_name (psym), lookup_name, NULL);
}
/* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
center = bottom + (top - bottom) / 2;
gdb_assert (center < top);
- enum language lang = SYMBOL_LANGUAGE (*center);
+ enum language lang = (*center)->language;
const char *lang_ln
= lookup_name.language_lookup_name (lang).c_str ();
- if (ordered_compare (SYMBOL_SEARCH_NAME (*center), lang_ln) >= 0)
+ if (ordered_compare (symbol_search_name (*center), lang_ln) >= 0)
top = center;
else
bottom = center + 1;
while (top <= real_top
&& psymbol_name_matches (*top, lookup_name))
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
- SYMBOL_DOMAIN (*top), domain))
+ if (symbol_matches_domain ((*top)->language,
+ (*top)->domain, domain))
return *top;
top++;
}
{
for (psym = start; psym < start + length; psym++)
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
- SYMBOL_DOMAIN (*psym), domain)
+ if (symbol_matches_domain ((*psym)->language,
+ (*psym)->domain, domain)
&& psymbol_name_matches (*psym, lookup_name))
return *psym;
}
if (!(center < top))
internal_error (__FILE__, __LINE__,
_("failed internal consistency check"));
- if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
+ if (strcmp_iw_ordered (symbol_search_name (*center),
search_name.get ()) >= 0)
{
top = center;
/* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
- while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, lookup_name))
+ while (top >= start && symbol_matches_search_name (*top, lookup_name))
top--;
/* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
top++;
- while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, lookup_name))
+ while (top <= real_top && symbol_matches_search_name (*top, lookup_name))
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
- SYMBOL_DOMAIN (*top), domain))
+ if (symbol_matches_domain ((*top)->language,
+ (*top)->domain, domain))
return *top;
top++;
}
{
for (psym = start; psym < start + length; psym++)
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
- SYMBOL_DOMAIN (*psym), domain)
- && SYMBOL_MATCHES_SEARCH_NAME (*psym, lookup_name))
+ if (symbol_matches_domain ((*psym)->language,
+ (*psym)->domain, domain)
+ && symbol_matches_search_name (*psym, lookup_name))
return *psym;
}
}
return pst->compunit_symtab;
}
-/* Psymtab version of relocate. See its definition in
- the definition of quick_symbol_functions in symfile.h. */
-
-static void
-psym_relocate (struct objfile *objfile,
- const struct section_offsets *new_offsets,
- const struct section_offsets *delta)
-{
- struct partial_symtab *p;
-
- ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
- {
- p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
- p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
- }
-
- for (partial_symbol *psym : objfile->global_psymbols)
- {
- fixup_psymbol_section (psym, objfile);
- if (SYMBOL_SECTION (psym) >= 0)
- SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym));
- }
- for (partial_symbol *psym : objfile->static_psymbols)
- {
- fixup_psymbol_section (psym, objfile);
- if (SYMBOL_SECTION (psym) >= 0)
- SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym));
- }
-
- objfile->psymbol_map.clear ();
-}
-
/* Psymtab version of find_last_source_symtab. See its definition in
the definition of quick_symbol_functions in symfile.h. */
}
static void
-print_partial_symbols (struct gdbarch *gdbarch,
+print_partial_symbols (struct gdbarch *gdbarch, struct objfile *objfile,
struct partial_symbol **p, int count, const char *what,
struct ui_file *outfile)
{
while (count-- > 0)
{
QUIT;
- fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
- if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
+ fprintf_filtered (outfile, " `%s'", (*p)->name);
+ if (symbol_demangled_name (*p) != NULL)
{
- fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
+ fprintf_filtered (outfile, " `%s'", symbol_demangled_name (*p));
}
fputs_filtered (", ", outfile);
- switch (SYMBOL_DOMAIN (*p))
+ switch ((*p)->domain)
{
case UNDEF_DOMAIN:
fputs_filtered ("undefined domain, ", outfile);
fputs_filtered ("<invalid domain>, ", outfile);
break;
}
- switch (PSYMBOL_CLASS (*p))
+ switch ((*p)->aclass)
{
case LOC_UNDEF:
fputs_filtered ("undefined", outfile);
break;
}
fputs_filtered (", ", outfile);
- fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
+ fputs_filtered (paddress (gdbarch, (*p)->unrelocated_address ()), outfile);
fprintf_filtered (outfile, "\n");
p++;
}
}
fprintf_filtered (outfile, " Symbols cover text addresses ");
- fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
+ fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)), outfile);
fprintf_filtered (outfile, "-");
- fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
+ fputs_filtered (paddress (gdbarch, psymtab->text_high (objfile)), outfile);
fprintf_filtered (outfile, "\n");
fprintf_filtered (outfile, " Address map supported - %s.\n",
psymtab->psymtabs_addrmap_supported ? "yes" : "no");
}
if (psymtab->n_global_syms > 0)
{
- print_partial_symbols (gdbarch,
+ print_partial_symbols (gdbarch, objfile,
&objfile->global_psymbols[psymtab->globals_offset],
psymtab->n_global_syms, "Global", outfile);
}
if (psymtab->n_static_syms > 0)
{
- print_partial_symbols (gdbarch,
+ print_partial_symbols (gdbarch, objfile,
&objfile->static_psymbols[psymtab->statics_offset],
psymtab->n_static_syms, "Static", outfile);
}
to handle cases like the file being moved. */
if (ps->fullname == NULL)
{
- int fd = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
+ gdb::unique_xmalloc_ptr<char> fullname;
+ int fd = find_and_open_source (ps->filename, ps->dirname, &fullname);
+ ps->fullname = fullname.release ();
if (fd >= 0)
close (fd);
else
{
- gdb::unique_xmalloc_ptr<char> fullname;
-
/* rewrite_source_path would be applied by find_and_open_source, we
should report the pathname where GDB tried to find the file. */
if ((domain == ALL_DOMAIN
|| (domain == VARIABLES_DOMAIN
- && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF
- && PSYMBOL_CLASS (*psym) != LOC_BLOCK)
+ && (*psym)->aclass != LOC_TYPEDEF
+ && (*psym)->aclass != LOC_BLOCK)
|| (domain == FUNCTIONS_DOMAIN
- && PSYMBOL_CLASS (*psym) == LOC_BLOCK)
+ && (*psym)->aclass == LOC_BLOCK)
|| (domain == TYPES_DOMAIN
- && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
+ && (*psym)->aclass == LOC_TYPEDEF))
&& psymbol_name_matches (*psym, lookup_name)
- && (sym_matcher == NULL || sym_matcher (SYMBOL_SEARCH_NAME (*psym))))
+ && (sym_matcher == NULL || sym_matcher (symbol_search_name (*psym))))
{
/* Found a match, so notify our caller. */
result = PST_SEARCHED_AND_FOUND;
{
struct partial_symbol *psym = symbols[start + i];
- if (PSYMBOL_CLASS (psym) == LOC_STATIC)
+ if (psym->aclass == LOC_STATIC)
{
- CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (psym);
+ CORE_ADDR addr = psym->address (objfile);
if (seen_addrs->find (addr) == seen_addrs->end ())
{
seen_addrs->insert (addr);
psym_lookup_symbol,
psym_print_stats,
psym_dump,
- psym_relocate,
psym_expand_symtabs_for_function,
psym_expand_all_symtabs,
psym_expand_symtabs_with_fullname,
std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2)
{
- return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (s1),
- SYMBOL_SEARCH_NAME (s2)) < 0;
+ return strcmp_iw_ordered (symbol_search_name (s1),
+ symbol_search_name (s2)) < 0;
});
}
struct partial_symtab *psymtab;
psymtab = allocate_psymtab (filename, objfile);
- psymtab->textlow = textlow;
- psymtab->texthigh = psymtab->textlow; /* default */
+ psymtab->set_text_low (textlow);
+ psymtab->set_text_high (psymtab->raw_text_low ()); /* default */
psymtab->globals_offset = global_psymbols.size ();
psymtab->statics_offset = static_psymbols.size ();
return psymtab;
{
unsigned long h = 0;
struct partial_symbol *psymbol = (struct partial_symbol *) addr;
- unsigned int lang = psymbol->ginfo.language;
- unsigned int domain = PSYMBOL_DOMAIN (psymbol);
- unsigned int theclass = PSYMBOL_CLASS (psymbol);
+ unsigned int lang = psymbol->language;
+ unsigned int domain = psymbol->domain;
+ unsigned int theclass = psymbol->aclass;
- h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
+ h = hash_continue (&psymbol->value, sizeof (psymbol->value), h);
h = hash_continue (&lang, sizeof (unsigned int), h);
h = hash_continue (&domain, sizeof (unsigned int), h);
h = hash_continue (&theclass, sizeof (unsigned int), h);
/* Note that psymbol names are interned via symbol_set_names, so
there's no need to hash the contents of the name here. */
- h = hash_continue (&psymbol->ginfo.name, sizeof (psymbol->ginfo.name), h);
+ h = hash_continue (&psymbol->name,
+ sizeof (psymbol->name), h);
return h;
}
struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
- return (memcmp (&sym1->ginfo.value, &sym2->ginfo.value,
- sizeof (sym1->ginfo.value)) == 0
- && sym1->ginfo.language == sym2->ginfo.language
- && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
- && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
+ return (memcmp (&sym1->value, &sym2->value,
+ sizeof (sym1->value)) == 0
+ && sym1->language == sym2->language
+ && sym1->domain == sym2->domain
+ && sym1->aclass == sym2->aclass
/* Note that psymbol names are interned via
symbol_set_names, so there's no need to compare the
contents of the name here. */
- && sym1->ginfo.name == sym2->ginfo.name);
+ && sym1->name == sym2->name);
}
/* Initialize a partial symbol bcache. */
add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
domain_enum domain,
enum address_class theclass,
+ short section,
CORE_ADDR coreaddr,
enum language language, struct objfile *objfile,
int *added)
{
struct partial_symbol psymbol;
- /* We must ensure that the entire struct has been zeroed before
- assigning to it, because an assignment may not touch some of the
- holes. */
- memset (&psymbol, 0, sizeof (psymbol));
-
- SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
- SYMBOL_SECTION (&psymbol) = -1;
- SYMBOL_SET_LANGUAGE (&psymbol, language, &objfile->objfile_obstack);
- PSYMBOL_DOMAIN (&psymbol) = domain;
- PSYMBOL_CLASS (&psymbol) = theclass;
+ psymbol.set_unrelocated_address (coreaddr);
+ psymbol.section = section;
+ psymbol.domain = domain;
+ psymbol.aclass = theclass;
- SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
+ memset (&psymbol.language_specific, 0, sizeof (psymbol.language_specific));
+ psymbol.ada_mangled = 0;
+ symbol_set_language (&psymbol, language, &objfile->objfile_obstack);
+ symbol_set_names (&psymbol, name, namelength, copy_name, objfile);
/* Stash the partial symbol away in the cache. */
return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added);
add_psymbol_to_list (const char *name, int namelength, int copy_name,
domain_enum domain,
enum address_class theclass,
+ short section,
std::vector<partial_symbol *> *list,
CORE_ADDR coreaddr,
enum language language, struct objfile *objfile)
/* Stash the partial symbol away in the cache. */
psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass,
- coreaddr, language, objfile, &added);
+ section, coreaddr, language, objfile, &added);
/* Do not duplicate global partial symbols. */
if (list == &objfile->global_psymbols
objfile->free_psymtabs = psymtab->next;
}
else
- psymtab = (struct partial_symtab *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct partial_symtab));
+ psymtab = XOBNEW (&objfile->objfile_obstack, partial_symtab);
memset (psymtab, 0, sizeof (struct partial_symtab));
psymtab->filename
psymtab->fullname
? psymtab->fullname : "(null)");
printf_filtered (" text addresses ");
- fputs_filtered (paddress (gdbarch, psymtab->textlow),
+ fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)),
gdb_stdout);
printf_filtered (" -- ");
- fputs_filtered (paddress (gdbarch, psymtab->texthigh),
+ fputs_filtered (paddress (gdbarch, psymtab->text_high (objfile)),
gdb_stdout);
printf_filtered ("\n");
printf_filtered (" psymtabs_addrmap_supported %s\n",
cust = ps->compunit_symtab;
/* First do some checks that don't require the associated symtab. */
- if (ps->texthigh < ps->textlow)
+ if (ps->text_high (objfile) < ps->text_low (objfile))
{
printf_filtered ("Psymtab ");
puts_filtered (ps->filename);
printf_filtered (" covers bad range ");
- fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
+ fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
+ gdb_stdout);
printf_filtered (" - ");
- fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
+ fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
+ gdb_stdout);
printf_filtered ("\n");
continue;
}
length = ps->n_static_syms;
while (length--)
{
- sym = block_lookup_symbol (b, SYMBOL_SEARCH_NAME (*psym),
+ sym = block_lookup_symbol (b, symbol_search_name (*psym),
symbol_name_match_type::SEARCH_NAME,
- SYMBOL_DOMAIN (*psym));
+ (*psym)->domain);
if (!sym)
{
printf_filtered ("Static symbol `");
- puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
+ puts_filtered ((*psym)->name);
printf_filtered ("' only found in ");
puts_filtered (ps->filename);
printf_filtered (" psymtab\n");
length = ps->n_global_syms;
while (length--)
{
- sym = block_lookup_symbol (b, SYMBOL_SEARCH_NAME (*psym),
+ sym = block_lookup_symbol (b, symbol_search_name (*psym),
symbol_name_match_type::SEARCH_NAME,
- SYMBOL_DOMAIN (*psym));
+ (*psym)->domain);
if (!sym)
{
printf_filtered ("Global symbol `");
- puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
+ puts_filtered ((*psym)->name);
printf_filtered ("' only found in ");
puts_filtered (ps->filename);
printf_filtered (" psymtab\n");
}
psym++;
}
- if (ps->texthigh != 0
- && (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b)))
+ if (ps->raw_text_high () != 0
+ && (ps->text_low (objfile) < BLOCK_START (b)
+ || ps->text_high (objfile) > BLOCK_END (b)))
{
printf_filtered ("Psymtab ");
puts_filtered (ps->filename);
printf_filtered (" covers ");
- fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
+ fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
+ gdb_stdout);
printf_filtered (" - ");
- fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
+ fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
+ gdb_stdout);
printf_filtered (" but symtab covers only ");
fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
printf_filtered (" - ");
projects / deliverable / binutils-gdb.git / blobdiff