X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsymtab.c;h=83ff9387556cf7a0d47246d8bdb421bc096f47c5;hb=17a912b6825ef7feaad6d9b4f5419f045fe3c8d0;hp=6b51df1fa662caadd11afd58e6a388fc08dc4a7c;hpb=b64296285dff79d58ce7b9dad578d5f3438a6cd4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/symtab.c b/gdb/symtab.c index 6b51df1fa6..83ff938755 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -1,7 +1,7 @@ /* Symbol table lookup for the GNU debugger, GDB. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, - 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 + Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, + 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007 Free Software Foundation, Inc. This file is part of GDB. @@ -18,8 +18,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" #include "symtab.h" @@ -41,6 +41,7 @@ #include "source.h" #include "filenames.h" /* for FILENAME_CMP */ #include "objc-lang.h" +#include "ada-lang.h" #include "hashtab.h" @@ -54,6 +55,8 @@ #include "gdb_stat.h" #include #include "cp-abi.h" +#include "observer.h" +#include "gdb_assert.h" /* Prototypes for local functions */ @@ -69,7 +72,7 @@ static void variables_info (char *, int); static void sources_info (char *, int); -static void output_source_filename (char *, int *); +static void output_source_filename (const char *, int *); static int find_line_common (struct linetable *, int, int *); @@ -81,6 +84,7 @@ static struct symbol *lookup_symbol_aux (const char *name, const char *linkage_name, const struct block *block, const domain_enum domain, + enum language language, int *is_a_field_of_this, struct symtab **symtab); @@ -114,12 +118,6 @@ struct symbol *lookup_symbol_aux_minsyms (const char *name, struct symtab **symtab); #endif -static struct symbol *find_active_alias (struct symbol *sym, CORE_ADDR addr); - -/* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c */ -/* Signals the presence of objects compiled by HP compilers */ -int hp_som_som_object_present = 0; - static void fixup_section (struct general_symbol_info *, struct objfile *); static int file_matches (char *, char **, int); @@ -151,9 +149,9 @@ const struct block *block_found; struct symtab * lookup_symtab (const char *name) { - register struct symtab *s; - register struct partial_symtab *ps; - register struct objfile *objfile; + struct symtab *s; + struct partial_symtab *ps; + struct objfile *objfile; char *real_path = NULL; char *full_path = NULL; @@ -183,21 +181,25 @@ got_symtab: if (full_path != NULL) { - const char *fp = symtab_to_filename (s); - if (FILENAME_CMP (full_path, fp) == 0) - { - return s; - } + const char *fp = symtab_to_fullname (s); + if (fp != NULL && FILENAME_CMP (full_path, fp) == 0) + { + return s; + } } if (real_path != NULL) { - char *rp = gdb_realpath (symtab_to_filename (s)); - make_cleanup (xfree, rp); - if (FILENAME_CMP (real_path, rp) == 0) - { - return s; - } + char *fullname = symtab_to_fullname (s); + if (fullname != NULL) + { + char *rp = gdb_realpath (fullname); + make_cleanup (xfree, rp); + if (FILENAME_CMP (real_path, rp) == 0) + { + return s; + } + } } } @@ -218,7 +220,7 @@ got_symtab: return (NULL); if (ps->readin) - error ("Internal: readin %s pst for `%s' found when no symtab found.", + error (_("Internal: readin %s pst for `%s' found when no symtab found."), ps->filename, name); s = PSYMTAB_TO_SYMTAB (ps); @@ -244,8 +246,8 @@ got_symtab: struct partial_symtab * lookup_partial_symtab (const char *name) { - register struct partial_symtab *pst; - register struct objfile *objfile; + struct partial_symtab *pst; + struct objfile *objfile; char *full_path = NULL; char *real_path = NULL; @@ -270,8 +272,7 @@ lookup_partial_symtab (const char *name) this symtab and use its absolute path. */ if (full_path != NULL) { - if (pst->fullname == NULL) - source_full_path_of (pst->filename, &pst->fullname); + psymtab_to_fullname (pst); if (pst->fullname != NULL && FILENAME_CMP (full_path, pst->fullname) == 0) { @@ -282,8 +283,7 @@ lookup_partial_symtab (const char *name) if (real_path != NULL) { char *rp = NULL; - if (pst->fullname == NULL) - source_full_path_of (pst->filename, &pst->fullname); + psymtab_to_fullname (pst); if (pst->fullname != NULL) { rp = gdb_realpath (pst->fullname); @@ -345,7 +345,7 @@ gdb_mangle_name (struct type *type, int method_id, int signature_id) is_full_physname_constructor = is_constructor_name (physname); is_constructor = - is_full_physname_constructor || (newname && STREQ (field_name, newname)); + is_full_physname_constructor || (newname && strcmp (field_name, newname) == 0); if (!is_destructor) is_destructor = (strncmp (physname, "__dt", 4) == 0); @@ -429,9 +429,9 @@ create_demangled_names_hash (struct objfile *objfile) Choosing a much larger table size wastes memory, and saves only about 1% in symbol reading. */ - objfile->demangled_names_hash = htab_create_alloc_ex + objfile->demangled_names_hash = htab_create_alloc (256, htab_hash_string, (int (*) (const void *, const void *)) streq, - NULL, objfile->md, xmcalloc, xmfree); + NULL, xcalloc, xfree); } /* Try to determine the demangled name for a symbol, based on the @@ -487,7 +487,7 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol, /* Set both the mangled and demangled (if any) names for GSYMBOL based on LINKAGE_NAME and LEN. The hash table corresponding to OBJFILE - is used, and the memory comes from that objfile's symbol_obstack. + is used, and the memory comes from that objfile's objfile_obstack. LINKAGE_NAME is copied, so the pointer can be discarded after calling this function. */ @@ -574,7 +574,7 @@ symbol_set_names (struct general_symbol_info *gsymbol, /* If there is a demangled name, place it right after the mangled name. Otherwise, just place a second zero byte after the end of the mangled name. */ - *slot = obstack_alloc (&objfile->symbol_obstack, + *slot = obstack_alloc (&objfile->objfile_obstack, lookup_len + demangled_len + 2); memcpy (*slot, lookup_name, lookup_len + 1); if (demangled_name != NULL) @@ -634,17 +634,24 @@ symbol_init_demangled_name (struct general_symbol_info *gsymbol, char * symbol_natural_name (const struct general_symbol_info *gsymbol) { - if ((gsymbol->language == language_cplus - || gsymbol->language == language_java - || gsymbol->language == language_objc) - && (gsymbol->language_specific.cplus_specific.demangled_name != NULL)) - { - return gsymbol->language_specific.cplus_specific.demangled_name; - } - else + switch (gsymbol->language) { - return gsymbol->name; + case language_cplus: + case language_java: + case language_objc: + if (gsymbol->language_specific.cplus_specific.demangled_name != NULL) + return gsymbol->language_specific.cplus_specific.demangled_name; + break; + case language_ada: + if (gsymbol->language_specific.cplus_specific.demangled_name != NULL) + return gsymbol->language_specific.cplus_specific.demangled_name; + else + return ada_decode_symbol (gsymbol); + break; + default: + break; } + return gsymbol->name; } /* Return the demangled name for a symbol based on the language for @@ -652,13 +659,37 @@ symbol_natural_name (const struct general_symbol_info *gsymbol) char * symbol_demangled_name (struct general_symbol_info *gsymbol) { - if (gsymbol->language == language_cplus - || gsymbol->language == language_java - || gsymbol->language == language_objc) - return gsymbol->language_specific.cplus_specific.demangled_name; + switch (gsymbol->language) + { + case language_cplus: + case language_java: + case language_objc: + if (gsymbol->language_specific.cplus_specific.demangled_name != NULL) + return gsymbol->language_specific.cplus_specific.demangled_name; + break; + case language_ada: + if (gsymbol->language_specific.cplus_specific.demangled_name != NULL) + return gsymbol->language_specific.cplus_specific.demangled_name; + else + return ada_decode_symbol (gsymbol); + break; + default: + break; + } + return NULL; +} - else - return NULL; +/* Return the search name of a symbol---generally the demangled or + linkage name of the symbol, depending on how it will be searched for. + If there is no distinct demangled name, then returns the same value + (same pointer) as SYMBOL_LINKAGE_NAME. */ +char * +symbol_search_name (const struct general_symbol_info *gsymbol) +{ + if (gsymbol->language == language_ada) + return gsymbol->name; + else + return symbol_natural_name (gsymbol); } /* Initialize the structure fields to zero values. */ @@ -673,14 +704,77 @@ init_sal (struct symtab_and_line *sal) } +/* Return 1 if the two sections are the same, or if they could + plausibly be copies of each other, one in an original object + file and another in a separated debug file. */ + +int +matching_bfd_sections (asection *first, asection *second) +{ + struct objfile *obj; + + /* If they're the same section, then they match. */ + if (first == second) + return 1; + + /* If either is NULL, give up. */ + if (first == NULL || second == NULL) + return 0; + + /* This doesn't apply to absolute symbols. */ + if (first->owner == NULL || second->owner == NULL) + return 0; + + /* If they're in the same object file, they must be different sections. */ + if (first->owner == second->owner) + return 0; + + /* Check whether the two sections are potentially corresponding. They must + have the same size, address, and name. We can't compare section indexes, + which would be more reliable, because some sections may have been + stripped. */ + if (bfd_get_section_size (first) != bfd_get_section_size (second)) + return 0; + + /* In-memory addresses may start at a different offset, relativize them. */ + if (bfd_get_section_vma (first->owner, first) + - bfd_get_start_address (first->owner) + != bfd_get_section_vma (second->owner, second) + - bfd_get_start_address (second->owner)) + return 0; + + if (bfd_get_section_name (first->owner, first) == NULL + || bfd_get_section_name (second->owner, second) == NULL + || strcmp (bfd_get_section_name (first->owner, first), + bfd_get_section_name (second->owner, second)) != 0) + return 0; + + /* Otherwise check that they are in corresponding objfiles. */ + + ALL_OBJFILES (obj) + if (obj->obfd == first->owner) + break; + gdb_assert (obj != NULL); + + if (obj->separate_debug_objfile != NULL + && obj->separate_debug_objfile->obfd == second->owner) + return 1; + if (obj->separate_debug_objfile_backlink != NULL + && obj->separate_debug_objfile_backlink->obfd == second->owner) + return 1; -/* Find which partial symtab on contains PC and SECTION. Return 0 if none. */ + return 0; +} +/* Find which partial symtab contains PC and SECTION. Return 0 if + none. We return the psymtab that contains a symbol whose address + exactly matches PC, or, if we cannot find an exact match, the + psymtab that contains a symbol whose address is closest to PC. */ struct partial_symtab * find_pc_sect_psymtab (CORE_ADDR pc, asection *section) { - register struct partial_symtab *pst; - register struct objfile *objfile; + struct partial_symtab *pst; + struct objfile *objfile; struct minimal_symbol *msymbol; /* If we know that this is not a text address, return failure. This is @@ -700,6 +794,8 @@ find_pc_sect_psymtab (CORE_ADDR pc, asection *section) if (pc >= pst->textlow && pc < pst->texthigh) { struct partial_symtab *tpst; + struct partial_symtab *best_pst = pst; + CORE_ADDR best_addr = pst->textlow; /* An objfile that has its functions reordered might have many partial symbol tables containing the PC, but @@ -712,20 +808,57 @@ find_pc_sect_psymtab (CORE_ADDR pc, asection *section) if (msymbol == NULL) return (pst); + /* The code range of partial symtabs sometimes overlap, so, in + the loop below, we need to check all partial symtabs and + find the one that fits better for the given PC address. We + select the partial symtab that contains a symbol whose + address is closest to the PC address. By closest we mean + that find_pc_sect_symbol returns the symbol with address + 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) { struct partial_symbol *p; + CORE_ADDR this_addr; + /* NOTE: This assumes that every psymbol has a + corresponding msymbol, which is not necessarily + true; the debug info might be much richer than the + object's symbol table. */ p = find_pc_sect_psymbol (tpst, pc, section); if (p != NULL && SYMBOL_VALUE_ADDRESS (p) == SYMBOL_VALUE_ADDRESS (msymbol)) return (tpst); + + /* Also accept the textlow value of a psymtab as a + "symbol", to provide some support for partial + 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); + else + this_addr = tpst->textlow; + + /* Check whether it is closer than our current + BEST_ADDR. Since this symbol address is + necessarily lower or equal to PC, the symbol closer + to PC is the symbol which address is the highest. + This way we return the psymtab which contains such + best match symbol. This can help in cases where the + symbol information/debuginfo is not complete, like + for instance on IRIX6 with gcc, where no debug info + is emitted for statics. (See also the nodebug.exp + testcase.) */ + if (this_addr > best_addr) + { + best_addr = this_addr; + best_pst = tpst; + } } } - return (pst); + return (best_pst); } } return (NULL); @@ -777,7 +910,7 @@ find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc, if (section) /* match on a specific section */ { fixup_psymbol_section (p, psymtab->objfile); - if (SYMBOL_BFD_SECTION (p) != section) + if (!matching_bfd_sections (SYMBOL_BFD_SECTION (p), section)) continue; } best_pc = SYMBOL_VALUE_ADDRESS (p); @@ -801,7 +934,7 @@ find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc, if (section) /* match on a specific section */ { fixup_psymbol_section (p, psymtab->objfile); - if (SYMBOL_BFD_SECTION (p) != section) + if (!matching_bfd_sections (SYMBOL_BFD_SECTION (p), section)) continue; } best_pc = SYMBOL_VALUE_ADDRESS (p); @@ -835,6 +968,62 @@ fixup_section (struct general_symbol_info *ginfo, struct objfile *objfile) ginfo->bfd_section = SYMBOL_BFD_SECTION (msym); ginfo->section = SYMBOL_SECTION (msym); } + else if (objfile) + { + /* Static, function-local variables do appear in the linker + (minimal) symbols, but are frequently given names that won't + be found via lookup_minimal_symbol(). E.g., it has been + observed in frv-uclinux (ELF) executables that a static, + function-local variable named "foo" might appear in the + linker symbols as "foo.6" or "foo.3". Thus, there is no + point in attempting to extend the lookup-by-name mechanism to + handle this case due to the fact that there can be multiple + names. + + 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. + + The address of the symbol whose section we're fixing up HAS + NOT BEEN adjusted (relocated) yet. It can't have been since + the section isn't yet known and knowing the section is + necessary in order to add the correct relocation value. In + other words, we wouldn't even be in this function (attempting + to compute the section) if it were already known. + + Note that it is possible to search the minimal symbols + (subtracting the relocation value if necessary) to find the + matching minimal symbol, but this is overkill and much less + efficient. It is not necessary to find the matching minimal + symbol, only its section. + + Note that this technique (of doing a section table search) + can fail when unrelocated section addresses overlap. For + this reason, we still attempt a lookup by name prior to doing + a search of the section table. */ + + CORE_ADDR addr; + struct obj_section *s; + + addr = ginfo->value.address; + + ALL_OBJFILE_OSECTIONS (objfile, s) + { + int idx = s->the_bfd_section->index; + CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx); + + if (s->addr - offset <= addr && addr < s->endaddr - offset) + { + ginfo->bfd_section = s->the_bfd_section; + ginfo->section = idx; + return; + } + } + } } struct symbol * @@ -887,9 +1076,10 @@ fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile) code). */ struct symbol * -lookup_symbol (const char *name, const struct block *block, - const domain_enum domain, int *is_a_field_of_this, - struct symtab **symtab) +lookup_symbol_in_language (const char *name, const struct block *block, + const domain_enum domain, enum language lang, + int *is_a_field_of_this, + struct symtab **symtab) { char *demangled_name = NULL; const char *modified_name = NULL; @@ -899,9 +1089,9 @@ lookup_symbol (const char *name, const struct block *block, modified_name = name; - /* If we are using C++ language, demangle the name before doing a lookup, so + /* If we are using C++ or Java, demangle the name before doing a lookup, so we can always binary search. */ - if (current_language->la_language == language_cplus) + if (lang == language_cplus) { demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS); if (demangled_name) @@ -911,6 +1101,17 @@ lookup_symbol (const char *name, const struct block *block, needtofreename = 1; } } + else if (lang == language_java) + { + demangled_name = cplus_demangle (name, + DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA); + if (demangled_name) + { + mangled_name = name; + modified_name = demangled_name; + needtofreename = 1; + } + } if (case_sensitivity == case_sensitive_off) { @@ -926,14 +1127,32 @@ lookup_symbol (const char *name, const struct block *block, } returnval = lookup_symbol_aux (modified_name, mangled_name, block, - domain, is_a_field_of_this, symtab); + domain, lang, + is_a_field_of_this, symtab); if (needtofreename) xfree (demangled_name); + /* Override the returned symtab with the symbol's specific one. */ + if (returnval != NULL && symtab != NULL) + *symtab = SYMBOL_SYMTAB (returnval); + return returnval; } -/* Behave like lookup_symbol_aux except that NAME is the natural name +/* Behave like lookup_symbol_in_language, but performed with the + current language. */ + +struct symbol * +lookup_symbol (const char *name, const struct block *block, + domain_enum domain, int *is_a_field_of_this, + struct symtab **symtab) +{ + return lookup_symbol_in_language (name, block, domain, + current_language->la_language, + is_a_field_of_this, symtab); +} + +/* Behave like lookup_symbol except that NAME is the natural name of the symbol that we're looking for and, if LINKAGE_NAME is non-NULL, ensure that the symbol's linkage name matches as well. */ @@ -941,9 +1160,19 @@ lookup_symbol (const char *name, const struct block *block, static struct symbol * lookup_symbol_aux (const char *name, const char *linkage_name, const struct block *block, const domain_enum domain, + enum language language, int *is_a_field_of_this, struct symtab **symtab) { struct symbol *sym; + const struct language_defn *langdef; + + /* Make sure we do something sensible with is_a_field_of_this, since + the callers that set this parameter to some non-null value will + certainly use it later and expect it to be either 0 or 1. + If we don't set it, the contents of is_a_field_of_this are + undefined. */ + if (is_a_field_of_this != NULL) + *is_a_field_of_this = 0; /* Search specified block and its superiors. Don't search STATIC_BLOCK or GLOBAL_BLOCK. */ @@ -953,15 +1182,16 @@ lookup_symbol_aux (const char *name, const char *linkage_name, if (sym != NULL) return sym; - /* If requested to do so by the caller and if appropriate for the - current language, check to see if NAME is a field of `this'. */ + /* If requested to do so by the caller and if appropriate for LANGUAGE, + check to see if NAME is a field of `this'. */ + + langdef = language_def (language); - if (current_language->la_value_of_this != NULL + if (langdef->la_value_of_this != NULL && is_a_field_of_this != NULL) { - struct value *v = current_language->la_value_of_this (0); + struct value *v = langdef->la_value_of_this (0); - *is_a_field_of_this = 0; if (v && check_field (v, name)) { *is_a_field_of_this = 1; @@ -971,12 +1201,11 @@ lookup_symbol_aux (const char *name, const char *linkage_name, } } - /* Now do whatever is appropriate for the current language to look + /* Now do whatever is appropriate for LANGUAGE to look up static and global variables. */ - sym = current_language->la_lookup_symbol_nonlocal (name, linkage_name, - block, domain, - symtab); + sym = langdef->la_lookup_symbol_nonlocal (name, linkage_name, + block, domain, symtab); if (sym != NULL) return sym; @@ -1055,7 +1284,7 @@ lookup_symbol_aux_block (const char *name, const char *linkage_name, { /* Search the list of symtabs for one which contains the address of the start of this block. */ - ALL_SYMTABS (objfile, s) + ALL_PRIMARY_SYMTABS (objfile, s) { bv = BLOCKVECTOR (s); b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); @@ -1090,7 +1319,7 @@ lookup_symbol_aux_symtabs (int block_index, const struct block *block; struct symtab *s; - ALL_SYMTABS (objfile, s) + ALL_PRIMARY_SYMTABS (objfile, s) { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, block_index); @@ -1154,7 +1383,7 @@ lookup_symbol_aux_psymtabs (int block_index, const char *name, STATIC_BLOCK : GLOBAL_BLOCK); sym = lookup_block_symbol (block, name, linkage_name, domain); if (!sym) - error ("Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n%s may be an inlined function, or may be a template function\n(if a template, try specifying an instantiation: %s).", + error (_("Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n%s may be an inlined function, or may be a template function\n(if a template, try specifying an instantiation: %s)."), block_index == GLOBAL_BLOCK ? "global" : "static", name, ps->filename, name, name); } @@ -1227,7 +1456,7 @@ lookup_symbol_aux_minsyms (const char *name, bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - /* This call used to pass `DEPRECATED_SYMBOL_NAME (msymbol)' as the + /* This call used to pass `SYMBOL_LINKAGE_NAME (msymbol)' as the `name' argument to lookup_block_symbol. But the name of a minimal symbol is always mangled, so that seems to be clearly the wrong thing to pass as the @@ -1421,13 +1650,13 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, { center = bottom + (top - bottom) / 2; if (!(center < top)) - internal_error (__FILE__, __LINE__, "failed internal consistency check"); + internal_error (__FILE__, __LINE__, _("failed internal consistency check")); if (!do_linear_search && (SYMBOL_LANGUAGE (*center) == language_java)) { do_linear_search = 1; } - if (strcmp_iw_ordered (SYMBOL_NATURAL_NAME (*center), name) >= 0) + if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center), name) >= 0) { top = center; } @@ -1437,12 +1666,12 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, } } if (!(top == bottom)) - internal_error (__FILE__, __LINE__, "failed internal consistency check"); + internal_error (__FILE__, __LINE__, _("failed internal consistency check")); while (top <= real_top && (linkage_name != NULL ? strcmp (SYMBOL_LINKAGE_NAME (*top), linkage_name) == 0 - : SYMBOL_MATCHES_NATURAL_NAME (*top,name))) + : SYMBOL_MATCHES_SEARCH_NAME (*top,name))) { if (SYMBOL_DOMAIN (*top) == domain) { @@ -1463,7 +1692,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, { if (linkage_name != NULL ? strcmp (SYMBOL_LINKAGE_NAME (*psym), linkage_name) == 0 - : SYMBOL_MATCHES_NATURAL_NAME (*psym, name)) + : SYMBOL_MATCHES_SEARCH_NAME (*psym, name)) { return (*psym); } @@ -1475,29 +1704,37 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, } /* Look up a type named NAME in the struct_domain. The type returned - must not be opaque -- i.e., must have at least one field defined + must not be opaque -- i.e., must have at least one field + defined. */ - This code was modelled on lookup_symbol -- the parts not relevant to looking - up types were just left out. In particular it's assumed here that types - are available in struct_domain and only at file-static or global blocks. */ +struct type * +lookup_transparent_type (const char *name) +{ + return current_language->la_lookup_transparent_type (name); +} +/* The standard implementation of lookup_transparent_type. This code + was modeled on lookup_symbol -- the parts not relevant to looking + up types were just left out. In particular it's assumed here that + types are available in struct_domain and only at file-static or + global blocks. */ struct type * -lookup_transparent_type (const char *name) +basic_lookup_transparent_type (const char *name) { - register struct symbol *sym; - register struct symtab *s = NULL; - register struct partial_symtab *ps; + struct symbol *sym; + struct symtab *s = NULL; + struct partial_symtab *ps; struct blockvector *bv; - register struct objfile *objfile; - register struct block *block; + struct objfile *objfile; + struct block *block; /* Now search all the global symbols. Do the symtab's first, then check the psymtab's. If a psymtab indicates the existence of the desired name as a global, then do psymtab-to-symtab conversion on the fly and return the found symbol. */ - ALL_SYMTABS (objfile, s) + ALL_PRIMARY_SYMTABS (objfile, s) { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); @@ -1527,9 +1764,9 @@ lookup_transparent_type (const char *name) block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); if (!sym) - error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\ + error (_("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\ %s may be an inlined function, or may be a template function\n\ -(if a template, try specifying an instantiation: %s).", +(if a template, try specifying an instantiation: %s)."), name, ps->filename, name, name); } if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) @@ -1545,7 +1782,7 @@ lookup_transparent_type (const char *name) conversion on the fly and return the found symbol. */ - ALL_SYMTABS (objfile, s) + ALL_PRIMARY_SYMTABS (objfile, s) { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); @@ -1574,9 +1811,9 @@ lookup_transparent_type (const char *name) block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); if (!sym) - error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\ + error (_("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\ %s may be an inlined function, or may be a template function\n\ -(if a template, try specifying an instantiation: %s).", +(if a template, try specifying an instantiation: %s)."), name, ps->filename, name, name); } if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) @@ -1594,8 +1831,8 @@ lookup_transparent_type (const char *name) struct partial_symtab * find_main_psymtab (void) { - register struct partial_symtab *pst; - register struct objfile *objfile; + struct partial_symtab *pst; + struct objfile *objfile; ALL_PSYMTABS (objfile, pst) { @@ -1623,7 +1860,7 @@ find_main_psymtab (void) */ struct symbol * -lookup_block_symbol (register const struct block *block, const char *name, +lookup_block_symbol (const struct block *block, const char *name, const char *linkage_name, const domain_enum domain) { @@ -1661,29 +1898,6 @@ lookup_block_symbol (register const struct block *block, const char *name, && (linkage_name != NULL ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1)) { - /* If SYM has aliases, then use any alias that is active - at the current PC. If no alias is active at the current - PC, then use the main symbol. - - ?!? Is checking the current pc correct? Is this routine - ever called to look up a symbol from another context? - - FIXME: No, it's not correct. If someone sets a - conditional breakpoint at an address, then the - breakpoint's `struct expression' should refer to the - `struct symbol' appropriate for the breakpoint's - address, which may not be the PC. - - Even if it were never called from another context, - it's totally bizarre for lookup_symbol's behavior to - depend on the value of the inferior's current PC. We - should pass in the appropriate PC as well as the - block. The interface to lookup_symbol should change - to require the caller to provide a PC. */ - - if (SYMBOL_ALIASES (sym)) - sym = find_active_alias (sym, read_pc ()); - sym_found = sym; if (SYMBOL_CLASS (sym) != LOC_ARG && SYMBOL_CLASS (sym) != LOC_LOCAL_ARG && @@ -1701,50 +1915,18 @@ lookup_block_symbol (register const struct block *block, const char *name, } } -/* Given a main symbol SYM and ADDR, search through the alias - list to determine if an alias is active at ADDR and return - the active alias. - - If no alias is active, then return SYM. */ - -static struct symbol * -find_active_alias (struct symbol *sym, CORE_ADDR addr) -{ - struct range_list *r; - struct alias_list *aliases; - - /* If we have aliases, check them first. */ - aliases = SYMBOL_ALIASES (sym); - - while (aliases) - { - if (!SYMBOL_RANGES (aliases->sym)) - return aliases->sym; - for (r = SYMBOL_RANGES (aliases->sym); r; r = r->next) - { - if (r->start <= addr && r->end > addr) - return aliases->sym; - } - aliases = aliases->next; - } - - /* Nothing found, return the main symbol. */ - return sym; -} - - /* Find the symtab associated with PC and SECTION. Look through the psymtabs and read in another symtab if necessary. */ struct symtab * find_pc_sect_symtab (CORE_ADDR pc, asection *section) { - register struct block *b; + struct block *b; struct blockvector *bv; - register struct symtab *s = NULL; - register struct symtab *best_s = NULL; - register struct partial_symtab *ps; - register struct objfile *objfile; + struct symtab *s = NULL; + struct symtab *best_s = NULL; + struct partial_symtab *ps; + struct objfile *objfile; CORE_ADDR distance = 0; struct minimal_symbol *msymbol; @@ -1777,7 +1959,7 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *section) It also happens for objfiles that have their functions reordered. For these, the symtab we are looking for is not necessarily read in. */ - ALL_SYMTABS (objfile, s) + ALL_PRIMARY_SYMTABS (objfile, s) { bv = BLOCKVECTOR (s); b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); @@ -1807,7 +1989,7 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *section) ALL_BLOCK_SYMBOLS (b, iter, sym) { fixup_symbol_section (sym, objfile); - if (section == SYMBOL_BFD_SECTION (sym)) + if (matching_bfd_sections (SYMBOL_BFD_SECTION (sym), section)) break; } if (sym == NULL) @@ -1829,8 +2011,8 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *section) /* Might want to error() here (in case symtab is corrupt and will cause a core dump), but maybe we can successfully continue, so let's not. */ - warning ("\ -(Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n", + warning (_("\ +(Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n"), paddr_nz (pc)); s = PSYMTAB_TO_SYMTAB (ps); } @@ -1865,13 +2047,13 @@ find_pc_symtab (CORE_ADDR pc) /* If it's worth the effort, we could be using a binary search. */ struct symtab_and_line -find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent) +find_pc_sect_line (CORE_ADDR pc, struct bfd_section *section, int notcurrent) { struct symtab *s; - register struct linetable *l; - register int len; - register int i; - register struct linetable_entry *item; + struct linetable *l; + int len; + int i; + struct linetable_entry *item; struct symtab_and_line val; struct blockvector *bv; struct minimal_symbol *msymbol; @@ -1961,7 +2143,8 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent) if (msymbol != NULL) if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline) { - mfunsym = lookup_minimal_symbol_text (DEPRECATED_SYMBOL_NAME (msymbol), NULL, NULL); + mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol), + NULL); if (mfunsym == NULL) /* I eliminated this warning since it is coming out * in the following situation: @@ -1972,12 +2155,12 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent) * so of course we can't find the real func/line info, * but the "break" still works, and the warning is annoying. * So I commented out the warning. RT */ - /* warning ("In stub for %s; unable to find real function/line info", DEPRECATED_SYMBOL_NAME (msymbol)) */ ; + /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ; /* fall through */ else if (SYMBOL_VALUE (mfunsym) == SYMBOL_VALUE (msymbol)) /* Avoid infinite recursion */ /* See above comment about why warning is commented out */ - /* warning ("In stub for %s; unable to find real function/line info", DEPRECATED_SYMBOL_NAME (msymbol)) */ ; + /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ; /* fall through */ else return find_pc_line (SYMBOL_VALUE (mfunsym), 0); @@ -2067,23 +2250,11 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent) if (!best_symtab) { - if (!alt_symtab) - { /* If we didn't find any line # info, just - return zeros. */ - val.pc = pc; - } - else - { - val.symtab = alt_symtab; - val.line = alt->line - 1; - - /* Don't return line 0, that means that we didn't find the line. */ - if (val.line == 0) - ++val.line; - - val.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); - val.end = alt->pc; - } + /* If we didn't find any line number info, just return zeros. + We used to return alt->line - 1 here, but that could be + anywhere; if we don't have line number info for this PC, + don't make some up. */ + val.pc = pc; } else if (best->line == 0) { @@ -2174,7 +2345,7 @@ find_line_symtab (struct symtab *symtab, int line, int *index, int *exact_match) struct linetable *l; int ind; - if (!STREQ (symtab->filename, s->filename)) + if (strcmp (symtab->filename, s->filename) != 0) continue; l = LINETABLE (s); ind = find_line_common (l, line, &exact); @@ -2280,11 +2451,11 @@ find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr, Set *EXACT_MATCH nonzero if the value returned is an exact match. */ static int -find_line_common (register struct linetable *l, register int lineno, +find_line_common (struct linetable *l, int lineno, int *exact_match) { - register int i; - register int len; + int i; + int len; /* BEST is the smallest linenumber > LINENO so far seen, or 0 if none has been seen so far. @@ -2301,7 +2472,7 @@ find_line_common (register struct linetable *l, register int lineno, len = l->nitems; for (i = 0; i < len; i++) { - register struct linetable_entry *item = &(l->item[i]); + struct linetable_entry *item = &(l->item[i]); if (item->line == lineno) { @@ -2350,24 +2521,21 @@ find_function_start_sal (struct symbol *sym, int funfirstline) { /* skip "first line" of function (which is actually its prologue) */ asection *section = SYMBOL_BFD_SECTION (sym); /* If function is in an unmapped overlay, use its unmapped LMA - address, so that SKIP_PROLOGUE has something unique to work on */ + address, so that gdbarch_skip_prologue has something unique to work + on */ if (section_is_overlay (section) && !section_is_mapped (section)) pc = overlay_unmapped_address (pc, section); - pc += FUNCTION_START_OFFSET; - pc = SKIP_PROLOGUE (pc); + pc += DEPRECATED_FUNCTION_START_OFFSET; + pc = gdbarch_skip_prologue (current_gdbarch, pc); /* For overlays, map pc back into its mapped VMA range */ pc = overlay_mapped_address (pc, section); } sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0); -#ifdef PROLOGUE_FIRSTLINE_OVERLAP - /* Convex: no need to suppress code on first line, if any */ - sal.pc = pc; -#else - /* Check if SKIP_PROLOGUE left us in mid-line, and the next + /* Check if gdbarch_skip_prologue left us in mid-line, and the next line is still part of the same function. */ if (sal.pc != pc && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= sal.end @@ -2379,7 +2547,6 @@ find_function_start_sal (struct symbol *sym, int funfirstline) sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0); } sal.pc = pc; -#endif return sal; } @@ -2409,7 +2576,7 @@ operator_chars (char *p, char **end) if (isalpha (*p) || *p == '_' || *p == '$') { - register char *q = p + 1; + char *q = p + 1; while (isalnum (*q) || *q == '_' || *q == '$') q++; *end = q; @@ -2431,14 +2598,14 @@ operator_chars (char *p, char **end) else if (p[1] == '[') { if (p[2] == ']') - error ("mismatched quoting on brackets, try 'operator\\[\\]'"); + error (_("mismatched quoting on brackets, try 'operator\\[\\]'")); else if (p[2] == '\\' && p[3] == ']') { *end = p + 4; /* 'operator\[\]' */ return p; } else - error ("nothing is allowed between '[' and ']'"); + error (_("nothing is allowed between '[' and ']'")); } else { @@ -2494,21 +2661,21 @@ operator_chars (char *p, char **end) return p; case '(': if (p[1] != ')') - error ("`operator ()' must be specified without whitespace in `()'"); + error (_("`operator ()' must be specified without whitespace in `()'")); *end = p + 2; return p; case '?': if (p[1] != ':') - error ("`operator ?:' must be specified without whitespace in `?:'"); + error (_("`operator ?:' must be specified without whitespace in `?:'")); *end = p + 2; return p; case '[': if (p[1] != ']') - error ("`operator []' must be specified without whitespace in `[]'"); + error (_("`operator []' must be specified without whitespace in `[]'")); *end = p + 2; return p; default: - error ("`operator %s' not supported", p); + error (_("`operator %s' not supported"), p); break; } @@ -2565,7 +2732,7 @@ filename_seen (const char *file, int add, int *first) NAME is the name to print and *FIRST is nonzero if this is the first name printed. Set *FIRST to zero. */ static void -output_source_filename (char *name, int *first) +output_source_filename (const char *name, int *first) { /* Since a single source file can result in several partial symbol tables, we need to avoid printing it more than once. Note: if @@ -2599,14 +2766,14 @@ output_source_filename (char *name, int *first) static void sources_info (char *ignore, int from_tty) { - register struct symtab *s; - register struct partial_symtab *ps; - register struct objfile *objfile; + struct symtab *s; + struct partial_symtab *ps; + struct objfile *objfile; int first; if (!have_full_symbols () && !have_partial_symbols ()) { - error ("No symbol table is loaded. Use the \"file\" command."); + error (_("No symbol table is loaded. Use the \"file\" command.")); } printf_filtered ("Source files for which symbols have been read in:\n\n"); @@ -2614,7 +2781,8 @@ sources_info (char *ignore, int from_tty) first = 1; ALL_SYMTABS (objfile, s) { - output_source_filename (s->filename, &first); + const char *fullname = symtab_to_fullname (s); + output_source_filename (fullname ? fullname : s->filename, &first); } printf_filtered ("\n\n"); @@ -2625,7 +2793,8 @@ sources_info (char *ignore, int from_tty) { if (!ps->readin) { - output_source_filename (ps->filename, &first); + const char *fullname = psymtab_to_fullname (ps); + output_source_filename (fullname ? fullname : ps->filename, &first); } } printf_filtered ("\n"); @@ -2741,14 +2910,13 @@ void search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], struct symbol_search **matches) { - register struct symtab *s; - register struct partial_symtab *ps; - register struct blockvector *bv; - struct blockvector *prev_bv = 0; - register struct block *b; - register int i = 0; + struct symtab *s; + struct partial_symtab *ps; + struct blockvector *bv; + struct block *b; + int i = 0; struct dict_iterator iter; - register struct symbol *sym; + struct symbol *sym; struct partial_symbol **psym; struct objfile *objfile; struct minimal_symbol *msymbol; @@ -2776,7 +2944,7 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], struct cleanup *old_chain = NULL; if (kind < VARIABLES_DOMAIN) - error ("must search on specific domain"); + error (_("must search on specific domain")); ourtype = types[(int) (kind - VARIABLES_DOMAIN)]; ourtype2 = types2[(int) (kind - VARIABLES_DOMAIN)]; @@ -2819,7 +2987,7 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], } if (0 != (val = re_comp (regexp))) - error ("Invalid regexp (%s): %s", val, regexp); + error (_("Invalid regexp (%s): %s"), val, regexp); } /* Search through the partial symtabs *first* for all symbols @@ -2859,7 +3027,11 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], QUIT; /* If it would match (logic taken from loop below) - load the file and go on to the next one */ + load the file and go on to the next one. We check the + filename here, but that's a bit bogus: we don't know + what file it really comes from until we have full + symtabs. The symbol might be in a header file included by + this psymtab. This only affects Insight. */ if (file_matches (ps->filename, files, nfiles) && ((regexp == NULL || re_exec (SYMBOL_NATURAL_NAME (*psym)) != 0) @@ -2911,10 +3083,11 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], symbol associated to a given minimal symbol (if any). */ if (kind == FUNCTIONS_DOMAIN - || lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol), + || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), (struct block *) NULL, VAR_DOMAIN, - 0, (struct symtab **) NULL) == NULL) + 0, (struct symtab **) NULL) + == NULL) found_misc = 1; } } @@ -2922,15 +3095,9 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], } } - ALL_SYMTABS (objfile, s) + ALL_PRIMARY_SYMTABS (objfile, s) { bv = BLOCKVECTOR (s); - /* Often many files share a blockvector. - Scan each blockvector only once so that - we don't get every symbol many times. - It happens that the first symtab in the list - for any given blockvector is the main file. */ - if (bv != prev_bv) for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++) { struct symbol_search *prevtail = tail; @@ -2938,8 +3105,10 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], b = BLOCKVECTOR_BLOCK (bv, i); ALL_BLOCK_SYMBOLS (b, iter, sym) { + struct symtab *real_symtab = SYMBOL_SYMTAB (sym); QUIT; - if (file_matches (s->filename, files, nfiles) + + if (file_matches (real_symtab->filename, files, nfiles) && ((regexp == NULL || re_exec (SYMBOL_NATURAL_NAME (sym)) != 0) && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (sym) != LOC_TYPEDEF @@ -2952,7 +3121,7 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], /* match */ psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search)); psr->block = i; - psr->symtab = s; + psr->symtab = real_symtab; psr->symbol = sym; psr->msymbol = NULL; psr->next = NULL; @@ -2980,7 +3149,6 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], tail = sort_search_symbols (prevtail, nfound); } } - prev_bv = bv; } /* If there are no eyes, avoid all contact. I mean, if there are @@ -3003,7 +3171,7 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))) { /* Variables/Absolutes: Look up by name */ - if (lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol), + if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), (struct block *) NULL, VAR_DOMAIN, 0, (struct symtab **) NULL) == NULL) { @@ -3078,13 +3246,13 @@ print_msymbol_info (struct minimal_symbol *msymbol) { char *tmp; - if (TARGET_ADDR_BIT <= 32) - tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol) - & (CORE_ADDR) 0xffffffff, - "08l"); + if (gdbarch_addr_bit (current_gdbarch) <= 32) + tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol) + & (CORE_ADDR) 0xffffffff, + 8); else - tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol), - "016l"); + tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol), + 16); printf_filtered ("%s %s\n", tmp, SYMBOL_PRINT_NAME (msymbol)); } @@ -3183,12 +3351,12 @@ rbreak_command (char *regexp, int from_tty) { if (p->msymbol == NULL) { - char *string = (char *) alloca (strlen (p->symtab->filename) - + strlen (DEPRECATED_SYMBOL_NAME (p->symbol)) - + 4); + char *string = alloca (strlen (p->symtab->filename) + + strlen (SYMBOL_LINKAGE_NAME (p->symbol)) + + 4); strcpy (string, p->symtab->filename); strcat (string, ":'"); - strcat (string, DEPRECATED_SYMBOL_NAME (p->symbol)); + strcat (string, SYMBOL_LINKAGE_NAME (p->symbol)); strcat (string, "'"); break_command (string, from_tty); print_symbol_info (FUNCTIONS_DOMAIN, @@ -3199,7 +3367,7 @@ rbreak_command (char *regexp, int from_tty) } else { - break_command (DEPRECATED_SYMBOL_NAME (p->msymbol), from_tty); + break_command (SYMBOL_LINKAGE_NAME (p->msymbol), from_tty); printf_filtered (" %s;\n", SYMBOL_PRINT_NAME (p->msymbol)); } @@ -3216,17 +3384,8 @@ static int return_val_index; static char **return_val; #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \ - do { \ - if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \ - /* Put only the mangled name on the list. */ \ - /* Advantage: "b foo" completes to "b foo(int, int)" */ \ - /* Disadvantage: "b foo__i" doesn't complete. */ \ completion_list_add_name \ - (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \ - else \ - completion_list_add_name \ - (DEPRECATED_SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \ - } while (0) + (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word)) /* Test to see if the symbol specified by SYMNAME (which is already demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN @@ -3554,7 +3713,7 @@ make_symbol_completion_list (char *text, char *word) /* Go through the symtabs and check the externs and statics for symbols which match. */ - ALL_SYMTABS (objfile, s) + ALL_PRIMARY_SYMTABS (objfile, s) { QUIT; b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); @@ -3564,7 +3723,7 @@ make_symbol_completion_list (char *text, char *word) } } - ALL_SYMTABS (objfile, s) + ALL_PRIMARY_SYMTABS (objfile, s) { QUIT; b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); @@ -3586,9 +3745,9 @@ make_symbol_completion_list (char *text, char *word) char ** make_file_symbol_completion_list (char *text, char *word, char *srcfile) { - register struct symbol *sym; - register struct symtab *s; - register struct block *b; + struct symbol *sym; + struct symtab *s; + struct block *b; struct dict_iterator iter; /* The symbol we are completing on. Points in same buffer as text. */ char *sym_text; @@ -3749,9 +3908,9 @@ not_interesting_fname (const char *fname) char ** make_source_files_completion_list (char *text, char *word) { - register struct symtab *s; - register struct partial_symtab *ps; - register struct objfile *objfile; + struct symtab *s; + struct partial_symtab *ps; + struct objfile *objfile; int first = 1; int list_alloced = 1; int list_used = 0; @@ -3864,7 +4023,7 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start) - The minimal symbols and partial symbols, which can usually tell us the starting and ending addresses of a function. - If we know the function's start address, we can call the - architecture-defined SKIP_PROLOGUE function to analyze the + architecture-defined gdbarch_skip_prologue function to analyze the instruction stream and guess where the prologue ends. - Our `func_start' argument; if non-zero, this is the caller's best guess as to the function's entry point. At the time of @@ -3882,7 +4041,7 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start) if (! func_start) return 1; /* We *might* be in a prologue. */ - prologue_end = SKIP_PROLOGUE (func_start); + prologue_end = gdbarch_skip_prologue (current_gdbarch, func_start); return func_start <= pc && pc < prologue_end; } @@ -3906,7 +4065,8 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start) /* We don't have any good line number info, so use the minsym information, together with the architecture-specific prologue scanning code. */ - CORE_ADDR prologue_end = SKIP_PROLOGUE (func_addr); + CORE_ADDR prologue_end = gdbarch_skip_prologue + (current_gdbarch, func_addr); return func_addr <= pc && pc < prologue_end; } @@ -3915,6 +4075,65 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start) return func_addr <= pc && pc < sal.end; } +/* Given PC at the function's start address, attempt to find the + prologue end using SAL information. Return zero if the skip fails. + + A non-optimized prologue traditionally has one SAL for the function + and a second for the function body. A single line function has + them both pointing at the same line. + + An optimized prologue is similar but the prologue may contain + instructions (SALs) from the instruction body. Need to skip those + while not getting into the function body. + + The functions end point and an increasing SAL line are used as + indicators of the prologue's endpoint. + + This code is based on the function refine_prologue_limit (versions + found in both ia64 and ppc). */ + +CORE_ADDR +skip_prologue_using_sal (CORE_ADDR func_addr) +{ + struct symtab_and_line prologue_sal; + CORE_ADDR start_pc; + CORE_ADDR end_pc; + + /* Get an initial range for the function. */ + find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc); + start_pc += DEPRECATED_FUNCTION_START_OFFSET; + + prologue_sal = find_pc_line (start_pc, 0); + if (prologue_sal.line != 0) + { + /* If there is only one sal that covers the entire function, + then it is probably a single line function, like + "foo(){}". */ + if (prologue_sal.end >= end_pc) + return 0; + while (prologue_sal.end < end_pc) + { + struct symtab_and_line sal; + + sal = find_pc_line (prologue_sal.end, 0); + if (sal.line == 0) + break; + /* Assume that a consecutive SAL for the same (or larger) + line mark the prologue -> body transition. */ + if (sal.line >= prologue_sal.line) + break; + /* The case in which compiler's optimizer/scheduler has + moved instructions into the prologue. We look ahead in + the function looking for address ranges whose + corresponding line number is less the first one that we + found for the function. This is more conservative then + refine_prologue_limit which scans a large number of SALs + looking for any in the prologue */ + prologue_sal = sal; + } + } + return prologue_sal.end; +} struct symtabs_and_lines decode_line_spec (char *string, int funfirstline) @@ -3923,7 +4142,7 @@ decode_line_spec (char *string, int funfirstline) struct symtab_and_line cursal; if (string == 0) - error ("Empty line specification."); + error (_("Empty line specification.")); /* We use whatever is set as the current source line. We do not try and get a default or it will recursively call us! */ @@ -3931,10 +4150,10 @@ decode_line_spec (char *string, int funfirstline) sals = decode_line_1 (&string, funfirstline, cursal.symtab, cursal.line, - (char ***) NULL); + (char ***) NULL, NULL); if (*string) - error ("Junk at end of line specification: %s", string); + error (_("Junk at end of line specification: %s"), string); return sals; } @@ -3955,27 +4174,71 @@ set_main_name (const char *name) } } +/* Deduce the name of the main procedure, and set NAME_OF_MAIN + accordingly. */ + +static void +find_main_name (void) +{ + char *new_main_name; + + /* Try to see if the main procedure is in Ada. */ + /* FIXME: brobecker/2005-03-07: Another way of doing this would + be to add a new method in the language vector, and call this + method for each language until one of them returns a non-empty + name. This would allow us to remove this hard-coded call to + an Ada function. It is not clear that this is a better approach + at this point, because all methods need to be written in a way + such that false positives never be returned. For instance, it is + important that a method does not return a wrong name for the main + procedure if the main procedure is actually written in a different + language. It is easy to guaranty this with Ada, since we use a + special symbol generated only when the main in Ada to find the name + of the main procedure. It is difficult however to see how this can + be guarantied for languages such as C, for instance. This suggests + that order of call for these methods becomes important, which means + a more complicated approach. */ + new_main_name = ada_main_name (); + if (new_main_name != NULL) + { + set_main_name (new_main_name); + return; + } + + /* The languages above didn't identify the name of the main procedure. + Fallback to "main". */ + set_main_name ("main"); +} + char * main_name (void) { - if (name_of_main != NULL) - return name_of_main; - else - return "main"; + if (name_of_main == NULL) + find_main_name (); + + return name_of_main; } +/* Handle ``executable_changed'' events for the symtab module. */ + +static void +symtab_observer_executable_changed (void *unused) +{ + /* NAME_OF_MAIN may no longer be the same, so reset it for now. */ + set_main_name (NULL); +} void _initialize_symtab (void) { - add_info ("variables", variables_info, - "All global and static variable names, or those matching REGEXP."); + add_info ("variables", variables_info, _("\ +All global and static variable names, or those matching REGEXP.")); if (dbx_commands) - add_com ("whereis", class_info, variables_info, - "All global and static variable names, or those matching REGEXP."); + add_com ("whereis", class_info, variables_info, _("\ +All global and static variable names, or those matching REGEXP.")); add_info ("functions", functions_info, - "All function names, or those matching REGEXP."); + _("All function names, or those matching REGEXP.")); /* FIXME: This command has at least the following problems: @@ -3987,22 +4250,25 @@ _initialize_symtab (void) I also think "ptype" or "whatis" is more likely to be useful (but if there is much disagreement "info types" can be fixed). */ add_info ("types", types_info, - "All type names, or those matching REGEXP."); + _("All type names, or those matching REGEXP.")); add_info ("sources", sources_info, - "Source files in the program."); + _("Source files in the program.")); add_com ("rbreak", class_breakpoint, rbreak_command, - "Set a breakpoint for all functions matching REGEXP."); + _("Set a breakpoint for all functions matching REGEXP.")); if (xdb_commands) { - add_com ("lf", class_info, sources_info, "Source files in the program"); - add_com ("lg", class_info, variables_info, - "All global and static variable names, or those matching REGEXP."); + add_com ("lf", class_info, sources_info, + _("Source files in the program")); + add_com ("lg", class_info, variables_info, _("\ +All global and static variable names, or those matching REGEXP.")); } /* Initialize the one built-in type that isn't language dependent... */ builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0, "", (struct objfile *) NULL); + + observer_attach_executable_changed (symtab_observer_executable_changed); }