X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsymtab.c;h=206119980c8fcbb92c10860d60f262ef4d8aba5f;hb=52f0bd74b2d084346e08abf2c7d9b5435fc1a9d5;hp=2c46f9d67510d140fef909ba3dbd9b38be28529e;hpb=1bae87b9e6b3c222e123b8f03fc7074e1036ef70;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/symtab.c b/gdb/symtab.c index 2c46f9d675..206119980c 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -46,6 +46,7 @@ #include "gdb_obstack.h" #include "block.h" +#include "dictionary.h" #include #include @@ -76,53 +77,42 @@ static int find_line_common (struct linetable *, int, int *); char *operator_chars (char *p, char **end); -static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *, - const char *, - const char *, int, - namespace_enum); - static struct symbol *lookup_symbol_aux (const char *name, - const char *mangled_name, + const char *linkage_name, const struct block *block, - const namespace_enum namespace, + const domain_enum domain, int *is_a_field_of_this, struct symtab **symtab); static struct symbol *lookup_symbol_aux_local (const char *name, - const char *mangled_name, - const struct block *block, - const namespace_enum namespace, - struct symtab **symtab, - const struct block **static_block); - -static -struct symbol *lookup_symbol_aux_block (const char *name, - const char *mangled_name, + const char *linkage_name, const struct block *block, - const namespace_enum namespace, + const domain_enum domain, struct symtab **symtab); static struct symbol *lookup_symbol_aux_symtabs (int block_index, const char *name, - const char *mangled_name, - const namespace_enum namespace, + const char *linkage_name, + const domain_enum domain, struct symtab **symtab); static struct symbol *lookup_symbol_aux_psymtabs (int block_index, const char *name, - const char *mangled_name, - const namespace_enum namespace, + const char *linkage_name, + const domain_enum domain, struct symtab **symtab); +#if 0 static struct symbol *lookup_symbol_aux_minsyms (const char *name, - const char *mangled_name, - const namespace_enum namespace, + const char *linkage_name, + const domain_enum domain, int *is_a_field_of_this, struct symtab **symtab); +#endif static struct symbol *find_active_alias (struct symbol *sym, CORE_ADDR addr); @@ -134,14 +124,12 @@ static void fixup_section (struct general_symbol_info *, struct objfile *); static int file_matches (char *, char **, int); -static void print_symbol_info (namespace_enum, +static void print_symbol_info (domain_enum, struct symtab *, struct symbol *, int, char *); static void print_msymbol_info (struct minimal_symbol *); -static void symtab_symbol_info (char *, namespace_enum, int); - -static void overload_list_add_symbol (struct symbol *sym, char *oload_name); +static void symtab_symbol_info (char *, domain_enum, int); void _initialize_symtab (void); @@ -163,9 +151,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; @@ -256,8 +244,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; @@ -691,8 +679,8 @@ init_sal (struct symtab_and_line *sal) 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 @@ -779,7 +767,7 @@ find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc, pp++) { p = *pp; - if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE + if (SYMBOL_DOMAIN (p) == VAR_DOMAIN && SYMBOL_CLASS (p) == LOC_BLOCK && pc >= SYMBOL_VALUE_ADDRESS (p) && (SYMBOL_VALUE_ADDRESS (p) > best_pc @@ -803,7 +791,7 @@ find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc, pp++) { p = *pp; - if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE + if (SYMBOL_DOMAIN (p) == VAR_DOMAIN && SYMBOL_CLASS (p) == LOC_BLOCK && pc >= SYMBOL_VALUE_ADDRESS (p) && (SYMBOL_VALUE_ADDRESS (p) > best_pc @@ -878,7 +866,7 @@ fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile) } /* Find the definition for a specified symbol name NAME - in namespace NAMESPACE, visible from lexical block BLOCK. + in domain DOMAIN, visible from lexical block BLOCK. Returns the struct symbol pointer, or zero if no symbol is found. If SYMTAB is non-NULL, store the symbol table in which the symbol was found there, or NULL if not found. @@ -900,7 +888,7 @@ fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile) struct symbol * lookup_symbol (const char *name, const struct block *block, - const namespace_enum namespace, int *is_a_field_of_this, + const domain_enum domain, int *is_a_field_of_this, struct symtab **symtab) { char *demangled_name = NULL; @@ -938,82 +926,49 @@ lookup_symbol (const char *name, const struct block *block, } returnval = lookup_symbol_aux (modified_name, mangled_name, block, - namespace, is_a_field_of_this, symtab); + domain, is_a_field_of_this, symtab); if (needtofreename) xfree (demangled_name); return returnval; } +/* Behave like lookup_symbol_aux 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. */ + static struct symbol * -lookup_symbol_aux (const char *name, const char *mangled_name, - const struct block *block, const namespace_enum namespace, +lookup_symbol_aux (const char *name, const char *linkage_name, + const struct block *block, const domain_enum domain, int *is_a_field_of_this, struct symtab **symtab) { struct symbol *sym; - const struct block *static_block; + + /* 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. */ - sym = lookup_symbol_aux_local (name, mangled_name, block, namespace, - symtab, &static_block); + sym = lookup_symbol_aux_local (name, linkage_name, block, domain, + symtab); if (sym != NULL) return sym; -#if 0 - /* NOTE: carlton/2002-11-05: At the time that this code was - #ifdeffed out, the value of 'block' was always NULL at this - point, hence the bemused comments below. */ - - /* FIXME: this code is never executed--block is always NULL at this - point. What is it trying to do, anyway? We already should have - checked the STATIC_BLOCK above (it is the superblock of top-level - blocks). Why is VAR_NAMESPACE special-cased? */ - /* Don't need to mess with the psymtabs; if we have a block, - that file is read in. If we don't, then we deal later with - all the psymtab stuff that needs checking. */ - /* Note (RT): The following never-executed code looks unnecessary to me also. - * If we change the code to use the original (passed-in) - * value of 'block', we could cause it to execute, but then what - * would it do? The STATIC_BLOCK of the symtab containing the passed-in - * 'block' was already searched by the above code. And the STATIC_BLOCK's - * of *other* symtabs (those files not containing 'block' lexically) - * should not contain 'block' address-wise. So we wouldn't expect this - * code to find any 'sym''s that were not found above. I vote for - * deleting the following paragraph of code. - */ - if (namespace == VAR_NAMESPACE && block != NULL) - { - struct block *b; - /* Find the right symtab. */ - ALL_SYMTABS (objfile, s) - { - bv = BLOCKVECTOR (s); - b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - if (BLOCK_START (b) <= BLOCK_START (block) - && BLOCK_END (b) > BLOCK_START (block)) - { - sym = lookup_block_symbol (b, name, mangled_name, VAR_NAMESPACE); - if (sym) - { - block_found = b; - if (symtab != NULL) - *symtab = s; - return fixup_symbol_section (sym, objfile); - } - } - } - } -#endif /* 0 */ + /* 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'. */ - /* C++/Java/Objective-C: If requested to do so by the caller, - check to see if NAME is a field of `this'. */ - if (is_a_field_of_this) + if (current_language->la_value_of_this != NULL + && is_a_field_of_this != NULL) { - struct value *v = value_of_this (0); + struct value *v = current_language->la_value_of_this (0); - *is_a_field_of_this = 0; if (v && check_field (v, name)) { *is_a_field_of_this = 1; @@ -1023,65 +978,12 @@ lookup_symbol_aux (const char *name, const char *mangled_name, } } - /* If there's a static block to search, search it next. */ - - /* NOTE: carlton/2002-12-05: There is a question as to whether or - not it would be appropriate to search the current global block - here as well. (That's what this code used to do before the - is_a_field_of_this check was moved up.) On the one hand, it's - redundant with the lookup_symbol_aux_symtabs search that happens - next. On the other hand, if decode_line_1 is passed an argument - like filename:var, then the user presumably wants 'var' to be - searched for in filename. On the third hand, there shouldn't be - multiple global variables all of which are named 'var', and it's - not like decode_line_1 has ever restricted its search to only - global variables in a single filename. All in all, only - searching the static block here seems best: it's correct and it's - cleanest. */ - - /* NOTE: carlton/2002-12-05: There's also a possible performance - issue here: if you usually search for global symbols in the - current file, then it would be slightly better to search the - current global block before searching all the symtabs. But there - are other factors that have a much greater effect on performance - than that one, so I don't think we should worry about that for - now. */ - - if (static_block != NULL) - { - sym = lookup_symbol_aux_block (name, mangled_name, static_block, - namespace, symtab); - if (sym != NULL) - return sym; - } - - /* Now search all global blocks. 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. */ - - sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, mangled_name, - namespace, symtab); - if (sym != NULL) - return sym; - -#ifndef HPUXHPPA - - /* Check for the possibility of the symbol being a function or - a mangled variable that is stored in one of the minimal symbol tables. - Eventually, all global symbols might be resolved in this way. */ - - sym = lookup_symbol_aux_minsyms (name, mangled_name, - namespace, is_a_field_of_this, - symtab); - - if (sym != NULL) - return sym; - -#endif + /* Now do whatever is appropriate for the current language to look + up static and global variables. */ - sym = lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, mangled_name, - namespace, symtab); + sym = current_language->la_lookup_symbol_nonlocal (name, linkage_name, + block, domain, + symtab); if (sym != NULL) return sym; @@ -1091,91 +993,59 @@ lookup_symbol_aux (const char *name, const char *mangled_name, desired name as a file-level static, then do psymtab-to-symtab conversion on the fly and return the found symbol. */ - sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, mangled_name, - namespace, symtab); - if (sym != NULL) - return sym; - - sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, mangled_name, - namespace, symtab); + sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, linkage_name, + domain, symtab); if (sym != NULL) return sym; - -#ifdef HPUXHPPA - - /* Check for the possibility of the symbol being a function or - a global variable that is stored in one of the minimal symbol tables. - The "minimal symbol table" is built from linker-supplied info. - - RT: I moved this check to last, after the complete search of - the global (p)symtab's and static (p)symtab's. For HP-generated - symbol tables, this check was causing a premature exit from - lookup_symbol with NULL return, and thus messing up symbol lookups - of things like "c::f". It seems to me a check of the minimal - symbol table ought to be a last resort in any case. I'm vaguely - worried about the comment below which talks about FORTRAN routines "foo_" - though... is it saying we need to do the "minsym" check before - the static check in this case? - */ - - - sym = lookup_symbol_aux_minsyms (name, mangled_name, - namespace, is_a_field_of_this, - symtab); + sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, linkage_name, + domain, symtab); if (sym != NULL) return sym; -#endif - if (symtab != NULL) *symtab = NULL; return NULL; } /* Check to see if the symbol is defined in BLOCK or its superiors. - Don't search STATIC_BLOCK or GLOBAL_BLOCK. If we don't find a - match, store the address of STATIC_BLOCK in static_block. */ + Don't search STATIC_BLOCK or GLOBAL_BLOCK. */ static struct symbol * -lookup_symbol_aux_local (const char *name, const char *mangled_name, +lookup_symbol_aux_local (const char *name, const char *linkage_name, const struct block *block, - const namespace_enum namespace, - struct symtab **symtab, - const struct block **static_block) + const domain_enum domain, + struct symtab **symtab) { struct symbol *sym; - + const struct block *static_block = block_static_block (block); + /* Check if either no block is specified or it's a global block. */ - if (block == NULL || BLOCK_SUPERBLOCK (block) == NULL) - { - *static_block = NULL; - return NULL; - } + if (static_block == NULL) + return NULL; - while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL) + while (block != static_block) { - sym = lookup_symbol_aux_block (name, mangled_name, block, namespace, + sym = lookup_symbol_aux_block (name, linkage_name, block, domain, symtab); if (sym != NULL) return sym; block = BLOCK_SUPERBLOCK (block); } - /* We've reached the static block. */ + /* We've reached the static block without finding a result. */ - *static_block = block; return NULL; } /* Look up a symbol in a block; if found, locate its symtab, fixup the symbol, and set block_found appropriately. */ -static struct symbol * -lookup_symbol_aux_block (const char *name, const char *mangled_name, +struct symbol * +lookup_symbol_aux_block (const char *name, const char *linkage_name, const struct block *block, - const namespace_enum namespace, + const domain_enum domain, struct symtab **symtab) { struct symbol *sym; @@ -1184,7 +1054,7 @@ lookup_symbol_aux_block (const char *name, const char *mangled_name, struct block *b; struct symtab *s = NULL; - sym = lookup_block_symbol (block, name, mangled_name, namespace); + sym = lookup_block_symbol (block, name, linkage_name, domain); if (sym) { block_found = block; @@ -1217,8 +1087,8 @@ lookup_symbol_aux_block (const char *name, const char *mangled_name, static struct symbol * lookup_symbol_aux_symtabs (int block_index, - const char *name, const char *mangled_name, - const namespace_enum namespace, + const char *name, const char *linkage_name, + const domain_enum domain, struct symtab **symtab) { struct symbol *sym; @@ -1231,7 +1101,7 @@ lookup_symbol_aux_symtabs (int block_index, { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, block_index); - sym = lookup_block_symbol (block, name, mangled_name, namespace); + sym = lookup_block_symbol (block, name, linkage_name, domain); if (sym) { block_found = block; @@ -1251,8 +1121,8 @@ lookup_symbol_aux_symtabs (int block_index, static struct symbol * lookup_symbol_aux_psymtabs (int block_index, const char *name, - const char *mangled_name, - const namespace_enum namespace, + const char *linkage_name, + const domain_enum domain, struct symtab **symtab) { struct symbol *sym; @@ -1266,13 +1136,13 @@ lookup_symbol_aux_psymtabs (int block_index, const char *name, ALL_PSYMTABS (objfile, ps) { if (!ps->readin - && lookup_partial_symbol (ps, name, mangled_name, - psymtab_index, namespace)) + && lookup_partial_symbol (ps, name, linkage_name, + psymtab_index, domain)) { s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, block_index); - sym = lookup_block_symbol (block, name, mangled_name, namespace); + sym = lookup_block_symbol (block, name, linkage_name, domain); if (!sym) { /* This shouldn't be necessary, but as a last resort try @@ -1289,7 +1159,7 @@ lookup_symbol_aux_psymtabs (int block_index, const char *name, block = BLOCKVECTOR_BLOCK (bv, block_index == GLOBAL_BLOCK ? STATIC_BLOCK : GLOBAL_BLOCK); - sym = lookup_block_symbol (block, name, mangled_name, namespace); + 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).", block_index == GLOBAL_BLOCK ? "global" : "static", @@ -1304,6 +1174,7 @@ lookup_symbol_aux_psymtabs (int block_index, const char *name, return NULL; } +#if 0 /* Check for the possibility of the symbol being a function or a mangled variable that is stored in one of the minimal symbol tables. Eventually, all global symbols might be resolved in this @@ -1317,10 +1188,15 @@ lookup_symbol_aux_psymtabs (int block_index, const char *name, some additional conditions held as well, and it caused problems with HP-generated symbol tables. */ +/* NOTE: carlton/2003-05-14: This function was once used as part of + lookup_symbol. It is currently unnecessary for correctness + reasons, however, and using it doesn't seem to be any faster than + using lookup_symbol_aux_psymtabs, so I'm commenting it out. */ + static struct symbol * lookup_symbol_aux_minsyms (const char *name, - const char *mangled_name, - const namespace_enum namespace, + const char *linkage_name, + const domain_enum domain, int *is_a_field_of_this, struct symtab **symtab) { @@ -1330,7 +1206,7 @@ lookup_symbol_aux_minsyms (const char *name, struct minimal_symbol *msymbol; struct symtab *s; - if (namespace == VAR_NAMESPACE) + if (domain == VAR_DOMAIN) { msymbol = lookup_minimal_symbol (name, NULL, NULL); @@ -1358,20 +1234,20 @@ 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 unmangled name. */ sym = - lookup_block_symbol (block, name, mangled_name, namespace); + lookup_block_symbol (block, name, linkage_name, domain); /* We kept static functions in minimal symbol table as well as in static scope. We want to find them in the symbol table. */ if (!sym) { block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); sym = lookup_block_symbol (block, name, - mangled_name, namespace); + linkage_name, domain); } /* NOTE: carlton/2002-12-04: The following comment was @@ -1417,31 +1293,109 @@ lookup_symbol_aux_minsyms (const char *name, *symtab = s; return fixup_symbol_section (sym, s->objfile); } - else if (MSYMBOL_TYPE (msymbol) != mst_text - && MSYMBOL_TYPE (msymbol) != mst_file_text - && !STREQ (name, DEPRECATED_SYMBOL_NAME (msymbol))) - { - /* This is a mangled variable, look it up by its - mangled name. */ - return lookup_symbol_aux (DEPRECATED_SYMBOL_NAME (msymbol), mangled_name, - NULL, namespace, is_a_field_of_this, - symtab); - } } } return NULL; } +#endif /* 0 */ + +/* A default version of lookup_symbol_nonlocal for use by languages + that can't think of anything better to do. This implements the C + lookup rules. */ + +struct symbol * +basic_lookup_symbol_nonlocal (const char *name, + const char *linkage_name, + const struct block *block, + const domain_enum domain, + struct symtab **symtab) +{ + struct symbol *sym; + + /* NOTE: carlton/2003-05-19: The comments below were written when + this (or what turned into this) was part of lookup_symbol_aux; + I'm much less worried about these questions now, since these + decisions have turned out well, but I leave these comments here + for posterity. */ + + /* NOTE: carlton/2002-12-05: There is a question as to whether or + not it would be appropriate to search the current global block + here as well. (That's what this code used to do before the + is_a_field_of_this check was moved up.) On the one hand, it's + redundant with the lookup_symbol_aux_symtabs search that happens + next. On the other hand, if decode_line_1 is passed an argument + like filename:var, then the user presumably wants 'var' to be + searched for in filename. On the third hand, there shouldn't be + multiple global variables all of which are named 'var', and it's + not like decode_line_1 has ever restricted its search to only + global variables in a single filename. All in all, only + searching the static block here seems best: it's correct and it's + cleanest. */ + + /* NOTE: carlton/2002-12-05: There's also a possible performance + issue here: if you usually search for global symbols in the + current file, then it would be slightly better to search the + current global block before searching all the symtabs. But there + are other factors that have a much greater effect on performance + than that one, so I don't think we should worry about that for + now. */ + + sym = lookup_symbol_static (name, linkage_name, block, domain, symtab); + if (sym != NULL) + return sym; + + return lookup_symbol_global (name, linkage_name, domain, symtab); +} + +/* Lookup a symbol in the static block associated to BLOCK, if there + is one; do nothing if BLOCK is NULL or a global block. */ + +struct symbol * +lookup_symbol_static (const char *name, + const char *linkage_name, + const struct block *block, + const domain_enum domain, + struct symtab **symtab) +{ + const struct block *static_block = block_static_block (block); + + if (static_block != NULL) + return lookup_symbol_aux_block (name, linkage_name, static_block, + domain, symtab); + else + return NULL; +} + +/* Lookup a symbol in all files' global blocks (searching psymtabs if + necessary). */ + +struct symbol * +lookup_symbol_global (const char *name, + const char *linkage_name, + const domain_enum domain, + struct symtab **symtab) +{ + struct symbol *sym; + + sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, linkage_name, + domain, symtab); + if (sym != NULL) + return sym; + + return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, linkage_name, + domain, symtab); +} /* Look, in partial_symtab PST, for symbol whose natural name is NAME. If LINKAGE_NAME is non-NULL, check in addition that the symbol's linkage name matches it. Check the global symbols if GLOBAL, the static symbols if not */ -static struct partial_symbol * +struct partial_symbol * lookup_partial_symbol (struct partial_symtab *pst, const char *name, const char *linkage_name, int global, - namespace_enum namespace) + domain_enum domain) { struct partial_symbol *temp; struct partial_symbol **start, **psym; @@ -1465,7 +1419,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, pointing at the earliest partial symbol whose name might be correct. At that point *all* partial symbols with an appropriate name will be checked against the correct - namespace. */ + domain. */ bottom = start; top = start + length - 1; @@ -1497,7 +1451,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, ? strcmp (SYMBOL_LINKAGE_NAME (*top), linkage_name) == 0 : SYMBOL_MATCHES_NATURAL_NAME (*top,name))) { - if (SYMBOL_NAMESPACE (*top) == namespace) + if (SYMBOL_DOMAIN (*top) == domain) { return (*top); } @@ -1512,7 +1466,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, { for (psym = start; psym < start + length; psym++) { - if (namespace == SYMBOL_NAMESPACE (*psym)) + if (domain == SYMBOL_DOMAIN (*psym)) { if (linkage_name != NULL ? strcmp (SYMBOL_LINKAGE_NAME (*psym), linkage_name) == 0 @@ -1527,23 +1481,23 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, return (NULL); } -/* Look up a type named NAME in the struct_namespace. The type returned +/* 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 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_namespace and only at file-static or global blocks. */ + are available in struct_domain and only at file-static or global blocks. */ struct type * 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 @@ -1554,7 +1508,7 @@ lookup_transparent_type (const char *name) { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE); + sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) { return SYMBOL_TYPE (sym); @@ -1564,12 +1518,12 @@ lookup_transparent_type (const char *name) ALL_PSYMTABS (objfile, ps) { if (!ps->readin && lookup_partial_symbol (ps, name, NULL, - 1, STRUCT_NAMESPACE)) + 1, STRUCT_DOMAIN)) { s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE); + sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); if (!sym) { /* This shouldn't be necessary, but as a last resort @@ -1578,7 +1532,7 @@ lookup_transparent_type (const char *name) * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE); + 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\ %s may be an inlined function, or may be a template function\n\ @@ -1602,7 +1556,7 @@ lookup_transparent_type (const char *name) { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE); + sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) { return SYMBOL_TYPE (sym); @@ -1611,12 +1565,12 @@ lookup_transparent_type (const char *name) ALL_PSYMTABS (objfile, ps) { - if (!ps->readin && lookup_partial_symbol (ps, name, NULL, 0, STRUCT_NAMESPACE)) + if (!ps->readin && lookup_partial_symbol (ps, name, NULL, 0, STRUCT_DOMAIN)) { s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE); + sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); if (!sym) { /* This shouldn't be necessary, but as a last resort @@ -1625,7 +1579,7 @@ lookup_transparent_type (const char *name) * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE); + 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\ %s may be an inlined function, or may be a template function\n\ @@ -1647,12 +1601,12 @@ 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) { - if (lookup_partial_symbol (pst, main_name (), NULL, 1, VAR_NAMESPACE)) + if (lookup_partial_symbol (pst, main_name (), NULL, 1, VAR_DOMAIN)) { return (pst); } @@ -1660,7 +1614,7 @@ find_main_psymtab (void) return (NULL); } -/* Search BLOCK for symbol NAME in NAMESPACE. +/* Search BLOCK for symbol NAME in DOMAIN. Note that if NAME is the demangled form of a C++ symbol, we will fail to find a match during the binary search of the non-encoded names, but @@ -1671,136 +1625,48 @@ find_main_psymtab (void) symbol (language_cplus or language_objc set) has both the encoded and non-encoded names tested for a match. - If MANGLED_NAME is non-NULL, verify that any symbol we find has this + If LINKAGE_NAME is non-NULL, verify that any symbol we find has this particular mangled name. */ struct symbol * lookup_block_symbol (register const struct block *block, const char *name, - const char *mangled_name, - const namespace_enum namespace) + const char *linkage_name, + const domain_enum domain) { - register int bot, top, inc; - register struct symbol *sym; - register struct symbol *sym_found = NULL; - register int do_linear_search = 1; + struct dict_iterator iter; + struct symbol *sym; - if (BLOCK_HASHTABLE (block)) + if (!BLOCK_FUNCTION (block)) { - unsigned int hash_index; - hash_index = msymbol_hash_iw (name); - hash_index = hash_index % BLOCK_BUCKETS (block); - for (sym = BLOCK_BUCKET (block, hash_index); sym; sym = sym->hash_next) + for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter); + sym != NULL; + sym = dict_iter_name_next (name, &iter)) { - if (SYMBOL_NAMESPACE (sym) == namespace - && (mangled_name - ? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0 - : SYMBOL_MATCHES_NATURAL_NAME (sym, name))) + if (SYMBOL_DOMAIN (sym) == domain + && (linkage_name != NULL + ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1)) return sym; } return NULL; } - - /* If the blocks's symbols were sorted, start with a binary search. */ - - if (BLOCK_SHOULD_SORT (block)) + else { - /* Reset the linear search flag so if the binary search fails, we - won't do the linear search once unless we find some reason to - do so */ - - do_linear_search = 0; - top = BLOCK_NSYMS (block); - bot = 0; - - /* Advance BOT to not far before the first symbol whose name is NAME. */ - - while (1) - { - inc = (top - bot + 1); - /* No need to keep binary searching for the last few bits worth. */ - if (inc < 4) - { - break; - } - inc = (inc >> 1) + bot; - sym = BLOCK_SYM (block, inc); - if (!do_linear_search && (SYMBOL_LANGUAGE (sym) == language_java)) - { - do_linear_search = 1; - } - if (SYMBOL_NATURAL_NAME (sym)[0] < name[0]) - { - bot = inc; - } - else if (SYMBOL_NATURAL_NAME (sym)[0] > name[0]) - { - top = inc; - } - else if (strcmp (SYMBOL_NATURAL_NAME (sym), name) < 0) - { - bot = inc; - } - else - { - top = inc; - } - } - - /* Now scan forward until we run out of symbols, find one whose - name is greater than NAME, or find one we want. If there is - more than one symbol with the right name and namespace, we - return the first one; I believe it is now impossible for us - to encounter two symbols with the same name and namespace - here, because blocks containing argument symbols are no - longer sorted. The exception is for C++, where multiple functions - (cloned constructors / destructors, in particular) can have - the same demangled name. So if we have a particular - mangled name to match, try to do so. */ - - top = BLOCK_NSYMS (block); - while (bot < top) - { - sym = BLOCK_SYM (block, bot); - if (SYMBOL_NAMESPACE (sym) == namespace - && (mangled_name - ? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0 - : SYMBOL_MATCHES_NATURAL_NAME (sym, name))) - { - return sym; - } - if (SYMBOL_PRINT_NAME (sym)[0] > name[0]) - { - break; - } - bot++; - } - } - - /* Here if block isn't sorted, or we fail to find a match during the - binary search above. If during the binary search above, we find a - symbol which is a Java symbol, then we have re-enabled the linear - search flag which was reset when starting the binary search. + /* Note that parameter symbols do not always show up last in the + list; this loop makes sure to take anything else other than + parameter symbols first; it only uses parameter symbols as a + last resort. Note that this only takes up extra computation + time on a match. */ - This loop is equivalent to the loop above, but hacked greatly for speed. + struct symbol *sym_found = NULL; - Note that parameter symbols do not always show up last in the - list; this loop makes sure to take anything else other than - parameter symbols first; it only uses parameter symbols as a - last resort. Note that this only takes up extra computation - time on a match. */ - - if (do_linear_search) - { - top = BLOCK_NSYMS (block); - bot = 0; - while (bot < top) + for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter); + sym != NULL; + sym = dict_iter_name_next (name, &iter)) { - sym = BLOCK_SYM (block, bot); - if (SYMBOL_NAMESPACE (sym) == namespace - && (mangled_name - ? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0 - : SYMBOL_MATCHES_NATURAL_NAME (sym, name))) + if (SYMBOL_DOMAIN (sym) == domain + && (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 @@ -1809,18 +1675,18 @@ lookup_block_symbol (register const struct block *block, const char *name, ?!? 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. + 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. */ + 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 ()); @@ -1837,10 +1703,9 @@ lookup_block_symbol (register const struct block *block, const char *name, break; } } - bot++; } + return (sym_found); /* Will be NULL if not found. */ } - return (sym_found); /* Will be NULL if not found. */ } /* Given a main symbol SYM and ADDR, search through the alias @@ -1881,12 +1746,12 @@ find_active_alias (struct symbol *sym, CORE_ADDR addr) 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; @@ -1943,16 +1808,16 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *section) } if (section != 0) { - int i; + struct dict_iterator iter; struct symbol *sym = NULL; - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { fixup_symbol_section (sym, objfile); if (section == SYMBOL_BFD_SECTION (sym)) break; } - if ((i >= BLOCK_BUCKETS (b)) && (sym == NULL)) + if (sym == NULL) continue; /* no symbol in this symtab matches section */ } distance = BLOCK_END (b) - BLOCK_START (b); @@ -2010,10 +1875,10 @@ struct symtab_and_line find_pc_sect_line (CORE_ADDR pc, struct sec *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; @@ -2103,7 +1968,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, NULL); if (mfunsym == NULL) /* I eliminated this warning since it is coming out * in the following situation: @@ -2114,12 +1980,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); @@ -2425,8 +2291,8 @@ static int find_line_common (register struct linetable *l, register 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. @@ -2741,9 +2607,9 @@ 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 ()) @@ -2868,10 +2734,10 @@ sort_search_symbols (struct symbol_search *prevtail, int nfound) returning the results in *MATCHES. Only symbols of KIND are searched: - FUNCTIONS_NAMESPACE - search all functions - TYPES_NAMESPACE - search all type names - METHODS_NAMESPACE - search all methods NOT IMPLEMENTED - VARIABLES_NAMESPACE - search all symbols, excluding functions, type names, + FUNCTIONS_DOMAIN - search all functions + TYPES_DOMAIN - search all type names + METHODS_DOMAIN - search all methods NOT IMPLEMENTED + VARIABLES_DOMAIN - search all symbols, excluding functions, type names, and constants (enums) free_search_symbols should be called when *MATCHES is no longer needed. @@ -2880,17 +2746,17 @@ sort_search_symbols (struct symbol_search *prevtail, int nfound) separately alphabetized. */ void -search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[], +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 symtab *s; + struct partial_symtab *ps; + struct blockvector *bv; struct blockvector *prev_bv = 0; - register struct block *b; - register int i = 0; - register int j; - register struct symbol *sym; + struct block *b; + int i = 0; + struct dict_iterator iter; + struct symbol *sym; struct partial_symbol **psym; struct objfile *objfile; struct minimal_symbol *msymbol; @@ -2917,13 +2783,13 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[], struct symbol_search *tail; struct cleanup *old_chain = NULL; - if (kind < VARIABLES_NAMESPACE) - error ("must search on specific namespace"); + if (kind < VARIABLES_DOMAIN) + error ("must search on specific domain"); - ourtype = types[(int) (kind - VARIABLES_NAMESPACE)]; - ourtype2 = types2[(int) (kind - VARIABLES_NAMESPACE)]; - ourtype3 = types3[(int) (kind - VARIABLES_NAMESPACE)]; - ourtype4 = types4[(int) (kind - VARIABLES_NAMESPACE)]; + ourtype = types[(int) (kind - VARIABLES_DOMAIN)]; + ourtype2 = types2[(int) (kind - VARIABLES_DOMAIN)]; + ourtype3 = types3[(int) (kind - VARIABLES_DOMAIN)]; + ourtype4 = types4[(int) (kind - VARIABLES_DOMAIN)]; sr = *matches = NULL; tail = NULL; @@ -3005,11 +2871,11 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[], if (file_matches (ps->filename, files, nfiles) && ((regexp == NULL || re_exec (SYMBOL_NATURAL_NAME (*psym)) != 0) - && ((kind == VARIABLES_NAMESPACE && SYMBOL_CLASS (*psym) != LOC_TYPEDEF + && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (*psym) != LOC_TYPEDEF && SYMBOL_CLASS (*psym) != LOC_BLOCK) - || (kind == FUNCTIONS_NAMESPACE && SYMBOL_CLASS (*psym) == LOC_BLOCK) - || (kind == TYPES_NAMESPACE && SYMBOL_CLASS (*psym) == LOC_TYPEDEF) - || (kind == METHODS_NAMESPACE && SYMBOL_CLASS (*psym) == LOC_BLOCK)))) + || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK) + || (kind == TYPES_DOMAIN && SYMBOL_CLASS (*psym) == LOC_TYPEDEF) + || (kind == METHODS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK)))) { PSYMTAB_TO_SYMTAB (ps); keep_going = 0; @@ -3032,7 +2898,7 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[], any matching symbols without debug info. */ - if (nfiles == 0 && (kind == VARIABLES_NAMESPACE || kind == FUNCTIONS_NAMESPACE)) + if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN)) { ALL_MSYMBOLS (objfile, msymbol) { @@ -3052,10 +2918,10 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[], function lookup_symbol_minsym that found the symbol associated to a given minimal symbol (if any). */ - if (kind == FUNCTIONS_NAMESPACE - || lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol), + if (kind == FUNCTIONS_DOMAIN + || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), (struct block *) NULL, - VAR_NAMESPACE, + VAR_DOMAIN, 0, (struct symtab **) NULL) == NULL) found_misc = 1; } @@ -3078,18 +2944,18 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[], struct symbol_search *prevtail = tail; int nfound = 0; b = BLOCKVECTOR_BLOCK (bv, i); - ALL_BLOCK_SYMBOLS (b, j, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { QUIT; if (file_matches (s->filename, files, nfiles) && ((regexp == NULL || re_exec (SYMBOL_NATURAL_NAME (sym)) != 0) - && ((kind == VARIABLES_NAMESPACE && SYMBOL_CLASS (sym) != LOC_TYPEDEF + && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (sym) != LOC_TYPEDEF && SYMBOL_CLASS (sym) != LOC_BLOCK && SYMBOL_CLASS (sym) != LOC_CONST) - || (kind == FUNCTIONS_NAMESPACE && SYMBOL_CLASS (sym) == LOC_BLOCK) - || (kind == TYPES_NAMESPACE && SYMBOL_CLASS (sym) == LOC_TYPEDEF) - || (kind == METHODS_NAMESPACE && SYMBOL_CLASS (sym) == LOC_BLOCK)))) + || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK) + || (kind == TYPES_DOMAIN && SYMBOL_CLASS (sym) == LOC_TYPEDEF) + || (kind == METHODS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK)))) { /* match */ psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search)); @@ -3128,7 +2994,7 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[], /* If there are no eyes, avoid all contact. I mean, if there are no debug symbols, then print directly from the msymbol_vector. */ - if (found_misc || kind != FUNCTIONS_NAMESPACE) + if (found_misc || kind != FUNCTIONS_DOMAIN) { ALL_MSYMBOLS (objfile, msymbol) { @@ -3141,12 +3007,12 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[], || re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0) { /* Functions: Look up by address. */ - if (kind != FUNCTIONS_NAMESPACE || + if (kind != FUNCTIONS_DOMAIN || (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))) { /* Variables/Absolutes: Look up by name */ - if (lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol), - (struct block *) NULL, VAR_NAMESPACE, + if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), + (struct block *) NULL, VAR_DOMAIN, 0, (struct symtab **) NULL) == NULL) { /* match */ @@ -3181,7 +3047,7 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[], regarding the match to gdb_stdout. */ static void -print_symbol_info (namespace_enum kind, struct symtab *s, struct symbol *sym, +print_symbol_info (domain_enum kind, struct symtab *s, struct symbol *sym, int block, char *last) { if (last == NULL || strcmp (last, s->filename) != 0) @@ -3191,17 +3057,17 @@ print_symbol_info (namespace_enum kind, struct symtab *s, struct symbol *sym, fputs_filtered (":\n", gdb_stdout); } - if (kind != TYPES_NAMESPACE && block == STATIC_BLOCK) + if (kind != TYPES_DOMAIN && block == STATIC_BLOCK) printf_filtered ("static "); /* Typedef that is not a C++ class */ - if (kind == TYPES_NAMESPACE - && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE) + if (kind == TYPES_DOMAIN + && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN) typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout); /* variable, func, or typedef-that-is-c++-class */ - else if (kind < TYPES_NAMESPACE || - (kind == TYPES_NAMESPACE && - SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE)) + else if (kind < TYPES_DOMAIN || + (kind == TYPES_DOMAIN && + SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN)) { type_print (SYMBOL_TYPE (sym), (SYMBOL_CLASS (sym) == LOC_TYPEDEF @@ -3237,7 +3103,7 @@ print_msymbol_info (struct minimal_symbol *msymbol) matches. */ static void -symtab_symbol_info (char *regexp, namespace_enum kind, int from_tty) +symtab_symbol_info (char *regexp, domain_enum kind, int from_tty) { static char *classnames[] = @@ -3255,7 +3121,7 @@ symtab_symbol_info (char *regexp, namespace_enum kind, int from_tty) printf_filtered (regexp ? "All %ss matching regular expression \"%s\":\n" : "All defined %ss:\n", - classnames[(int) (kind - VARIABLES_NAMESPACE)], regexp); + classnames[(int) (kind - VARIABLES_DOMAIN)], regexp); for (p = symbols; p != NULL; p = p->next) { @@ -3287,20 +3153,20 @@ symtab_symbol_info (char *regexp, namespace_enum kind, int from_tty) static void variables_info (char *regexp, int from_tty) { - symtab_symbol_info (regexp, VARIABLES_NAMESPACE, from_tty); + symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty); } static void functions_info (char *regexp, int from_tty) { - symtab_symbol_info (regexp, FUNCTIONS_NAMESPACE, from_tty); + symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty); } static void types_info (char *regexp, int from_tty) { - symtab_symbol_info (regexp, TYPES_NAMESPACE, from_tty); + symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty); } /* Breakpoint all functions matching regular expression. */ @@ -3318,22 +3184,22 @@ rbreak_command (char *regexp, int from_tty) struct symbol_search *p; struct cleanup *old_chain; - search_symbols (regexp, FUNCTIONS_NAMESPACE, 0, (char **) NULL, &ss); + search_symbols (regexp, FUNCTIONS_DOMAIN, 0, (char **) NULL, &ss); old_chain = make_cleanup_free_search_symbols (ss); for (p = ss; p != NULL; p = p->next) { 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_NAMESPACE, + print_symbol_info (FUNCTIONS_DOMAIN, p->symtab, p->symbol, p->block, @@ -3341,7 +3207,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)); } @@ -3358,17 +3224,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 @@ -3423,6 +3280,112 @@ completion_list_add_name (char *symname, char *sym_text, int sym_text_len, } } +/* ObjC: In case we are completing on a selector, look as the msymbol + again and feed all the selectors into the mill. */ + +static void +completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text, + int sym_text_len, char *text, char *word) +{ + static char *tmp = NULL; + static unsigned int tmplen = 0; + + char *method, *category, *selector; + char *tmp2 = NULL; + + method = SYMBOL_NATURAL_NAME (msymbol); + + /* Is it a method? */ + if ((method[0] != '-') && (method[0] != '+')) + return; + + if (sym_text[0] == '[') + /* Complete on shortened method method. */ + completion_list_add_name (method + 1, sym_text, sym_text_len, text, word); + + while ((strlen (method) + 1) >= tmplen) + { + if (tmplen == 0) + tmplen = 1024; + else + tmplen *= 2; + tmp = xrealloc (tmp, tmplen); + } + selector = strchr (method, ' '); + if (selector != NULL) + selector++; + + category = strchr (method, '('); + + if ((category != NULL) && (selector != NULL)) + { + memcpy (tmp, method, (category - method)); + tmp[category - method] = ' '; + memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1); + completion_list_add_name (tmp, sym_text, sym_text_len, text, word); + if (sym_text[0] == '[') + completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word); + } + + if (selector != NULL) + { + /* Complete on selector only. */ + strcpy (tmp, selector); + tmp2 = strchr (tmp, ']'); + if (tmp2 != NULL) + *tmp2 = '\0'; + + completion_list_add_name (tmp, sym_text, sym_text_len, text, word); + } +} + +/* Break the non-quoted text based on the characters which are in + symbols. FIXME: This should probably be language-specific. */ + +static char * +language_search_unquoted_string (char *text, char *p) +{ + for (; p > text; --p) + { + if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0') + continue; + else + { + if ((current_language->la_language == language_objc)) + { + if (p[-1] == ':') /* might be part of a method name */ + continue; + else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+')) + p -= 2; /* beginning of a method name */ + else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')') + { /* might be part of a method name */ + char *t = p; + + /* Seeing a ' ' or a '(' is not conclusive evidence + that we are in the middle of a method name. However, + finding "-[" or "+[" should be pretty un-ambiguous. + Unfortunately we have to find it now to decide. */ + + while (t > text) + if (isalnum (t[-1]) || t[-1] == '_' || + t[-1] == ' ' || t[-1] == ':' || + t[-1] == '(' || t[-1] == ')') + --t; + else + break; + + if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+')) + p = t - 2; /* method name detected */ + /* else we leave with p unchanged */ + } + } + break; + } + } + return p; +} + + /* Return a NULL terminated array of all symbols (regardless of class) which begin by matching TEXT. If the answer is no symbols, then the return value is an array which contains only a NULL pointer. @@ -3433,13 +3396,14 @@ completion_list_add_name (char *symname, char *sym_text, int sym_text_len, char ** make_symbol_completion_list (char *text, char *word) { - register struct symbol *sym; - register struct symtab *s; - register struct partial_symtab *ps; - register struct minimal_symbol *msymbol; - register struct objfile *objfile; - register struct block *b, *surrounding_static_block = 0; - register int i, j; + struct symbol *sym; + struct symtab *s; + struct partial_symtab *ps; + struct minimal_symbol *msymbol; + struct objfile *objfile; + struct block *b, *surrounding_static_block = 0; + struct dict_iterator iter; + int j; struct partial_symbol **psym; /* The symbol we are completing on. Points in same buffer as text. */ char *sym_text; @@ -3545,6 +3509,8 @@ make_symbol_completion_list (char *text, char *word) { QUIT; COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word); + + completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text, word); } /* Search upwards from currently selected frame (so that we can @@ -3560,8 +3526,9 @@ make_symbol_completion_list (char *text, char *word) /* Also catch fields of types defined in this places which match our text string. Only complete on types visible from current context. */ - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { + QUIT; COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); if (SYMBOL_CLASS (sym) == LOC_TYPEDEF) { @@ -3590,7 +3557,7 @@ make_symbol_completion_list (char *text, char *word) { QUIT; b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } @@ -3603,7 +3570,7 @@ make_symbol_completion_list (char *text, char *word) /* Don't do this block twice. */ if (b == surrounding_static_block) continue; - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } @@ -3618,10 +3585,10 @@ 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; - register int i; + 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; /* Length of sym_text. */ @@ -3667,16 +3634,8 @@ make_file_symbol_completion_list (char *text, char *word, char *srcfile) } else { - /* It is not a quoted string. Break it based on the characters - which are in symbols. */ - while (p > text) - { - if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0') - --p; - else - break; - } - sym_text = p; + /* Not a quoted string. */ + sym_text = language_search_unquoted_string (text, p); } } @@ -3708,13 +3667,13 @@ make_file_symbol_completion_list (char *text, char *word, char *srcfile) symbols which match. */ b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } @@ -3789,9 +3748,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; @@ -3955,211 +3914,6 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start) return func_addr <= pc && pc < sal.end; } - -/* Begin overload resolution functions */ - -static char * -remove_params (const char *demangled_name) -{ - const char *argp; - char *new_name; - int depth; - - if (demangled_name == NULL) - return NULL; - - /* First find the end of the arg list. */ - argp = strrchr (demangled_name, ')'); - if (argp == NULL) - return NULL; - - /* Back up to the beginning. */ - depth = 1; - - while (argp-- > demangled_name) - { - if (*argp == ')') - depth ++; - else if (*argp == '(') - { - depth --; - - if (depth == 0) - break; - } - } - if (depth != 0) - internal_error (__FILE__, __LINE__, - "bad demangled name %s\n", demangled_name); - while (argp[-1] == ' ' && argp > demangled_name) - argp --; - - new_name = xmalloc (argp - demangled_name + 1); - memcpy (new_name, demangled_name, argp - demangled_name); - new_name[argp - demangled_name] = '\0'; - return new_name; -} - -/* Helper routine for make_symbol_completion_list. */ - -static int sym_return_val_size; -static int sym_return_val_index; -static struct symbol **sym_return_val; - -/* 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 - characters. If so, add it to the current completion list. */ - -static void -overload_list_add_symbol (struct symbol *sym, char *oload_name) -{ - int newsize; - int i; - char *sym_name; - - /* If there is no type information, we can't do anything, so skip */ - if (SYMBOL_TYPE (sym) == NULL) - return; - - /* skip any symbols that we've already considered. */ - for (i = 0; i < sym_return_val_index; ++i) - if (!strcmp (DEPRECATED_SYMBOL_NAME (sym), DEPRECATED_SYMBOL_NAME (sym_return_val[i]))) - return; - - /* Get the demangled name without parameters */ - sym_name = remove_params (SYMBOL_DEMANGLED_NAME (sym)); - if (!sym_name) - return; - - /* skip symbols that cannot match */ - if (strcmp (sym_name, oload_name) != 0) - { - xfree (sym_name); - return; - } - - xfree (sym_name); - - /* We have a match for an overload instance, so add SYM to the current list - * of overload instances */ - if (sym_return_val_index + 3 > sym_return_val_size) - { - newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *); - sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize); - } - sym_return_val[sym_return_val_index++] = sym; - sym_return_val[sym_return_val_index] = NULL; -} - -/* Return a null-terminated list of pointers to function symbols that - * match name of the supplied symbol FSYM. - * This is used in finding all overloaded instances of a function name. - * This has been modified from make_symbol_completion_list. */ - - -struct symbol ** -make_symbol_overload_list (struct symbol *fsym) -{ - register struct symbol *sym; - register struct symtab *s; - register struct partial_symtab *ps; - register struct objfile *objfile; - register struct block *b, *surrounding_static_block = 0; - register int i; - /* The name we are completing on. */ - char *oload_name = NULL; - /* Length of name. */ - int oload_name_len = 0; - - /* Look for the symbol we are supposed to complete on. */ - - oload_name = remove_params (SYMBOL_DEMANGLED_NAME (fsym)); - if (!oload_name) - { - sym_return_val_size = 1; - sym_return_val = (struct symbol **) xmalloc (2 * sizeof (struct symbol *)); - sym_return_val[0] = fsym; - sym_return_val[1] = NULL; - - return sym_return_val; - } - oload_name_len = strlen (oload_name); - - sym_return_val_size = 100; - sym_return_val_index = 0; - sym_return_val = (struct symbol **) xmalloc ((sym_return_val_size + 1) * sizeof (struct symbol *)); - sym_return_val[0] = NULL; - - /* Read in all partial symtabs containing a partial symbol named - OLOAD_NAME. */ - - ALL_PSYMTABS (objfile, ps) - { - struct partial_symbol **psym; - - /* If the psymtab's been read in we'll get it when we search - through the blockvector. */ - if (ps->readin) - continue; - - if ((lookup_partial_symbol (ps, oload_name, NULL, 1, VAR_NAMESPACE) - != NULL) - || (lookup_partial_symbol (ps, oload_name, NULL, 0, VAR_NAMESPACE) - != NULL)) - PSYMTAB_TO_SYMTAB (ps); - } - - /* Search upwards from currently selected frame (so that we can - complete on local vars. */ - - for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b)) - { - if (!BLOCK_SUPERBLOCK (b)) - { - surrounding_static_block = b; /* For elimination of dups */ - } - - /* Also catch fields of types defined in this places which match our - text string. Only complete on types visible from current context. */ - - ALL_BLOCK_SYMBOLS (b, i, sym) - { - overload_list_add_symbol (sym, oload_name); - } - } - - /* Go through the symtabs and check the externs and statics for - symbols which match. */ - - ALL_SYMTABS (objfile, s) - { - QUIT; - b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, sym) - { - overload_list_add_symbol (sym, oload_name); - } - } - - ALL_SYMTABS (objfile, s) - { - QUIT; - b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); - /* Don't do this block twice. */ - if (b == surrounding_static_block) - continue; - ALL_BLOCK_SYMBOLS (b, i, sym) - { - overload_list_add_symbol (sym, oload_name); - } - } - - xfree (oload_name); - - return (sym_return_val); -} - -/* End of overload resolution functions */ struct symtabs_and_lines decode_line_spec (char *string, int funfirstline)