From mboxrd@z Thu Jan 1 00:00:00 1970 From: Michael Snyder To: Jimmy Guo Cc: gdb-patches@sourceware.cygnus.com Subject: Re: (patch) hpjyg20: symtab.c & related Date: Thu, 11 Nov 1999 12:27:00 -0000 Message-id: <382B250C.5DD4@cygnus.com> References: X-SW-Source: 1999-q4/msg00232.html Jimmy Guo wrote: > > *** > Patch dependecies: hpjyg05 (config/pa/tm-hppa.h) > hpjyg16 (symtab.c,source.c) > hpjyg19 (breakpoint.c) > *** > > This patch contains various changes to symtab.c, mainly: > > - introduction of multiple functions handling in decode_line_1 > (i.e. overloaded C++ funcs or file static C functions) > > - addition of codes ifdef'd by FAT_FREE_PSYMTABS to rely on linker > symbol table entries to determine which translation unit's partial > symbol table must be expanded. Here is a more complete overview of > this feature: This patch is huge, and these two changes are unrelated. Could you please submit them separately? Michael >From guo@cup.hp.com Thu Nov 11 12:45:00 1999 From: Jimmy Guo To: Michael Snyder Cc: gdb-patches@sourceware.cygnus.com Subject: revision: (patch) hpjyg20: symtab.c & related Date: Thu, 11 Nov 1999 12:45:00 -0000 Message-id: References: <382B250C.5DD4@cygnus.com> X-SW-Source: 1999-q4/msg00233.html Content-length: 129177 >This patch is huge, and these two changes are unrelated. >Could you please submit them separately? Sure. Here it is for the part without FAT_FREE_PSYMTABS. *** Patch dependecies: hpjyg16 (symtab.c,source.c) hpjyg19 (breakpoint.c) *** This patch contains various changes to symtab.c, mainly: - introduction of multiple functions handling in decode_line_1 (i.e. overloaded C++ funcs or file static C functions) - addition of the notion of language case sensitivity to support debugging Fortran which is case insensitive ... a new pair of GDB commands is introduced here: set/show case-sensitive (on/off). ChangeLog: 1999-11-11 Jimmy Guo * symtab.c: Add support for breakpoint menu of multiple (overloaded or file static) functions. (lookup_symtab_1): Replace use of goto with a 2-iteration loop. (lookup_partial_symtab): Try lookup without filename extensions if still not found. (lookup_symbol): Add case sensitivity handling. (lookup_transparent_type): Add handling of the case where the same block hasboth a complete and an opaque version of a type. (lookup_block_transparent_type): New function. (find_pc_sect_symtab): If pc is 0 just return NULL. (find_pc_symtab): Ditto. (find_pc_sect_line): Detect bogus line number by checking if the function enclosing val.pc ends before pc (e.g. when the function has no line number info, say compiler generated functions). (find_line_symtab): Fallback to psymtab if not found. (decode_line_1): Add resolve argument (USER_CHOICE or ALL_SYMBOLS) to control how multiple matches for a symbol are resolved; set values.nelts to 0 to flag error to the caller; fallback to minimal symbol table to handle the case when the file containing the symbol have no debug info; look for multiple overloads (C++) or static (C) defintions of the function symbol found (ifdef GDB_TARGET_IS_HPPA). (decode_line_2): Add resolve argument, handle multiple matches for a function. (find_n_block_functions,find_functions,find_functions_in_symtab): New functions. (cplusplus_hint): Removed. * symtab.h: Enable BYTE_FIELD definition for HP C compiler. (namespace_enum): Add VAR_OR_STRUCT_NAMESPACE entry. (DESTRUCTOR_PREFIX_P): Recognize HP aCC destructors. (how_to_resolve_multiple_symbols enum): Define. (decode_line_1): Add resolve argument. * language.c: Add case sensitivity support and set/show case-sensitive command. * language.h (case_mode,case_sensitivity): Define. (language_defn struct): Add la_case_sensitivity field. * c-lang.c,ch-lang.c,f-lang.c,jv-lang.c,m2-lang.c,scm-lang.c: Add case sensitivity enum to language definition vector. * breakpoint.c: Adjust decode_line_1() calls to include resolve argument. (break_at_finish_command): Check error return of decode_line_1 and call error(). (clear_command): Check error return of decode_line_spec and call error(). * source.c,tracepoint.c: Adjust decode_line_1() calls to include resolve argument. Index: gdb/symtab.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/symtab.c gdb/symtab.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/symtab.c Thu Nov 4 10:49:29 1999 --- gdb/symtab.c Thu Nov 11 12:35:58 1999 *************** *** 44,49 **** --- 44,59 ---- #include "gdb_stat.h" #include + /* To support breakpoint menus for multiple defintions (overloaded or + file-static) functions */ + #define MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS 20 + + struct symtab_and_block + { + struct symtab *symtab; + int block_number; + }; + /* Prototype for one function in parser-defs.h, instead of including that entire file. */ *************** *** 53,66 **** static int find_methods PARAMS ((struct type *, char *, struct symbol **)); static void completion_list_add_name PARAMS ((char *, char *, int, char *, char *)); static void build_canonical_line_spec PARAMS ((struct symtab_and_line *, char *, char ***)); ! static struct symtabs_and_lines decode_line_2 PARAMS ((struct symbol *[], ! int, int, char ***)); static void rbreak_command PARAMS ((char *, int)); --- 63,88 ---- static int find_methods PARAMS ((struct type *, char *, struct symbol **)); + static int + find_n_block_functions PARAMS ((struct block *, char *, namespace_enum, + int, struct symbol **, int)); + + static int + find_functions PARAMS ((char *, struct symbol **, + struct symtab_and_block *)); + + static int + find_functions_in_symtab PARAMS ((char *, struct symbol **, + struct symtab_and_block *, struct symtab *)); + static void completion_list_add_name PARAMS ((char *, char *, int, char *, char *)); static void build_canonical_line_spec PARAMS ((struct symtab_and_line *, char *, char ***)); ! static struct symtabs_and_lines ! decode_line_2 PARAMS ((struct symbol *[], int, int, char ***, struct symtab_and_block[], enum how_to_resolve_multiple_symbols)); static void rbreak_command PARAMS ((char *, int)); *************** *** 87,93 **** static struct symtab *lookup_symtab_1 PARAMS ((char *)); ! static void cplusplus_hint PARAMS ((char *)); static struct symbol *find_active_alias PARAMS ((struct symbol * sym, CORE_ADDR addr)); --- 109,116 ---- static struct symtab *lookup_symtab_1 PARAMS ((char *)); ! struct symbol *lookup_block_transparent_type ! PARAMS ((const struct block *, const char *)); static struct symbol *find_active_alias PARAMS ((struct symbol * sym, CORE_ADDR addr)); *************** *** 129,148 **** char *default_main = "main"; - /* While the C++ support is still in flux, issue a possibly helpful hint on - using the new command completion feature on single quoted demangled C++ - symbols. Remove when loose ends are cleaned up. FIXME -fnf */ - - static void - cplusplus_hint (name) - char *name; - { - while (*name == '\'') - name++; - printf_filtered ("Hint: try '%s or '%s\n", name, name); - printf_filtered ("(Note leading single quote.)\n"); - } - /* Check for a symtab of a specific name; first in symtabs, then in psymtabs. *If* there is no '/' in the name, a match after a '/' in the symtab filename will also work. */ --- 152,157 ---- *************** *** 155,211 **** register struct partial_symtab *ps; register char *slash; register struct objfile *objfile; ! got_symtab: ! /* First, search for an exact match */ ! ALL_SYMTABS (objfile, s) ! if (STREQ (name, s->filename)) ! return s; ! slash = strchr (name, '/'); ! /* Now, search for a matching tail (only if name doesn't have any dirs) */ ! if (!slash) ! ALL_SYMTABS (objfile, s) ! { ! char *p = s->filename; ! char *tail = strrchr (p, '/'); ! if (tail) ! p = tail + 1; ! if (STREQ (p, name)) ! return s; ! } ! /* Same search rules as above apply here, but now we look thru the ! psymtabs. */ ! ps = lookup_partial_symtab (name); ! if (!ps) ! return (NULL); ! ! if (ps->readin) ! error ("Internal: readin %s pst for `%s' found when no symtab found.", ! ps->filename, name); ! s = PSYMTAB_TO_SYMTAB (ps); ! if (s) ! return s; ! /* At this point, we have located the psymtab for this file, but ! the conversion to a symtab has failed. This usually happens ! when we are looking up an include file. In this case, ! PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has ! been created. So, we need to run through the symtabs again in ! order to find the file. ! XXX - This is a crock, and should be fixed inside of the the ! symbol parsing routines. */ ! goto got_symtab; } /* Lookup the symbol table of a source file named NAME. Try a couple --- 164,224 ---- register struct partial_symtab *ps; register char *slash; register struct objfile *objfile; + int i; ! for (i = 0; i < 2; i++) ! { ! /* First, search for an exact match */ ! ALL_SYMTABS (objfile, s) ! if (STREQ (name, s->filename)) ! return s; ! slash = strchr (name, '/'); ! /* Now, search for a matching tail (only if name doesn't have any dirs) */ ! if (!slash) ! { ! ALL_SYMTABS (objfile, s) ! { ! char *p = s->filename; ! char *tail = strrchr (p, '/'); ! if (tail) ! p = tail + 1; ! if (STREQ (p, name)) ! return s; ! } ! } ! /* Same search rules as above apply here, but now we look thru the ! psymtabs. */ ! ps = lookup_partial_symtab (name); ! if (!ps) ! return (NULL); ! if (ps->readin) ! error ("Internal: readin %s pst for `%s' found when no symtab found.", ! ps->filename, name); ! s = PSYMTAB_TO_SYMTAB (ps); ! if (s) ! return s; ! /* At this point, we have located the psymtab for this file, but ! the conversion to a symtab has failed. This usually happens ! when we are looking up an include file. In this case, ! PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has ! been created. So, we need to run through the symtabs again in ! order to find the file. ! XXX - This is a crock, and should be fixed inside of the the ! symbol parsing routines. */ ! } ! return NULL; } /* Lookup the symbol table of a source file named NAME. Try a couple *************** *** 216,246 **** char *name; { register struct symtab *s; - #if 0 - register char *copy; - #endif s = lookup_symtab_1 (name); if (s) return s; - #if 0 - /* This screws c-exp.y:yylex if there is both a type "tree" and a symtab - "tree.c". */ - - /* If name not found as specified, see if adding ".c" helps. */ - /* Why is this? Is it just a user convenience? (If so, it's pretty - questionable in the presence of C++, FORTRAN, etc.). It's not in - the GDB manual. */ - - copy = (char *) alloca (strlen (name) + 3); - strcpy (copy, name); - strcat (copy, ".c"); - s = lookup_symtab_1 (copy); - if (s) - return s; - #endif /* 0 */ - /* We didn't find anything; die. */ return 0; } --- 229,239 ---- *************** *** 255,260 **** --- 248,254 ---- { register struct partial_symtab *pst; register struct objfile *objfile; + char *basename, *tail, *p; ALL_PSYMTABS (objfile, pst) { *************** *** 279,284 **** --- 273,310 ---- return (pst); } + /* RM: DOOM on 10.20 causes psymtabs to have filenames without + extensions. Try these too */ + basename = alloca (strlen (name) + 1); + strcpy (basename, name); + p = strrchr (basename, '.'); + if (p) + { + *p = 0; + + ALL_PSYMTABS (objfile, pst) + { + if (STREQ (basename, pst->filename)) + { + return (pst); + } + } + + /* Now, search for a matching tail (only if name doesn't have any dirs) */ + if (!strchr (basename, '/')) + ALL_PSYMTABS (objfile, pst) + { + p = pst->filename; + tail = strrchr (p, '/'); + + if (tail) + p = tail + 1; + + if (STREQ (p, basename)) + return (pst); + } + } + return (NULL); } *************** *** 422,427 **** --- 448,454 ---- struct partial_symbol *p; p = find_pc_sect_psymbol (tpst, pc, section); + if (p != NULL && SYMBOL_VALUE_ADDRESS (p) == SYMBOL_VALUE_ADDRESS (msymbol)) *************** *** 473,480 **** pp++) { p = *pp; ! if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE ! && SYMBOL_CLASS (p) == LOC_BLOCK && pc >= SYMBOL_VALUE_ADDRESS (p) && (SYMBOL_VALUE_ADDRESS (p) > best_pc || (psymtab->textlow == 0 --- 500,508 ---- pp++) { p = *pp; ! /* No problemo, fuzzy namespace & LOC_BLOCK don't go together */ ! if (PSYMBOL_NAMESPACE (p) == VAR_NAMESPACE ! && PSYMBOL_CLASS (p) == LOC_BLOCK && pc >= SYMBOL_VALUE_ADDRESS (p) && (SYMBOL_VALUE_ADDRESS (p) > best_pc || (psymtab->textlow == 0 *************** *** 497,504 **** pp++) { p = *pp; ! if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE ! && SYMBOL_CLASS (p) == LOC_BLOCK && pc >= SYMBOL_VALUE_ADDRESS (p) && (SYMBOL_VALUE_ADDRESS (p) > best_pc || (psymtab->textlow == 0 --- 525,533 ---- pp++) { p = *pp; ! /* No problemo, fuzzy namespace & LOC_BLOCK don't go together */ ! if (PSYMBOL_NAMESPACE (p) == VAR_NAMESPACE ! && PSYMBOL_CLASS (p) == LOC_BLOCK && pc >= SYMBOL_VALUE_ADDRESS (p) && (SYMBOL_VALUE_ADDRESS (p) > best_pc || (psymtab->textlow == 0 *************** *** 609,623 **** register struct symtab *s = NULL; register struct partial_symtab *ps; struct blockvector *bv; ! register struct objfile *objfile = NULL; register struct block *b; register struct minimal_symbol *msymbol; /* Search specified block and its superiors. */ while (block != 0) { ! sym = lookup_block_symbol (block, name, namespace); if (sym) { block_found = block; --- 638,671 ---- register struct symtab *s = NULL; register struct partial_symtab *ps; struct blockvector *bv; ! register struct objfile *objfile = NULL, *objfile2 = NULL; register struct block *b; register struct minimal_symbol *msymbol; + int do_internal_error_at_end = 0; + char *internal_error_str1 = NULL; + char *internal_error_str2 = NULL; + + extern enum case_sensitivity_type case_sensitivity; + char *copy; + int copy_name_len, i; + + copy_name_len = strlen (name); + copy = (char *) xmalloc (copy_name_len + 1); + if (case_sensitivity == case_sensitive_on) + strcpy (copy, name); + else + { + for (i = 0; i < copy_name_len; i++) + copy[i] = tolower (name[i]); + copy[i] = 0; + } + /* Search specified block and its superiors. */ while (block != 0) { ! sym = lookup_block_symbol (block, copy, namespace); if (sym) { block_found = block; *************** *** 670,676 **** if (BLOCK_START (b) <= BLOCK_START (block) && BLOCK_END (b) > BLOCK_START (block)) { ! sym = lookup_block_symbol (b, name, VAR_NAMESPACE); if (sym) { block_found = b; --- 718,724 ---- if (BLOCK_START (b) <= BLOCK_START (block) && BLOCK_END (b) > BLOCK_START (block)) { ! sym = lookup_block_symbol (b, copy, VAR_NAMESPACE); if (sym) { block_found = b; *************** *** 690,696 **** struct value *v = value_of_this (0); *is_a_field_of_this = 0; ! if (v && check_field (v, name)) { *is_a_field_of_this = 1; if (symtab != NULL) --- 738,744 ---- struct value *v = value_of_this (0); *is_a_field_of_this = 0; ! if (v && check_field (v, copy)) { *is_a_field_of_this = 1; if (symtab != NULL) *************** *** 708,714 **** { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, name, namespace); if (sym) { block_found = block; --- 756,762 ---- { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, copy, namespace); if (sym) { block_found = block; *************** *** 726,732 **** if (namespace == VAR_NAMESPACE) { ! msymbol = lookup_minimal_symbol (name, NULL, NULL); if (msymbol != NULL) { s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol), --- 774,780 ---- if (namespace == VAR_NAMESPACE) { ! msymbol = lookup_minimal_symbol (copy, NULL, NULL); if (msymbol != NULL) { s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol), *************** *** 766,772 **** } else if (MSYMBOL_TYPE (msymbol) != mst_text && MSYMBOL_TYPE (msymbol) != mst_file_text ! && !STREQ (name, SYMBOL_NAME (msymbol))) { /* This is a mangled variable, look it up by its mangled name. */ --- 814,820 ---- } else if (MSYMBOL_TYPE (msymbol) != mst_text && MSYMBOL_TYPE (msymbol) != mst_file_text ! && !STREQ (copy, SYMBOL_NAME (msymbol))) { /* This is a mangled variable, look it up by its mangled name. */ *************** *** 783,794 **** ALL_PSYMTABS (objfile, ps) { ! if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace)) { s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, name, namespace); if (!sym) { /* This shouldn't be necessary, but as a last resort --- 831,842 ---- ALL_PSYMTABS (objfile, ps) { ! if (!ps->readin && lookup_partial_symbol (ps, copy, 1, namespace)) { s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, copy, namespace); if (!sym) { /* This shouldn't be necessary, but as a last resort *************** *** 797,808 **** * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, name, namespace); 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\ ! (if a template, try specifying an instantiation: %s).", ! name, ps->filename, name, name); } if (symtab != NULL) *symtab = s; --- 845,886 ---- * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, copy, namespace); if (!sym) ! if (ps->symtab == NULL) ! { ! /* CM: This means that the symtab could not be created for ! some reason. Instead of dying, just continue with the ! search */ ! continue; ! } ! else ! { ! /* CM: Look through all of the symtabs again just in case ! expanding out this psymtab introduced additional entries ! in other symtabs. This can happen in HP's version of ! template instantiation (CTTI). */ ! ALL_SYMTABS (objfile2, s) ! { ! bv = BLOCKVECTOR (s); ! block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, copy, namespace); ! if (sym) ! { ! block_found = block; ! if (symtab != NULL) ! *symtab = s; ! return fixup_symbol_section (sym, objfile2); ! } ! } ! /* CM: Check other psymtabs just in case this is defined ! elsewhere. Give an error at the end of this function if ! a match was not found. */ ! do_internal_error_at_end = 1; ! internal_error_str1 = "global"; ! internal_error_str2 = ps->filename; ! continue; ! } } if (symtab != NULL) *symtab = s; *************** *** 821,827 **** { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, name, namespace); if (sym) { block_found = block; --- 899,905 ---- { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, copy, namespace); if (sym) { block_found = block; *************** *** 833,844 **** ALL_PSYMTABS (objfile, ps) { ! if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace)) { s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, name, namespace); if (!sym) { /* This shouldn't be necessary, but as a last resort --- 911,922 ---- ALL_PSYMTABS (objfile, ps) { ! if (!ps->readin && lookup_partial_symbol (ps, copy, 0, namespace)) { s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, copy, namespace); if (!sym) { /* This shouldn't be necessary, but as a last resort *************** *** 847,858 **** * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, name, namespace); 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\ ! (if a template, try specifying an instantiation: %s).", ! name, ps->filename, name, name); } if (symtab != NULL) *symtab = s; --- 925,966 ---- * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, copy, namespace); if (!sym) ! if (ps->symtab == NULL) ! { ! /* CM: This means that the symtab could not be created for ! some reason. Instead of dying, just continue with the ! search */ ! continue; ! } ! else ! { ! /* CM: Look through all of the symtabs again just in case ! expanding out this psymtab introduced additional entries ! in other symtabs. This can happen in HP's version of ! template instantiation (CTTI). */ ! ALL_SYMTABS (objfile2, s) ! { ! bv = BLOCKVECTOR (s); ! block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, copy, namespace); ! if (sym) ! { ! block_found = block; ! if (symtab != NULL) ! *symtab = s; ! return fixup_symbol_section (sym, objfile2); ! } ! } ! /* CM: Check other psymtabs just in case this is defined ! elsewhere. Give an error at the end of this function if ! a match was not found. */ ! do_internal_error_at_end = 1; ! internal_error_str1 = "static"; ! internal_error_str2 = ps->filename; ! continue; ! } } if (symtab != NULL) *symtab = s; *************** *** 879,885 **** if (namespace == VAR_NAMESPACE) { ! msymbol = lookup_minimal_symbol (name, NULL, NULL); if (msymbol != NULL) { /* OK, we found a minimal symbol in spite of not --- 987,993 ---- if (namespace == VAR_NAMESPACE) { ! msymbol = lookup_minimal_symbol (copy, NULL, NULL); if (msymbol != NULL) { /* OK, we found a minimal symbol in spite of not *************** *** 946,952 **** */ else if (MSYMBOL_TYPE (msymbol) != mst_text && MSYMBOL_TYPE (msymbol) != mst_file_text ! && !STREQ (name, SYMBOL_NAME (msymbol))) { return lookup_symbol (SYMBOL_NAME (msymbol), block, namespace, is_a_field_of_this, symtab); --- 1054,1060 ---- */ else if (MSYMBOL_TYPE (msymbol) != mst_text && MSYMBOL_TYPE (msymbol) != mst_file_text ! && !STREQ (copy, SYMBOL_NAME (msymbol))) { return lookup_symbol (SYMBOL_NAME (msymbol), block, namespace, is_a_field_of_this, symtab); *************** *** 956,961 **** --- 1064,1075 ---- #endif + + if (do_internal_error_at_end) + { + 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).", internal_error_str1, name, internal_error_str2, name, name); + } + if (symtab != NULL) *symtab = NULL; return 0; *************** *** 987,994 **** if (global) /* This means we can use a binary search. */ { - do_linear_search = 0; - /* Binary search. This search is guaranteed to end with center pointing at the earliest partial symbol with the correct name. At that point *all* partial symbols with that name --- 1101,1106 ---- *************** *** 996,1001 **** --- 1108,1119 ---- bottom = start; top = start + length - 1; + + do_linear_search = (top == bottom && + (SYMBOL_LANGUAGE (*top) == language_cplus || + SYMBOL_LANGUAGE (*top) == language_fortran || + SYMBOL_LANGUAGE (*top) == language_java)) ? 1 : 0; + while (top > bottom) { center = bottom + (top - bottom) / 2; *************** *** 1003,1008 **** --- 1121,1127 ---- abort (); if (!do_linear_search && (SYMBOL_LANGUAGE (*center) == language_cplus + || SYMBOL_LANGUAGE (*center) == language_fortran || SYMBOL_LANGUAGE (*center) == language_java )) { *************** *** 1021,1027 **** abort (); while (STREQ (SYMBOL_NAME (*top), name)) { ! if (SYMBOL_NAMESPACE (*top) == namespace) { return (*top); } --- 1140,1154 ---- abort (); while (STREQ (SYMBOL_NAME (*top), name)) { ! /* do a fuzzy match */ ! namespace_enum nm = PSYMBOL_NAMESPACE (*top); ! if ((nm == VAR_OR_STRUCT_NAMESPACE) && ! (namespace == STRUCT_NAMESPACE || ! namespace == VAR_NAMESPACE)) ! { ! return (*top); ! } ! if (PSYMBOL_NAMESPACE (*top) == namespace) { return (*top); } *************** *** 1036,1042 **** { for (psym = start; psym < start + length; psym++) { ! if (namespace == SYMBOL_NAMESPACE (*psym)) { if (SYMBOL_MATCHES_NAME (*psym, name)) { --- 1163,1172 ---- { for (psym = start; psym < start + length; psym++) { ! if ((namespace == PSYMBOL_NAMESPACE (*psym)) || ! (PSYMBOL_NAMESPACE (*psym) == VAR_OR_STRUCT_NAMESPACE && ! (namespace == STRUCT_NAMESPACE || ! namespace == VAR_NAMESPACE))) { if (SYMBOL_MATCHES_NAME (*psym, name)) { *************** *** 1056,1061 **** --- 1186,1195 ---- 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. */ + /* RM: With HP's DOOM, it is possible that the same block has both a + * complete and an opaque version of a type. Fixed this routine to + * handle this + */ struct type * lookup_transparent_type (name) *************** *** 1065,1071 **** register struct symtab *s = NULL; register struct partial_symtab *ps; struct blockvector *bv; ! register struct objfile *objfile; register struct block *block; /* Now search all the global symbols. Do the symtab's first, then --- 1199,1205 ---- register struct symtab *s = NULL; register struct partial_symtab *ps; struct blockvector *bv; ! register struct objfile *objfile, *objfile2; register struct block *block; /* Now search all the global symbols. Do the symtab's first, then *************** *** 1077,1083 **** { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, name, STRUCT_NAMESPACE); if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) { return SYMBOL_TYPE (sym); --- 1211,1217 ---- { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_transparent_type (block, name); if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) { return SYMBOL_TYPE (sym); *************** *** 1091,1097 **** s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, name, STRUCT_NAMESPACE); if (!sym) { /* This shouldn't be necessary, but as a last resort --- 1225,1231 ---- s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_transparent_type (block, name); if (!sym) { /* This shouldn't be necessary, but as a last resort *************** *** 1100,1111 **** * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, name, STRUCT_NAMESPACE); 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\ ! (if a template, try specifying an instantiation: %s).", ! name, ps->filename, name, name); } if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) return SYMBOL_TYPE (sym); --- 1234,1268 ---- * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_transparent_type (block, name); if (!sym) ! if (ps->symtab == NULL) ! { ! /* CM: This means that the symtab could not be created for ! some reason. Instead of dying, just continue with the ! search */ ! continue; ! } ! else ! { ! /* CM: Look through all of the symtabs again just in case ! expanding out this psymtab introduced additional entries ! in other symtabs. This can happen in HP's version of ! template instantiation (CTTI). */ ! ALL_SYMTABS (objfile2, s) ! { ! bv = BLOCKVECTOR (s); ! block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_transparent_type (block, name); ! if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) ! { ! return SYMBOL_TYPE (sym); ! } ! } ! /* CM: Check other psymtabs just in case this is defined ! elsewhere. */ ! continue; ! } } if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) return SYMBOL_TYPE (sym); *************** *** 1124,1130 **** { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, name, STRUCT_NAMESPACE); if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) { return SYMBOL_TYPE (sym); --- 1281,1287 ---- { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_transparent_type (block, name); if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) { return SYMBOL_TYPE (sym); *************** *** 1138,1144 **** s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_symbol (block, name, STRUCT_NAMESPACE); if (!sym) { /* This shouldn't be necessary, but as a last resort --- 1295,1301 ---- s = PSYMTAB_TO_SYMTAB (ps); bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_transparent_type (block, name); if (!sym) { /* This shouldn't be necessary, but as a last resort *************** *** 1147,1163 **** * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_symbol (block, name, STRUCT_NAMESPACE); 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\ ! (if a template, try specifying an instantiation: %s).", ! name, ps->filename, name, name); } if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) return SYMBOL_TYPE (sym); } } return (struct type *) 0; } --- 1304,1349 ---- * the psymtab gets it wrong in some cases. */ block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! sym = lookup_block_transparent_type (block, name); if (!sym) ! if (ps->symtab == NULL) ! { ! /* CM: This means that the symtab could not be created for ! some reason. Instead of dying, just continue with the ! search */ ! continue; ! } ! else ! { ! /* CM: Look through all of the symtabs again just in case ! expanding out this psymtab introduced additional entries ! in other symtabs. This can happen in HP's version of ! template instantiation (CTTI). */ ! ALL_SYMTABS (objfile2, s) ! { ! bv = BLOCKVECTOR (s); ! block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! sym = lookup_block_transparent_type (block, name); ! if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) ! { ! return SYMBOL_TYPE (sym); ! } ! } ! /* CM: Check other psymtabs just in case this is defined ! elsewhere. */ ! continue; ! } } if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) return SYMBOL_TYPE (sym); } } + + /* RM: We _don't_ want to give error just because we found a type in a + psymtab, and didn't find the corresponding _transparent_ type in the + symtab (or any of the symtabs). It doesn't mean that we are in error: + the transparent type might be in a file without debug information. */ + return (struct type *) 0; } *************** *** 1171,1176 **** --- 1357,1363 ---- { register struct partial_symtab *pst; register struct objfile *objfile; + struct minimal_symbol *m; ALL_PSYMTABS (objfile, pst) { *************** *** 1179,1184 **** --- 1366,1372 ---- return (pst); } } + return (NULL); } *************** *** 1232,1237 **** --- 1420,1426 ---- sym = BLOCK_SYM (block, inc); if (!do_linear_search && (SYMBOL_LANGUAGE (sym) == language_cplus + || SYMBOL_LANGUAGE (sym) == language_fortran || SYMBOL_LANGUAGE (sym) == language_java )) { *************** *** 1379,1384 **** --- 1568,1703 ---- /* Nothing found, return the main symbol. */ return sym; } + + /* RM: Just like lookup_block_symbol, but looks for a transparent type + * -- i.e. opaque types don't make the cut for lookup. + */ + struct symbol * + lookup_block_transparent_type (block, name) + register const struct block *block; + const char *name; + { + register int bot, top, inc; + register struct symbol *sym; + register struct symbol *sym_found = NULL; + register int do_linear_search = 1; + + /* If the blocks's symbols were sorted, start with a binary search. */ + + if (BLOCK_SHOULD_SORT (block)) + { + /* 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, such as finding a C++ symbol during the binary search. + Note that for C++ modules, ALL the symbols in a block should + end up marked as C++ symbols. */ + + 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_cplus + || SYMBOL_LANGUAGE (sym) == language_fortran + || SYMBOL_LANGUAGE (sym) == language_java + )) + { + do_linear_search = 1; + } + if (SYMBOL_NAME (sym)[0] < name[0]) + { + bot = inc; + } + else if (SYMBOL_NAME (sym)[0] > name[0]) + { + top = inc; + } + else if (STRCMP (SYMBOL_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. + */ + /* RM: but first scan backwards, since we may be pointing to a + * section of symbols with the same name but different namespace + */ + while (bot > 0) + { + sym = BLOCK_SYM (block, bot - 1); + inc = SYMBOL_NAME (sym)[0] - name[0]; + if (inc == 0) + inc = STRCMP (SYMBOL_NAME (sym), name); + if (inc == 0) + bot--; + else + break; + } + + top = BLOCK_NSYMS (block); + while (bot < top) + { + sym = BLOCK_SYM (block, bot); + inc = SYMBOL_NAME (sym)[0] - name[0]; + if (inc == 0) + { + inc = STRCMP (SYMBOL_NAME (sym), name); + } + if ((inc == 0) && (SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE) && + (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))) + { + return (sym); + } + if (inc > 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 C++ symbol, then we have re-enabled the linear + search flag which was reset when starting the binary search. + */ + if (do_linear_search) + { + top = BLOCK_NSYMS (block); + bot = 0; + while (bot < top) + { + sym = BLOCK_SYM (block, bot); + if ((SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE) && + (SYMBOL_MATCHES_NAME (sym, name)) && + (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))) + { + sym_found = sym; + break; + } + bot++; + } + } + return (sym_found); /* Will be NULL if not found. */ + } /* Return the symbol for the function which contains a specified *************** *** 1410,1415 **** --- 1729,1744 ---- register struct objfile *objfile; CORE_ADDR distance = 0; + /* srikanth, 990325, beat it quick if pc == 0 as no program object can be + at this address. Currently we attempt to search for the psymbtab that + contains address 0 and as it happens the psymtab for the psuedo-file + `globals' has its textlow and texthigh set to zero causing the entire + global symbol table to be read in. This takes forever ... (yawn) + */ + + if (pc == 0) + return NULL; + /* Search all symtabs for the one whose file contains our address, and which is the smallest of all the ones containing the address. This is designed to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000 *************** *** 1476,1485 **** /* 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. */ - /* FIXME-32x64: assumes pc fits in a long */ warning ("\ ! (Internal error: pc 0x%lx in read in psymtab, but not in symtab.)\n", ! (unsigned long) pc); s = PSYMTAB_TO_SYMTAB (ps); } return (s); --- 1805,1813 ---- /* 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 %s in read in psymtab, but not in symtab.)\n", ! longest_local_hex_string ((LONGEST) pc)); s = PSYMTAB_TO_SYMTAB (ps); } return (s); *************** *** 1492,1601 **** find_pc_symtab (pc) CORE_ADDR pc; { return find_pc_sect_symtab (pc, find_pc_mapped_section (pc)); } ! #if 0 ! ! /* Find the closest symbol value (of any sort -- function or variable) ! for a given address value. Slow but complete. (currently unused, ! mainly because it is too slow. We could fix it if each symtab and ! psymtab had contained in it the addresses ranges of each of its ! sections, which also would be required to make things like "info ! line *0x2345" cause psymtabs to be converted to symtabs). */ ! ! struct symbol * ! find_addr_symbol (addr, symtabp, symaddrp) ! CORE_ADDR addr; ! struct symtab **symtabp; ! CORE_ADDR *symaddrp; ! { ! struct symtab *symtab, *best_symtab; ! struct objfile *objfile; ! register int bot, top; ! register struct symbol *sym; ! register CORE_ADDR sym_addr; ! struct block *block; ! int blocknum; ! ! /* Info on best symbol seen so far */ ! ! register CORE_ADDR best_sym_addr = 0; ! struct symbol *best_sym = 0; ! ! /* FIXME -- we should pull in all the psymtabs, too! */ ! ALL_SYMTABS (objfile, symtab) ! { ! /* Search the global and static blocks in this symtab for ! the closest symbol-address to the desired address. */ ! ! for (blocknum = GLOBAL_BLOCK; blocknum <= STATIC_BLOCK; blocknum++) ! { ! QUIT; ! block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), blocknum); ! top = BLOCK_NSYMS (block); ! for (bot = 0; bot < top; bot++) ! { ! sym = BLOCK_SYM (block, bot); ! switch (SYMBOL_CLASS (sym)) ! { ! case LOC_STATIC: ! case LOC_LABEL: ! sym_addr = SYMBOL_VALUE_ADDRESS (sym); ! break; ! ! case LOC_INDIRECT: ! sym_addr = SYMBOL_VALUE_ADDRESS (sym); ! /* An indirect symbol really lives at *sym_addr, ! * so an indirection needs to be done. ! * However, I am leaving this commented out because it's ! * expensive, and it's possible that symbolization ! * could be done without an active process (in ! * case this read_memory will fail). RT ! sym_addr = read_memory_unsigned_integer ! (sym_addr, TARGET_PTR_BIT / TARGET_CHAR_BIT); ! */ ! break; ! ! case LOC_BLOCK: ! sym_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); ! break; ! ! default: ! continue; ! } ! ! if (sym_addr <= addr) ! if (sym_addr > best_sym_addr) ! { ! /* Quit if we found an exact match. */ ! best_sym = sym; ! best_sym_addr = sym_addr; ! best_symtab = symtab; ! if (sym_addr == addr) ! goto done; ! } ! } ! } ! } ! ! done: ! if (symtabp) ! *symtabp = best_symtab; ! if (symaddrp) ! *symaddrp = best_sym_addr; ! return best_sym; ! } ! #endif /* 0 */ ! ! /* Find the source file and line number for a given PC value and section. ! Return a structure containing a symtab pointer, a line number, ! and a pc range for the entire source line. ! The value's .pc field is NOT the specified pc. ! NOTCURRENT nonzero means, if specified pc is on a line boundary, ! use the line that ends there. Otherwise, in that case, the line ! that begins there is used. */ /* The big complication here is that a line may start in one file, and end just before the start of another file. This usually occurs when you #include --- 1820,1842 ---- find_pc_symtab (pc) CORE_ADDR pc; { + + if (pc == 0) + { + return NULL; + } + return find_pc_sect_symtab (pc, find_pc_mapped_section (pc)); } ! /* Find the source file and line number for a given PC value and section. ! Return a structure containing a symtab pointer, a line number, ! and a pc range for the entire source line. ! The value's .pc field is NOT the specified pc. ! NOTCURRENT nonzero means, if specified pc is on a line boundary, ! use the line that ends there. Otherwise, in that case, the line ! that begins there is used. */ /* The big complication here is that a line may start in one file, and end just before the start of another file. This usually occurs when you #include *************** *** 1621,1626 **** --- 1862,1868 ---- struct blockvector *bv; struct minimal_symbol *msymbol; struct minimal_symbol *mfunsym; + struct symbol *func; /* Info on best line seen so far, and where it starts, and its file. */ *************** *** 1825,1830 **** --- 2067,2087 ---- val.end = alt->pc; else val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); + /* RM: If the function enclosing val.pc ends before pc, then the + * line number was probably bogus -- this can happen if the function + * enclosing pc has no line number information, as is the case + * for compiler generated functions (constructors, for example). The + * line number we get back is the last line number of the preceding + * function in the text space, which is obviously incorrect. + */ + func = find_pc_function (val.pc); + if (func && + (BLOCK_END (SYMBOL_BLOCK_VALUE (func)) < pc)) + { + val.line = 0; + val.pc = 0; + val.symtab = 0; + } } val.section = section; return val; *************** *** 1895,1900 **** --- 2152,2161 ---- struct objfile *objfile; struct symtab *s; + struct partial_symtab *ps; + struct linetable *l; + int ind; + if (best_index >= 0) best = best_linetable->item[best_index].line; *************** *** 1903,1911 **** ALL_SYMTABS (objfile, s) { - struct linetable *l; - int ind; - if (!STREQ (symtab->filename, s->filename)) continue; l = LINETABLE (s); --- 2164,2169 ---- *************** *** 1928,1933 **** --- 2186,2228 ---- } } } + + /* Try the psymtabs if we haven't found it */ + ALL_PSYMTABS (objfile, ps) + { + if (!STREQ (symtab->filename, ps->filename)) + continue; + if (ps->readin) + continue; + s = PSYMTAB_TO_SYMTAB (ps); + + /* guo: (related to lookup_symtab_1() comments) + gdb core dumps w/ list.exp 'list list0.h:1' on Linux, at + the following 'l = LINETABLE (s)' statement. + Need to short-circuit this if psymtab_to_symtab returns NULL. */ + if (!s) + break; + + l = LINETABLE (s); + ind = find_line_common (l, line, &exact); + if (ind >= 0) + { + if (exact) + { + best_index = ind; + best_linetable = l; + best_symtab = s; + goto done; + } + if (best == 0 || l->item[ind].line < best) + { + best = l->item[ind].line; + best_index = ind; + best_linetable = l; + best_symtab = s; + } + } + } } done: if (best_index < 0) *************** *** 2233,2364 **** return 0; count = TYPE_NFN_FIELDS_TOTAL (type); ! for (n = 0; n < TYPE_N_BASECLASSES (type); n++) ! count += total_number_of_methods (TYPE_BASECLASS (type, n)); ! return count; } ! /* Recursive helper function for decode_line_1. ! Look for methods named NAME in type T. Return number of matches. Put matches in SYM_ARR, which should have been allocated with ! a size of total_number_of_methods (T) * sizeof (struct symbol *). ! Note that this function is g++ specific. */ ! static int ! find_methods (t, name, sym_arr) ! struct type *t; char *name; struct symbol **sym_arr; { int i1 = 0; ! int ibase; ! struct symbol *sym_class; ! char *class_name = type_name_no_tag (t); ! ! /* Ignore this class if it doesn't have a name. This is ugly, but ! unless we figure out how to get the physname without the name of ! the class, then the loop can't do any good. */ ! if (class_name ! && (sym_class = lookup_symbol (class_name, ! (struct block *) NULL, ! STRUCT_NAMESPACE, ! (int *) NULL, ! (struct symtab **) NULL))) ! { ! int method_counter; ! ! /* FIXME: Shouldn't this just be CHECK_TYPEDEF (t)? */ ! t = SYMBOL_TYPE (sym_class); ! /* Loop over each method name. At this level, all overloads of a name ! are counted as a single name. There is an inner loop which loops over ! each overload. */ ! for (method_counter = TYPE_NFN_FIELDS (t) - 1; ! method_counter >= 0; ! --method_counter) ! { ! int field_counter; ! char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter); ! char dem_opname[64]; ! if (strncmp (method_name, "__", 2) == 0 || ! strncmp (method_name, "op", 2) == 0 || ! strncmp (method_name, "type", 4) == 0) { ! if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI)) ! method_name = dem_opname; ! else if (cplus_demangle_opname (method_name, dem_opname, 0)) ! method_name = dem_opname; } - - if (STREQ (name, method_name)) - /* Find all the overloaded methods with that name. */ - for (field_counter = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1; - field_counter >= 0; - --field_counter) - { - struct fn_field *f; - char *phys_name; - - f = TYPE_FN_FIELDLIST1 (t, method_counter); - - if (TYPE_FN_FIELD_STUB (f, field_counter)) - { - char *tmp_name; - - tmp_name = gdb_mangle_name (t, - method_counter, - field_counter); - phys_name = alloca (strlen (tmp_name) + 1); - strcpy (phys_name, tmp_name); - free (tmp_name); - } - else - phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter); - - /* Destructor is handled by caller, dont add it to the list */ - if (DESTRUCTOR_PREFIX_P (phys_name)) - continue; - - sym_arr[i1] = lookup_symbol (phys_name, - NULL, VAR_NAMESPACE, - (int *) NULL, - (struct symtab **) NULL); - if (sym_arr[i1]) - i1++; - else - { - /* This error message gets printed, but the method - still seems to be found - fputs_filtered("(Cannot find method ", gdb_stdout); - fprintf_symbol_filtered (gdb_stdout, phys_name, - language_cplus, - DMGL_PARAMS | DMGL_ANSI); - fputs_filtered(" - possibly inlined.)\n", gdb_stdout); - */ - } - } } } ! ! /* Only search baseclasses if there is no match yet, since names in ! derived classes override those in baseclasses. ! ! FIXME: The above is not true; it is only true of member functions ! if they have the same number of arguments (??? - section 13.1 of the ! ARM says the function members are not in the same scope but doesn't ! really spell out the rules in a way I understand. In any case, if ! the number of arguments differ this is a case in which we can overload ! rather than hiding without any problem, and gcc 2.4.5 does overload ! rather than hiding in this case). */ ! ! if (i1 == 0) ! for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++) ! i1 += find_methods (TYPE_BASECLASS (t, ibase), name, sym_arr + i1); ! return i1; } --- 2528,3045 ---- return 0; count = TYPE_NFN_FIELDS_TOTAL (type); ! for (n = 0; n < TYPE_N_BASECLASSES (type); n++) ! count += total_number_of_methods (TYPE_BASECLASS (type, n)); ! ! return count; ! } ! ! /* Recursive helper function for decode_line_1. ! Look for methods named NAME in type T. ! Return number of matches. ! Put matches in SYM_ARR, which should have been allocated with ! a size of total_number_of_methods (T) * sizeof (struct symbol *). ! Note that this function is g++ specific. */ ! ! static int ! find_methods (t, name, sym_arr) ! struct type *t; ! char *name; ! struct symbol **sym_arr; ! { ! int i1 = 0; ! int ibase; ! struct symbol *sym_class; ! char *class_name = type_name_no_tag (t); ! ! /* Ignore this class if it doesn't have a name. This is ugly, but ! unless we figure out how to get the physname without the name of ! the class, then the loop can't do any good. */ ! if (class_name ! && (sym_class = lookup_symbol (class_name, ! (struct block *) NULL, ! STRUCT_NAMESPACE, ! (int *) NULL, ! (struct symtab **) NULL))) ! { ! int method_counter; ! ! /* FIXME: Shouldn't this just be CHECK_TYPEDEF (t)? */ ! t = SYMBOL_TYPE (sym_class); ! ! /* Loop over each method name. At this level, all overloads of a name ! are counted as a single name. There is an inner loop which loops over ! each overload. */ ! ! for (method_counter = TYPE_NFN_FIELDS (t) - 1; ! method_counter >= 0; ! --method_counter) ! { ! int field_counter; ! char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter); ! char dem_opname[64]; ! ! if (strncmp (method_name, "__", 2) == 0 || ! strncmp (method_name, "op", 2) == 0 || ! strncmp (method_name, "type", 4) == 0) ! { ! if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI)) ! method_name = dem_opname; ! else if (cplus_demangle_opname (method_name, dem_opname, 0)) ! method_name = dem_opname; ! } ! ! if (STREQ (name, method_name)) ! /* Find all the overloaded methods with that name. */ ! for (field_counter = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1; ! field_counter >= 0; ! --field_counter) ! { ! struct fn_field *f; ! char *phys_name; ! ! f = TYPE_FN_FIELDLIST1 (t, method_counter); ! ! if (TYPE_FN_FIELD_STUB (f, field_counter)) ! { ! char *tmp_name; ! ! tmp_name = gdb_mangle_name (t, ! method_counter, ! field_counter); ! phys_name = alloca (strlen (tmp_name) + 1); ! strcpy (phys_name, tmp_name); ! free (tmp_name); ! } ! else ! phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter); ! ! /* Destructor is handled by caller, dont add it to the list */ ! if (DESTRUCTOR_PREFIX_P (phys_name)) ! continue; ! ! sym_arr[i1] = lookup_symbol (phys_name, ! NULL, VAR_NAMESPACE, ! (int *) NULL, ! (struct symtab **) NULL); ! if (sym_arr[i1]) ! i1++; ! else ! { ! /* This error message gets printed, but the method ! still seems to be found ! fputs_filtered("(Cannot find method ", gdb_stdout); ! fprintf_symbol_filtered (gdb_stdout, phys_name, ! language_cplus, ! DMGL_PARAMS | DMGL_ANSI); ! fputs_filtered(" - possibly inlined.)\n", gdb_stdout); ! */ ! } ! } ! } ! } ! ! /* Only search baseclasses if there is no match yet, since names in ! derived classes override those in baseclasses. ! ! FIXME: The above is not true; it is only true of member functions ! if they have the same number of arguments (??? - section 13.1 of the ! ARM says the function members are not in the same scope but doesn't ! really spell out the rules in a way I understand. In any case, if ! the number of arguments differ this is a case in which we can overload ! rather than hiding without any problem, and gcc 2.4.5 does overload ! rather than hiding in this case). */ ! ! if (i1 == 0) ! for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++) ! i1 += find_methods (TYPE_BASECLASS (t, ibase), name, sym_arr + i1); ! ! return i1; ! } ! ! /* RM: Modified so that this function now returns only function ! symbols: all callers are only interested in functions, so this is ! the correct thing to do. ! ! Helper function for find_functions(). ! Find first N symbols in BLOCK matching symbol NAME in NAMESPACE; ! put the symbols found in SYM_ARR starting at postion PUT_AT. ! Avoid multiple instances of the 'same' symbol ( 'same' ness detected by ! a 'shallow' but fast equality test.) ! ! This function is based on lookup_block_symbol() but does not attempt ! a binary search. ! ! Each symbol which is marked as being a C++ ! symbol (language_cplus set) has both the encoded and non-encoded names ! tested for a match. */ ! ! int ! find_n_block_functions (block, name, namespace, n, sym_arr, put_at) ! struct block *block; ! char *name; ! namespace_enum namespace; ! int n; ! struct symbol **sym_arr; ! int put_at; ! { ! int i1 = 0; ! register int bot, top; ! register struct symbol *sym; ! int j = 0; ! ! top = BLOCK_NSYMS (block); ! bot = 0; ! while (bot < top) ! { ! sym = BLOCK_SYM (block, bot); ! if (SYMBOL_NAMESPACE (sym) == namespace && ! SYMBOL_CLASS (sym) == LOC_BLOCK && ! SYMBOL_MATCHES_NAME (sym, name)) ! { ! if (i1 == n) ! { ! /* Already found first 'n' symbols */ ! break; ! } ! /* Check if 'sym' is already in 'sym_arr[0]...sym_arr[put_at+i1-1]' */ ! /* One scenario this is needed is this: ! Prototype for foo() defined in 'foo.h'; foo() defined in ! 'foo.c' that includes 'foo.h'. Definition of foo() appears ! in the symtabs for both 'foo.h' and 'foo.c' ! */ ! for (j = 0; j < (put_at + i1); j++) ! { ! /* fast but shallow equality test first */ ! if (sym == sym_arr[j]) ! break; ! } ! if (j == (put_at + i1)) ! { /* not already present in sym_arr, put it */ ! sym_arr[put_at + i1] = sym; ! i1 = i1 + 1; ! } ! } ! bot++; ! } ! return (i1); ! } ! ! /* Helper function for decode_line_1. ! Look for functions named NAME in all the symbol tables. ! Return number of matches. ! Put matches in SYM_ARR, which should have been allocated with ! a size of MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS * ! sizeof (struct symbol *). ! Put the corresponding symtabs in SYMTAB_ARR, which should have been ! allocated with a size of ! MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS * ! sizeof (struct symtab *). ! */ ! ! /* This function is based on lookup_symbol() -- specialized with the ! value of formal parameter BLOCK as NULL, namespace as VAR_NAMESPACE, ! and IS_A_FIELD_OF_THIS as 0. ! Unlike lookup_symbol() this function does not quit after the first match. ! Unlike lookup_symbol() this function does not check for error conditions ! such as a discrepancy between partial_symtab and full_symtab. ! Unlike lookup_symbol() this function does not look for minimal ! symbols; the caller does that if this function returns 0. ! */ ! ! int ! find_functions (name, sym_arr, symtab_and_block_arr) ! char *name; ! struct symbol **sym_arr; ! struct symtab_and_block *symtab_and_block_arr; ! { ! int i1 = 0; ! int maxi1 = MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS; ! int n_found = 0; ! int lookup_terminated = 0; ! int k; ! register struct symtab *s = NULL; ! register struct partial_symtab *ps; ! struct blockvector *bv; ! register struct objfile *objfile; ! register struct block *block; ! namespace_enum namespace = VAR_NAMESPACE; ! ! /* Initialize sym_arr and symtab_and_block_arr */ ! for (k = 0; k < maxi1; k++) ! { ! symtab_and_block_arr[k].symtab = NULL; ! symtab_and_block_arr[k].block_number = -1; ! sym_arr[k] = NULL; ! } ! ! /* Look into the symbol table for the current source file first */ ! /* We look for both static and global definitions here to handle ! oveloaded C++ functions. ! */ ! s = current_source_symtab; ! if (s) ! { ! int b = 0; ! bv = BLOCKVECTOR (s); ! for (b = 0; b < 2; b++) ! { ! /* We do not want to rely on the #define of GLOBAL/STATIC_BLOCK ! here */ ! int block_no = (b == 0) ? GLOBAL_BLOCK : STATIC_BLOCK; ! block = BLOCKVECTOR_BLOCK (bv, block_no); ! n_found = 0; ! n_found = find_n_block_functions (block, name, namespace, maxi1 - i1, sym_arr, i1); ! if (n_found != 0) ! { ! block_found = block; ! for (k = 0; k < n_found; k++) ! { ! if ((i1 + k) == maxi1) ! break; ! symtab_and_block_arr[i1 + k].symtab = s; ! symtab_and_block_arr[i1 + k].block_number = block_no; ! } ! i1 += n_found; ! if (i1 == maxi1) ! { ! lookup_terminated = 1; ! goto lookup_over; ! } ! } ! } ! } ! /* If we found match(es) in the current source file we are done */ ! if (i1) ! goto lookup_over; ! ! /* 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) ! { ! bv = BLOCKVECTOR (s); ! block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! n_found = 0; ! n_found = find_n_block_functions (block, name, namespace, maxi1 - i1, sym_arr, i1); ! if (n_found != 0) ! { ! block_found = block; ! for (k = 0; k < n_found; k++) ! { ! if ((i1 + k) == maxi1) ! break; ! symtab_and_block_arr[i1 + k].symtab = s; ! symtab_and_block_arr[i1 + k].block_number = GLOBAL_BLOCK; ! } ! i1 += n_found; ! if (i1 == maxi1) ! { ! lookup_terminated = 1; ! goto lookup_over; ! } ! } ! } ! ! ALL_PSYMTABS (objfile, ps) ! { ! if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace)) ! { ! s = PSYMTAB_TO_SYMTAB (ps); ! bv = BLOCKVECTOR (s); ! block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); ! n_found = 0; ! n_found = find_n_block_functions (block, name, namespace, maxi1 - i1, sym_arr, i1); ! if (n_found != 0) ! { ! block_found = block; ! for (k = 0; k < n_found; k++) ! { ! if ((i1 + k) == maxi1) ! break; ! symtab_and_block_arr[i1 + k].symtab = s; ! symtab_and_block_arr[i1 + k].block_number = GLOBAL_BLOCK; ! } ! i1 += n_found; ! if (i1 == maxi1) ! { ! lookup_terminated = 1; ! goto lookup_over; ! } ! } ! } ! } ! /* If we found any matches in the globalsymbols we are done */ ! if (i1) ! goto lookup_over; ! ! /* Now search the static file-level symbols. ! Not strictly correct, but more useful than an error. ! Do the symtab's first, then ! check the psymtab's. If a psymtab indicates the existence ! of the desired name as a file-level static, then do psymtab-to-symtab ! conversion on the fly and return the found symbol. ! */ ! ALL_SYMTABS (objfile, s) ! { ! bv = BLOCKVECTOR (s); ! block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! n_found = 0; ! n_found = find_n_block_functions (block, name, namespace, maxi1 - i1, sym_arr, i1); ! if (n_found != 0) ! { ! block_found = block; ! for (k = 0; k < n_found; k++) ! { ! if (i1 + k == maxi1) ! break; ! symtab_and_block_arr[i1 + k].symtab = s; ! symtab_and_block_arr[i1 + k].block_number = STATIC_BLOCK; ! } ! i1 += n_found; ! if (i1 == maxi1) ! { ! lookup_terminated = 1; ! goto lookup_over; ! } ! } ! } ! ! ALL_PSYMTABS (objfile, ps) ! { ! if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace)) ! { ! s = PSYMTAB_TO_SYMTAB (ps); ! bv = BLOCKVECTOR (s); ! block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); ! n_found = 0; ! n_found = find_n_block_functions (block, name, namespace, maxi1 - i1, sym_arr, i1); ! if (n_found != 0) ! { ! block_found = block; ! for (k = 0; k < n_found; k++) ! { ! if (i1 + k == maxi1) ! break; ! symtab_and_block_arr[i1 + k].symtab = s; ! symtab_and_block_arr[i1 + k].block_number = STATIC_BLOCK; ! } ! i1 += n_found; ! if (i1 == maxi1) ! { ! lookup_terminated = 1; ! goto lookup_over; ! } ! } ! } ! } ! /* The caller (decode_line_1) will check for the possibility of the symbol ! being a function that is stored in one of the minimal symbol tables. ! The "minimal symbol table" is built from linker-supplied info. ! */ ! lookup_over: ! if (lookup_terminated) ! { ! warning ("\ ! (Only %d definitions of function %s matched; use \ ! 'info func %s' to find all the matching defintions.\n", maxi1, name, name); ! } ! return i1; } ! /* Helper function for decode_line_1. ! Look for functions named NAME in SYMTAB_IN. Return number of matches. Put matches in SYM_ARR, which should have been allocated with ! a size of MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS * ! sizeof (struct symbol *). ! Put the corresponding symtabs in SYMTAB_ARR, which should have been ! allocated with a size of ! MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS * ! sizeof (struct symtab *). ! */ ! /* This function is based on find_functions() ! Most of the comments above find_functions() apply here as well. ! */ ! ! int ! find_functions_in_symtab (name, sym_arr, symtab_and_block_arr, ! symtab_in) char *name; struct symbol **sym_arr; + struct symtab_and_block *symtab_and_block_arr; + struct symtab *symtab_in; { int i1 = 0; ! int maxi1 = MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS; ! int n_found = 0; ! int lookup_terminated = 0; ! int k; ! register struct symtab *s = NULL; ! struct blockvector *bv; ! register struct block *block; ! namespace_enum namespace = VAR_NAMESPACE; ! /* Initialize sym_arr and symtab_and_block_arr */ ! for (k = 0; k < maxi1; k++) ! { ! symtab_and_block_arr[k].symtab = NULL; ! symtab_and_block_arr[k].block_number = -1; ! sym_arr[k] = NULL; ! } ! /* We look for both static and global definitions here to handle ! oveloaded C++ functions. ! */ ! s = symtab_in; ! if (s) ! { ! int b = 0; ! bv = BLOCKVECTOR (s); ! for (b = 0; b < 2; b++) ! { ! /* We do not want to rely on the #define of GLOBAL/STATIC_BLOCK ! here */ ! int block_no = (b == 0) ? GLOBAL_BLOCK : STATIC_BLOCK; ! block = BLOCKVECTOR_BLOCK (bv, block_no); ! n_found = 0; ! n_found = find_n_block_functions (block, name, namespace, maxi1 - i1, sym_arr, i1); ! if (n_found != 0) { ! block_found = block; ! for (k = 0; k < n_found; k++) ! { ! if ((i1 + k) == maxi1) ! break; ! symtab_and_block_arr[i1 + k].symtab = s; ! symtab_and_block_arr[i1 + k].block_number = block_no; ! } ! i1 += n_found; ! if (i1 == maxi1) ! { ! lookup_terminated = 1; ! goto lookup_over; ! } } } } ! /* The caller (decode_line_1) will check for the possibility of the symbol ! being a function that is stored in one of the minimal symbol tables. ! The "minimal symbol table" is built from linker-supplied info. ! */ ! lookup_over: ! if (lookup_terminated) ! { ! warning ("\ ! (Only %d definitions of function %s matched; use \ ! 'info func %s' to find all the matching defintions.\n", maxi1, name, name); ! } return i1; } *************** *** 2435,2440 **** --- 3116,3126 ---- line spec. The array and the line spec strings are allocated on the heap, it is the callers responsibility to free them. + RESOLVE tells us what to do if we find more than one match for a + symbol. If it is set to USER_CHOICE, a menu is popped up for the + user to choose from. If it is set to ALL_SYMBOLS, all matching + symbols are returned. + Note that it is possible to return zero for the symtab if no file is validly specified. Callers must check that. Also, the line number returned may be invalid. */ *************** *** 2445,2456 **** can use as appropriate instead of make_symbol_completion_list. */ struct symtabs_and_lines ! decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical) char **argptr; int funfirstline; struct symtab *default_symtab; int default_line; char ***canonical; { struct symtabs_and_lines values; #ifdef HPPA_COMPILER_BUG --- 3131,3143 ---- can use as appropriate instead of make_symbol_completion_list. */ struct symtabs_and_lines ! decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical, resolve) char **argptr; int funfirstline; struct symtab *default_symtab; int default_line; char ***canonical; + enum how_to_resolve_multiple_symbols resolve; { struct symtabs_and_lines values; #ifdef HPPA_COMPILER_BUG *************** *** 2505,2512 **** int has_if = 0; int has_comma = 0; struct symbol **sym_arr; struct type *t; - char *saved_arg = *argptr; extern char *gdb_completer_quote_characters; INIT_SAL (&val); /* initialize to zeroes */ --- 3192,3199 ---- int has_if = 0; int has_comma = 0; struct symbol **sym_arr; + struct symtab_and_block *symtab_and_block_arr; struct type *t; extern char *gdb_completer_quote_characters; INIT_SAL (&val); /* initialize to zeroes */ *************** *** 2651,2657 **** /* ... or Java */ if (is_quoted) *argptr = *argptr + 1; ! if (p[0] == '.' || p[1] == ':') { char *saved_arg2 = *argptr; char *temp_end; --- 3338,3344 ---- /* ... or Java */ if (is_quoted) *argptr = *argptr + 1; ! if (strlen (p) > 1 && (p[0] == '.' || p[1] == ':')) { char *saved_arg2 = *argptr; char *temp_end; *************** *** 2720,2747 **** while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':') p++; } ! /* ! q = operator_chars (*argptr, &q1); ! if (q1 - q) ! { ! char *opname; ! char *tmp = alloca (q1 - q + 1); ! memcpy (tmp, q, q1 - q); ! tmp[q1 - q] = '\0'; ! opname = cplus_mangle_opname (tmp, DMGL_ANSI); ! if (opname == NULL) ! { ! error_begin (); ! printf_filtered ("no mangling for \"%s\"\n", tmp); ! cplusplus_hint (saved_arg); ! return_to_top_level (RETURN_ERROR); ! } ! copy = (char*) alloca (3 + strlen(opname)); ! sprintf (copy, "__%s", opname); ! p = q1; ! } ! else ! */ { copy = (char *) alloca (p - *argptr + 1); memcpy (copy, *argptr, p - *argptr); --- 3407,3413 ---- while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':') p++; } ! { copy = (char *) alloca (p - *argptr + 1); memcpy (copy, *argptr, p - *argptr); *************** *** 2805,2811 **** { /* There is more than one field with that name (overloaded). Ask the user which one to use. */ ! return decode_line_2 (sym_arr, i1, funfirstline, canonical); } else { --- 3471,3477 ---- { /* There is more than one field with that name (overloaded). Ask the user which one to use. */ ! return decode_line_2 (sym_arr, i1, funfirstline, canonical, NULL, resolve); } else { *************** *** 2819,2835 **** } else tmp = copy; ! error_begin (); ! if (tmp[0] == '~') ! printf_filtered ! ("the class `%s' does not have destructor defined\n", ! SYMBOL_SOURCE_NAME (sym_class)); ! else ! printf_filtered ! ("the class %s does not have any method named %s\n", ! SYMBOL_SOURCE_NAME (sym_class), tmp); ! cplusplus_hint (saved_arg); ! return_to_top_level (RETURN_ERROR); } } --- 3485,3493 ---- } else tmp = copy; ! ! values.nelts = 0; ! return values; } } *************** *** 2881,2893 **** if (sym) goto symbol_found; /* Couldn't find any interpretation as classes/namespaces, so give up */ ! error_begin (); ! /* The quotes are important if copy is empty. */ ! printf_filtered ! ("Can't find member of namespace, class, struct, or union named \"%s\"\n", copy); ! cplusplus_hint (saved_arg); ! return_to_top_level (RETURN_ERROR); } /* end of C++ */ --- 3539,3553 ---- if (sym) goto symbol_found; + /* RM: try once more, as a minimal symbol -- the file + containing the symbol may have no debug information */ + msymbol = lookup_minimal_symbol (copy, 0, 0); + if (msymbol) + goto minimal_symbol_found; + /* Couldn't find any interpretation as classes/namespaces, so give up */ ! values.nelts = 0; ! return values; } /* end of C++ */ *************** *** 2918,2926 **** --- 3578,3643 ---- s = lookup_symtab (copy); if (s == 0) { + /* RM: We may be debugging a stripped executable with + * unstripped shared libraries. Just because we have no + * symbols now doesn't mean we'll never have symbols. + */ + #if 0 if (!have_full_symbols () && !have_partial_symbols ()) error (no_symtab_msg); + #endif + + /* RM: source file may be in an as yet unloaded shared + * library. Just return an empty sal, and let the caller + * deal with it. + */ + /* guo: gdb.trace/tracecmd.exp has test for this 'feature'. + make it HPPA only. + Should really be #if 0 or removed, and fix the test. */ + #ifndef GDB_TARGET_IS_HPPA error ("No source file named %s.", copy); + #endif + + p++; + while (*p == ' ' || *p == '\t') + p++; + /* RM: do we have a line number? */ + if (*p == '-' || *p == '+' || + (*p >= '0' && *p <= '9')) + { + p++; + while (*p >= '0' && *p <= '9') + p++; + *argptr = p; + } + else + { + /* Arg token is not digits => try it as a variable name + * Find the next token (everything up to end or next + * whitespace). + */ + if (*p == '$') /* May be a convenience variable */ + /* One or two $ chars possible */ + p = skip_quoted (p + ((p[1] == '$') ? 2 : 1)); + else if (is_quoted) + { + p = skip_quoted (p); + if (p[-1] != '\'') + error ("Unmatched single quote."); + } + else if (has_parens) + { + p = pp + 1; + } + else + { + p = skip_quoted (p); + } + *argptr = p; + } + + values.nelts = 0; + return values; } /* Discard the file name from the arg. */ *************** *** 2929,2935 **** p++; *argptr = p; } ! #if 0 /* No one really seems to know why this was added. It certainly breaks the command line, though, whenever the passed name is of the form ClassName::Method. This bit of code --- 3646,3652 ---- p++; *argptr = p; } ! #ifdef GDB_TARGET_IS_HPPA /* No one really seems to know why this was added. It certainly breaks the command line, though, whenever the passed name is of the form ClassName::Method. This bit of code *************** *** 2952,2960 **** copy = (char *) alloca (p - *argptr + 1); memcpy (copy, *argptr, p - *argptr); copy[p - *argptr] = '\000'; ! sym = lookup_symbol (copy, 0, VAR_NAMESPACE, 0, &sym_symtab); ! if (sym) ! { /* Yes, we have a symbol; jump to symbol processing */ /* Code after symbol_found expects S, SYM_SYMTAB, SYM, and COPY to be set correctly */ --- 3669,3691 ---- copy = (char *) alloca (p - *argptr + 1); memcpy (copy, *argptr, p - *argptr); copy[p - *argptr] = '\000'; ! ! /* Look for multiple overloaded (in case of C++) or static (both for C ! and C++ definitions of the function symbol found */ ! sym = 0; ! i1 = 0; /* counter for the symbol array */ ! sym_arr = (struct symbol **) ! alloca (MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS ! * sizeof (struct symbol *)); ! symtab_and_block_arr = (struct symtab_and_block *) ! alloca (MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS ! * sizeof (struct symtab_and_block)); ! i1 = find_functions (copy, sym_arr, symtab_and_block_arr); ! if (i1 == 1) ! { ! /* There is exactly one function with that name. */ ! sym = sym_arr[0]; ! sym_symtab = symtab_and_block_arr[0].symtab; /* Yes, we have a symbol; jump to symbol processing */ /* Code after symbol_found expects S, SYM_SYMTAB, SYM, and COPY to be set correctly */ *************** *** 2962,2971 **** s = (struct symtab *) 0; goto symbol_found; } /* Otherwise fall out from here and go to file/line spec processing, etc. */ } ! #endif /* S is specified file's symtab, or 0 if no file specified. arg no longer contains the file name. */ --- 3693,3709 ---- s = (struct symtab *) 0; goto symbol_found; } + else if (i1 > 1) + { + /* There is more than one functions with that name + (overloaded or file-statics). Ask the user which one to use. */ + *argptr = (*p == '\'') ? p + 1 : p; + return decode_line_2 (sym_arr, i1, funfirstline, canonical, symtab_and_block_arr, resolve); + } /* Otherwise fall out from here and go to file/line spec processing, etc. */ } ! #endif /* GDB_TARGET_IS_HPPA */ /* S is specified file's symtab, or 0 if no file specified. arg no longer contains the file name. */ *************** *** 3154,3159 **** --- 3892,3941 ---- /* Look up that token as a variable. If file specified, use that file's per-file block to start with. */ + #ifdef GDB_TARGET_IS_HPPA + /* If a file is specified look for multiple definitions of the + function to break at in the file. */ + + if (s) + { + int i1; + + sym = 0; + i1 = 0; /* counter for the symbol array */ + + sym_arr = (struct symbol **) + alloca (MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS + * sizeof (struct symbol *)); + + symtab_and_block_arr = (struct symtab_and_block *) + alloca (MAX_NUMBER_OF_OVERLOADED_OR_STATIC_FUNCTION_DEFINITIONS + * sizeof (struct symtab_and_block)); + + i1 = find_functions_in_symtab (copy, sym_arr, symtab_and_block_arr, s); + if (i1 == 1) + { + /* There is exactly one function with that name. */ + sym = sym_arr[0]; + sym_symtab = symtab_and_block_arr[0].symtab; + /* Yes, we have a symbol; jump to symbol processing */ + /* Code after symbol_found expects S, SYM_SYMTAB, SYM, + and COPY to be set correctly */ + *argptr = (*p == '\'') ? p + 1 : p; + /* Let 's' stay as it is */ + goto symbol_found; + } + else if (i1 > 1) + { + /* There is more than one functions with that name + (overloaded or file-statics). Ask the user which one to use. + */ + *argptr = (*p == '\'') ? p + 1 : p; + return decode_line_2 (sym_arr, i1, funfirstline, canonical, + symtab_and_block_arr, resolve); + } + /* Otherwise fall out from here */ + } + #endif /* GDB_TARGET_IS_HPPA */ sym = lookup_symbol (copy, (s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) *************** *** 3234,3244 **** --- 4016,4041 ---- return values; } + /* RM: We may be debugging a stripped executable with unstripped + * shared libraries. Just because we have no symbols now doesn't mean + * we'll never have symbols. + */ + #if 0 if (!have_full_symbols () && !have_partial_symbols () && !have_minimal_symbols ()) error (no_symtab_msg); + #endif + /* RM: function may be defined in an as yet unloaded shared + * library. Just return an empty sal, and let the caller deal with + * it. */ + /* guo: gdb.trace/tracecmd.exp has test for this 'feature'. + Should really be #if 0 or removed, and fix the test. */ + #ifndef GDB_TARGET_IS_HPPA error ("Function \"%s\" not defined.", copy); + #endif + + values.nelts = 0; return values; /* for lint */ } *************** *** 3252,3258 **** error ("Empty line specification."); sals = decode_line_1 (&string, funfirstline, current_source_symtab, current_source_line, ! (char ***) NULL); if (*string) error ("Junk at end of line specification: %s", string); return sals; --- 4049,4055 ---- error ("Empty line specification."); sals = decode_line_1 (&string, funfirstline, current_source_symtab, current_source_line, ! (char ***) NULL, USER_CHOICE); if (*string) error ("Junk at end of line specification: %s", string); return sals; *************** *** 3261,3278 **** /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to operate on (ask user if necessary). If CANONICAL is non-NULL return a corresponding array of mangled names ! as canonical line specs there. */ static struct symtabs_and_lines ! decode_line_2 (sym_arr, nelts, funfirstline, canonical) struct symbol *sym_arr[]; int nelts; int funfirstline; char ***canonical; { struct symtabs_and_lines values, return_values; ! char *args, *arg1; int i; char *prompt; char *symname; struct cleanup *old_chain; --- 4058,4087 ---- /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to operate on (ask user if necessary). If CANONICAL is non-NULL return a corresponding array of mangled names ! as canonical line specs there. ! If CANONICAL is non-NULL and if SYMTAB_ARR is non-NULL use SYMTAB_ARR ! to find whether the symbols in SYM_ARR are static and if they are then ! return canonical line specs of the form "function:filename". ! ! RESOLVE tells us what to do if with multiple matching symbols. If ! it is set to USER_CHOICE, a menu is popped up for the user to ! choose from. If it is set to ALL_SYMBOLS, all symbols are ! returned. ! */ static struct symtabs_and_lines ! decode_line_2 (sym_arr, nelts, funfirstline, canonical, symtab_and_block_arr, resolve) struct symbol *sym_arr[]; int nelts; int funfirstline; char ***canonical; + struct symtab_and_block symtab_and_block_arr[]; + enum how_to_resolve_multiple_symbols resolve; { struct symtabs_and_lines values, return_values; ! char *args = NULL, *arg1; int i; + char buf[2]; char *prompt; char *symname; struct cleanup *old_chain; *************** *** 3293,3299 **** } i = 0; ! printf_unfiltered ("[0] cancel\n[1] all\n"); while (i < nelts) { INIT_SAL (&return_values.sals[i]); /* initialize to zeroes */ --- 4102,4110 ---- } i = 0; ! /* Choices are [0],[1],..,[nelts+1] */ ! if (resolve == USER_CHOICE) ! printf_filtered ("[0] cancel\n[1] all\n"); while (i < nelts) { INIT_SAL (&return_values.sals[i]); /* initialize to zeroes */ *************** *** 3301,3322 **** if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK) { values.sals[i] = find_function_start_sal (sym_arr[i], funfirstline); ! printf_unfiltered ("[%d] %s at %s:%d\n", (i + 2), SYMBOL_SOURCE_NAME (sym_arr[i]), values.sals[i].symtab->filename, ! values.sals[i].line); } ! else ! printf_unfiltered ("?HERE\n"); i++; } ! if ((prompt = getenv ("PS2")) == NULL) { ! prompt = "> "; } - args = command_line_input (prompt, 0, "overload-choice"); if (args == 0 || *args == 0) error_no_arg ("one or more choice numbers"); --- 4112,4149 ---- if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK) { values.sals[i] = find_function_start_sal (sym_arr[i], funfirstline); ! if (resolve == USER_CHOICE) ! printf_filtered ("[%d] %s at %s:%d\n", (i + 2), SYMBOL_SOURCE_NAME (sym_arr[i]), values.sals[i].symtab->filename, ! values.sals[i].line, ! (symtab_and_block_arr && ! symtab_and_block_arr[i].block_number == STATIC_BLOCK) ? ! " (STATIC)" : ""); } ! else if (resolve == USER_CHOICE) ! printf_filtered ("?HERE\n"); i++; } ! if (resolve == USER_CHOICE) ! { ! if ((prompt = getenv ("PS2")) == NULL) ! { ! /* guo 991019: need to update WDB test (gdb.c++/templates.exp) ! when merge back to WDB tree. */ ! prompt = "> "; ! } ! ! args = command_line_input (prompt, 0, "overload-choice"); ! } ! else if (resolve == ALL_SYMBOLS) { ! buf[0] = '1'; ! buf[1] = 0; ! args = buf; } if (args == 0 || *args == 0) error_no_arg ("one or more choice numbers"); *************** *** 3345,3354 **** if (canonical_arr[i] == NULL) { symname = SYMBOL_NAME (sym_arr[i]); ! canonical_arr[i] = savestring (symname, strlen (symname)); } } } memcpy (return_values.sals, values.sals, (nelts * sizeof (struct symtab_and_line))); return_values.nelts = nelts; --- 4172,4206 ---- if (canonical_arr[i] == NULL) { symname = SYMBOL_NAME (sym_arr[i]); ! if (symtab_and_block_arr && symtab_and_block_arr[i].symtab) ! { ! /* Is this a 'static' function? */ ! if (symtab_and_block_arr[i].block_number == STATIC_BLOCK) ! { ! /* This is a static function */ ! char *filename, *canonical_name; ! ! filename = values.sals[i].symtab->filename, ! canonical_name = xmalloc (strlen (filename) + ! strlen (symname) + 2); ! strcpy (canonical_name, filename); ! strcat (canonical_name, ":"); ! strcat (canonical_name, symname); ! canonical_arr[i] = canonical_name; ! } ! else ! { /* Not a static function */ ! canonical_arr[i] = savestring (symname, strlen (symname)); ! } ! } ! else ! { /* SYMTAB_AND_BLOCK_ARR is NULL or no SYMTAB */ ! canonical_arr[i] = savestring (symname, strlen (symname)); ! } } } } + memcpy (return_values.sals, values.sals, (nelts * sizeof (struct symtab_and_line))); return_values.nelts = nelts; *************** *** 3370,3375 **** --- 4222,4252 ---- symname = SYMBOL_NAME (sym_arr[num]); make_cleanup (free, symname); canonical_arr[i] = savestring (symname, strlen (symname)); + if (symtab_and_block_arr && symtab_and_block_arr[i].symtab) + { + /* Is this a 'static' function? */ + if (symtab_and_block_arr[i].block_number == STATIC_BLOCK) + { + /* This is a static function */ + char *filename, *canonical_name; + + filename = values.sals[i].symtab->filename, + canonical_name = xmalloc (strlen (filename) + + strlen (symname) + 2); + strcpy (canonical_name, filename); + strcat (canonical_name, ":"); + strcat (canonical_name, symname); + canonical_arr[i] = canonical_name; + } + else + { /* Not a static function */ + canonical_arr[i] = savestring (symname, strlen (symname)); + } + } + else + { /* SYMTAB_AND_BLOCK_ARR is NULL or SYMTAB is NULL */ + canonical_arr[i] = savestring (symname, strlen (symname)); + } } return_values.sals[i++] = values.sals[num]; values.sals[num].pc = 0; *************** *** 3664,3674 **** load the file and go on to the next one */ if (file_matches (ps->filename, files, nfiles) && ((regexp == NULL || SYMBOL_MATCHES_REGEXP (*psym)) ! && ((kind == VARIABLES_NAMESPACE && 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)))) { PSYMTAB_TO_SYMTAB (ps); keep_going = 0; --- 4541,4555 ---- load the file and go on to the next one */ if (file_matches (ps->filename, files, nfiles) && ((regexp == NULL || SYMBOL_MATCHES_REGEXP (*psym)) ! && ((kind == VARIABLES_NAMESPACE ! && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF ! && PSYMBOL_CLASS (*psym) != LOC_BLOCK) ! || (kind == FUNCTIONS_NAMESPACE ! && PSYMBOL_CLASS (*psym) == LOC_BLOCK) ! || (kind == TYPES_NAMESPACE ! && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF) ! || (kind == METHODS_NAMESPACE ! && PSYMBOL_CLASS (*psym) == LOC_BLOCK)))) { PSYMTAB_TO_SYMTAB (ps); keep_going = 0; *************** *** 3714,3719 **** --- 4595,4603 ---- } } } + + /* RM: allow user to quit */ + QUIT; } ALL_SYMTABS (objfile, s) *************** *** 4164,4169 **** --- 5048,5054 ---- char *sym_text; /* Length of sym_text. */ int sym_text_len; + int class_qualified; /* Now look for the symbol we are supposed to complete on. FIXME: This should be language-specific. */ *************** *** 4259,4264 **** --- 5144,5150 ---- ALL_MSYMBOLS (objfile, msymbol) { QUIT; + COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word); } *************** *** 4481,4487 **** sym_return_val[0] = NULL; /* Look through the partial symtabs for all symbols which begin ! by matching OLOAD_NAME. Make sure we read that symbol table in. */ ALL_PSYMTABS (objfile, ps) { --- 5367,5373 ---- sym_return_val[0] = NULL; /* Look through the partial symtabs for all symbols which begin ! by matching OLOAD_NAME. Add each one that you find to the list. */ ALL_PSYMTABS (objfile, ps) { *************** *** 4499,4506 **** { /* If interrupted, then quit. */ QUIT; ! /* This will cause the symbol table to be read if it has not yet been */ ! s = PSYMTAB_TO_SYMTAB (ps); } for (psym = objfile->static_psymbols.list + ps->statics_offset; --- 5385,5392 ---- { /* If interrupted, then quit. */ QUIT; ! /* This will cause the symbol table to be read if it has not yet been */ ! s = PSYMTAB_TO_SYMTAB (ps); } for (psym = objfile->static_psymbols.list + ps->statics_offset; *************** *** 4509,4516 **** psym++) { QUIT; ! /* This will cause the symbol table to be read if it has not yet been */ ! s = PSYMTAB_TO_SYMTAB (ps); } } --- 5395,5402 ---- psym++) { QUIT; ! /* This will cause the symbol table to be read if it has not yet been */ ! s = PSYMTAB_TO_SYMTAB (ps); } } Index: gdb/symtab.h /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/symtab.h gdb/symtab.h *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/symtab.h Tue Nov 2 16:04:08 1999 --- gdb/symtab.h Thu Nov 11 09:19:20 1999 *************** *** 34,44 **** --- 34,49 ---- things; also it is a pain to have to "make clean" every time you want to switch compilers), then GDB dies a horrible death. */ /* GNU C supports enums that are bitfields. Some compilers don't. */ + /* HPC supports enum bitfields */ #if 0 && defined(__GNUC__) && !defined(BYTE_BITFIELD) #define BYTE_BITFIELD :8; #else + #if defined(__hpux) && !defined(__GNUC__) && !defined(BYTE_BITFIELD) + #define BYTE_BITFIELD :8 + #else #define BYTE_BITFIELD /*nothing */ #endif + #endif /* Define a structure for the information that is common to all symbol types, including minimal symbols, partial symbols, and full symbols. In a *************** *** 67,73 **** /* The fact that this is a long not a LONGEST mainly limits the range of a LOC_CONST. Since LOC_CONST_BYTES exists, I'm not sure that is a big deal. */ ! long ivalue; struct block *block; --- 72,78 ---- /* The fact that this is a long not a LONGEST mainly limits the range of a LOC_CONST. Since LOC_CONST_BYTES exists, I'm not sure that is a big deal. */ ! CORE_ADDR ivalue; struct block *block; *************** *** 508,513 **** --- 513,526 ---- STRUCT_NAMESPACE, + /* In doom mode, it is not clear at the psymtab stage whether a type name + is a struct/union/enum tag or not. So we end up adding the same symbol + under both categories. I am introducing a fuzzy name space here to + cut down the number of psymbols - srikanth + */ + + VAR_OR_STRUCT_NAMESPACE, + /* LABEL_NAMESPACE may be used for names of labels (for gotos); currently it is not used and labels are not recorded at all. */ *************** *** 1101,1109 **** /* Macro that yields non-zero value iff NAME is the prefix for C++ destructor names. Note that this macro is g++ specific (FIXME). */ #define DESTRUCTOR_PREFIX_P(NAME) \ ! ((NAME)[0] == '_' && is_cplus_marker ((NAME)[1]) && (NAME)[2] == '_') /* External variables and functions for the objects described above. */ --- 1114,1134 ---- /* Macro that yields non-zero value iff NAME is the prefix for C++ destructor names. Note that this macro is g++ specific (FIXME). */ + /* RM: This is probably the wrong place to do this, but we should at + least recognize HP aCC destructors too */ #define DESTRUCTOR_PREFIX_P(NAME) \ ! (((NAME)[0] == '_' && is_cplus_marker ((NAME)[1]) && (NAME)[2] == '_') \ ! || (!(strncmp(NAME, "__dt__", 6)))) ! ! /* RM: enum used to choose between various methods of resolving ! * multiple symbols with the same name. Used in decode_line_1(). ! */ ! enum how_to_resolve_multiple_symbols ! { ! USER_CHOICE, ! ALL_SYMBOLS ! }; /* External variables and functions for the objects described above. */ *************** *** 1408,1414 **** decode_line_spec_1 PARAMS ((char *, int)); extern struct symtabs_and_lines ! decode_line_1 PARAMS ((char **, int, struct symtab *, int, char ***)); /* Symmisc.c */ --- 1433,1440 ---- decode_line_spec_1 PARAMS ((char *, int)); extern struct symtabs_and_lines ! decode_line_1 PARAMS ((char **, int, struct symtab *, int, char ***, ! enum how_to_resolve_multiple_symbols)); /* Symmisc.c */ Index: gdb/language.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/language.c gdb/language.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/language.c Fri Oct 29 15:41:44 1999 --- gdb/language.c Thu Nov 11 09:19:17 1999 *************** *** 64,75 **** --- 64,84 ---- set_range_command PARAMS ((char *, int)); static void + show_case_command PARAMS ((char *, int)); + + static void + set_case_command PARAMS ((char *, int)); + + static void set_range_str PARAMS ((void)); static void set_type_str PARAMS ((void)); static void + set_case_str PARAMS ((void)); + + static void set_lang_str PARAMS ((void)); static void *************** *** 85,91 **** set_check PARAMS ((char *, int)); static void ! set_type_range PARAMS ((void)); static void unk_lang_emit_char PARAMS ((int c, GDB_FILE * stream, int quoter)); --- 94,100 ---- set_check PARAMS ((char *, int)); static void ! set_type_range_case PARAMS ((void)); static void unk_lang_emit_char PARAMS ((int c, GDB_FILE * stream, int quoter)); *************** *** 122,127 **** --- 131,138 ---- enum range_check range_check = range_check_off; enum type_mode type_mode = type_mode_auto; enum type_check type_check = type_check_off; + enum case_mode_type case_mode = case_mode_auto; + enum case_sensitivity_type case_sensitivity = case_sensitive_on; /* The current language and language_mode (see language.h) */ *************** *** 140,146 **** static unsigned languages_allocsize; #define DEFAULT_ALLOCSIZE 4 ! /* The "set language/type/range" commands all put stuff in these buffers. This is to make them work as set/show commands. The user's string is copied here, then the set_* commands look at them and update them to something that looks nice when it is --- 151,157 ---- static unsigned languages_allocsize; #define DEFAULT_ALLOCSIZE 4 ! /* The "set language/type/range/case" commands all put stuff in these buffers. This is to make them work as set/show commands. The user's string is copied here, then the set_* commands look at them and update them to something that looks nice when it is *************** *** 149,154 **** --- 160,166 ---- static char *language; static char *type; static char *range; + static char *case_sensitive; /* Warning issued when current_language and the language of the current frame do not match. */ *************** *** 232,238 **** /* Enter manual mode. Set the specified language. */ language_mode = language_mode_manual; current_language = languages[i]; ! set_type_range (); set_lang_str (); expected_language = current_language; return; --- 244,250 ---- /* Enter manual mode. Set the specified language. */ language_mode = language_mode_manual; current_language = languages[i]; ! set_type_range_case (); set_lang_str (); expected_language = current_language; return; *************** *** 284,292 **** else if (STREQ (type, "auto")) { type_mode = type_mode_auto; ! set_type_range (); /* Avoid hitting the set_type_str call below. We ! did it in set_type_range. */ return; } else --- 296,304 ---- else if (STREQ (type, "auto")) { type_mode = type_mode_auto; ! set_type_range_case (); /* Avoid hitting the set_type_str call below. We ! did it in set_type_range_case. */ return; } else *************** *** 334,342 **** else if (STREQ (range, "auto")) { range_mode = range_mode_auto; ! set_type_range (); /* Avoid hitting the set_range_str call below. We ! did it in set_type_range. */ return; } else --- 346,354 ---- else if (STREQ (range, "auto")) { range_mode = range_mode_auto; ! set_type_range_case (); /* Avoid hitting the set_range_str call below. We ! did it in set_type_range_case. */ return; } else *************** *** 347,358 **** show_range_command ((char *) 0, from_tty); } ! /* Set the status of range and type checking based on ! the current modes and the current language. If SHOW is non-zero, then print out the current language, type and range checking status. */ static void ! set_type_range () { if (range_mode == range_mode_auto) --- 359,413 ---- show_range_command ((char *) 0, from_tty); } ! static void ! show_case_command (ignore, from_tty) ! char *ignore; ! int from_tty; ! { ! if (case_sensitivity != current_language->la_case_sensitivity) ! printf_unfiltered ( ! "Warning: the current case sensitivity setting does not match the language.\n"); ! } ! ! /* Set command. Change the setting for type checking. */ ! static void ! set_case_command (ignore, from_tty) ! char *ignore; ! int from_tty; ! { ! if (STREQ (case_sensitive, "on")) ! { ! case_sensitivity = case_sensitive_on; ! case_mode = case_mode_manual; ! } ! else if (STREQ (case_sensitive, "off")) ! { ! case_sensitivity = case_sensitive_off; ! case_mode = case_mode_manual; ! } ! else if (STREQ (case_sensitive, "auto")) ! { ! case_mode = case_mode_auto; ! set_type_range_case (); ! /* Avoid hitting the set_str_case call below. We ! did it in set_type_range_case. */ ! return; ! } ! else ! { ! warning ("Unrecognized case-sensitive setting: \"%s\"", case_sensitive); ! } ! ! set_case_str (); ! show_case_command ((char *) NULL, from_tty); ! } ! ! /* Set the status of range and type checking as well as case sensitivity ! based on the current modes and the current language. If SHOW is non-zero, then print out the current language, type and range checking status. */ static void ! set_type_range_case () { if (range_mode == range_mode_auto) *************** *** 361,368 **** --- 416,427 ---- if (type_mode == type_mode_auto) type_check = current_language->la_type_check; + if (case_mode == case_mode_auto) + case_sensitivity = current_language->la_case_sensitivity; + set_type_str (); set_range_str (); + set_case_str (); } /* Set current language to (enum language) LANG. Returns previous language. */ *************** *** 381,387 **** if (languages[i]->la_language == lang) { current_language = languages[i]; ! set_type_range (); set_lang_str (); break; } --- 440,446 ---- if (languages[i]->la_language == lang) { current_language = languages[i]; ! set_type_range_case (); set_lang_str (); break; } *************** *** 409,415 **** { char *tmp = NULL, *prefix = ""; - free (type); if (type_mode == type_mode_auto) prefix = "auto; currently "; --- 468,473 ---- *************** *** 428,440 **** error ("Unrecognized type check setting."); } type = concat (prefix, tmp, NULL); } static void set_range_str () { ! char *tmp, *pref = ""; if (range_mode == range_mode_auto) pref = "auto; currently "; --- 486,499 ---- error ("Unrecognized type check setting."); } + free (type); type = concat (prefix, tmp, NULL); } static void set_range_str () { ! char *tmp = NULL, *pref = ""; if (range_mode == range_mode_auto) pref = "auto; currently "; *************** *** 458,463 **** --- 517,545 ---- range = concat (pref, tmp, NULL); } + static void + set_case_str () + { + char *tmp = NULL, *prefix = ""; + + if (case_mode == case_mode_auto) + prefix = "auto; currently "; + + switch (case_sensitivity) + { + case case_sensitive_on: + tmp = "on"; + break; + case case_sensitive_off: + tmp = "off"; + break; + default: + error ("Unrecognized case-sensitive setting."); + } + + free (case_sensitive); + case_sensitive = concat (prefix, tmp, NULL); + } /* Print out the current language settings: language, range and type checking. If QUIETLY, print only what has changed. */ *************** *** 479,484 **** --- 561,568 ---- show_type_command ((char *) 0, 1); printf_unfiltered ("Range checking: %s\n", range); show_range_command ((char *) 0, 1); + printf_unfiltered ("Case sensitivity: %s\n", case_sensitive); + show_case_command ((char *) 0, 1); } } *************** *** 1448,1453 **** --- 1532,1538 ---- &unknown_builtin_types[0], range_check_off, type_check_off, + case_sensitive_on, unk_lang_parser, unk_lang_error, evaluate_subexp_standard, *************** *** 1477,1482 **** --- 1562,1568 ---- &unknown_builtin_types[0], range_check_off, type_check_off, + case_sensitive_on, unk_lang_parser, unk_lang_error, evaluate_subexp_standard, *************** *** 1505,1510 **** --- 1591,1597 ---- &unknown_builtin_types[0], range_check_off, type_check_off, + case_sensitive_on, unk_lang_parser, unk_lang_error, evaluate_subexp_standard, *************** *** 1571,1576 **** --- 1658,1672 ---- set->function.cfunc = set_range_command; show->function.cfunc = show_range_command; + set = add_set_cmd ("case-sensitive", class_support, var_string_noescape, + (char *) &case_sensitive, + "Set case sensitivity in name search. (on/off/auto)\n\ + For Fortran the default is off; for other languages the default is on.", + &setlist); + show = add_show_from_set (set, &showlist); + set->function.cfunc = set_case_command; + show->function.cfunc = show_case_command; + add_language (&unknown_language_defn); add_language (&local_language_defn); add_language (&auto_language_defn); *************** *** 1578,1587 **** language = savestring ("auto", strlen ("auto")); range = savestring ("auto", strlen ("auto")); type = savestring ("auto", strlen ("auto")); /* Have the above take effect */ ! set_language_command (language, 0); ! set_type_command (NULL, 0); ! set_range_command (NULL, 0); } --- 1674,1682 ---- language = savestring ("auto", strlen ("auto")); range = savestring ("auto", strlen ("auto")); type = savestring ("auto", strlen ("auto")); + case_sensitive = savestring ("auto", strlen ("auto")); /* Have the above take effect */ ! set_language (language_auto); } Index: gdb/language.h /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/language.h gdb/language.h *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/language.h Fri Oct 29 15:41:45 1999 --- gdb/language.h Thu Nov 11 09:19:17 1999 *************** *** 80,85 **** --- 80,105 ---- type_check_off, type_check_warn, type_check_on } type_check; + + /* case_mode_type == + case_mode_auto: case_sensitivity set upon selection of scope + case_mode_manual: case_sensitivity set only by user. */ + + extern enum case_mode_type + { + case_mode_auto, case_mode_manual + } + case_mode; + + /* case_sensitivity_type == + case_sensitive_on: Case sensitivity in name matching is used + case_sensitive_off: Case sensitivity in name matching is not used */ + + extern enum case_sensitivity_type + { + case_sensitive_on, case_sensitive_off + } + case_sensitivity; /* Information for doing language dependent formatting of printed values. */ *************** *** 138,143 **** --- 158,167 ---- /* Default type checking */ enum type_check la_type_check; + + /* Default case sensitivity */ + + enum case_sensitivity_type la_case_sensitivity; /* Parser function. */ Index: gdb/c-lang.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/c-lang.c gdb/c-lang.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/c-lang.c Wed Nov 10 11:02:27 1999 --- gdb/c-lang.c Wed Nov 10 11:04:38 1999 *************** *** 421,426 **** --- 421,427 ---- c_builtin_types, range_check_off, type_check_off, + case_sensitive_on, c_parse, c_error, evaluate_subexp_standard, *************** *** 472,477 **** --- 473,479 ---- cplus_builtin_types, range_check_off, type_check_off, + case_sensitive_on, c_parse, c_error, evaluate_subexp_standard, *************** *** 500,505 **** --- 502,508 ---- c_builtin_types, range_check_off, type_check_off, + case_sensitive_on, c_parse, c_error, evaluate_subexp_standard, Index: gdb/ch-lang.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/ch-lang.c gdb/ch-lang.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/ch-lang.c Wed Nov 10 11:02:54 1999 --- gdb/ch-lang.c Wed Nov 10 11:06:24 1999 *************** *** 407,413 **** value_chill_length (val) value_ptr val; { ! LONGEST tmp; struct type *type = VALUE_TYPE (val); struct type *ttype; CHECK_TYPEDEF (type); --- 407,413 ---- value_chill_length (val) value_ptr val; { ! LONGEST tmp = 0; struct type *type = VALUE_TYPE (val); struct type *ttype; CHECK_TYPEDEF (type); *************** *** 464,470 **** { LONGEST tmp = 0; struct type *type = VALUE_TYPE (val); ! struct type *elttype; CHECK_TYPEDEF (type); if (TYPE_CODE (type) == TYPE_CODE_SET) --- 464,470 ---- { LONGEST tmp = 0; struct type *type = VALUE_TYPE (val); ! struct type *elttype = NULL; CHECK_TYPEDEF (type); if (TYPE_CODE (type) == TYPE_CODE_SET) *************** *** 629,634 **** --- 629,635 ---- chill_builtin_types, range_check_on, type_check_on, + case_sensitive_on, chill_parse, /* parser */ chill_error, /* parser error function */ evaluate_subexp_chill, Index: gdb/f-lang.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/f-lang.c gdb/f-lang.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/f-lang.c Wed Nov 10 11:02:57 1999 --- gdb/f-lang.c Wed Nov 10 11:07:45 1999 *************** *** 470,475 **** --- 470,476 ---- f_builtin_types, range_check_on, type_check_on, + case_sensitive_off, f_parse, /* parser */ f_error, /* parser error function */ evaluate_subexp_standard, Index: gdb/jv-lang.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/jv-lang.c gdb/jv-lang.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/jv-lang.c Wed Nov 10 11:02:59 1999 --- gdb/jv-lang.c Wed Nov 10 11:09:34 1999 *************** *** 268,275 **** value_ptr utf8_name; char *nptr; CORE_ADDR addr; - struct block *bl; - int i; int is_array = 0; type = check_typedef (VALUE_TYPE (clas)); --- 268,273 ---- *************** *** 1065,1070 **** --- 1063,1069 ---- c_builtin_types, range_check_off, type_check_off, + case_sensitive_on, java_parse, java_error, evaluate_subexp_java, Index: gdb/m2-lang.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/m2-lang.c gdb/m2-lang.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/m2-lang.c Wed Nov 10 11:03:02 1999 --- gdb/m2-lang.c Wed Nov 10 11:26:42 1999 *************** *** 424,429 **** --- 424,430 ---- m2_builtin_types, range_check_on, type_check_on, + case_sensitive_on, m2_parse, /* parser */ m2_error, /* parser error function */ evaluate_subexp_standard, Index: gdb/scm-lang.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/scm-lang.c gdb/scm-lang.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/scm-lang.c Wed Nov 10 11:03:03 1999 --- gdb/scm-lang.c Wed Nov 10 11:27:40 1999 *************** *** 249,254 **** --- 249,255 ---- c_builtin_types, range_check_off, type_check_off, + case_sensitive_on, scm_parse, c_error, evaluate_subexp_scm, Index: gdb/breakpoint.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/breakpoint.c gdb/breakpoint.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/breakpoint.c Wed Nov 10 10:25:35 1999 --- gdb/breakpoint.c Thu Nov 11 09:21:20 1999 *************** *** 143,149 **** set_breakpoint_count PARAMS ((int)); static struct expression * ! save_breakpoint_condition PARAMS ((struct expression *)); #if 0 static struct breakpoint * --- 143,149 ---- set_breakpoint_count PARAMS ((int)); static struct expression * ! save_breakpoint_condition PARAMS ((struct expression *)); #if 0 static struct breakpoint * *************** *** 221,227 **** static void create_fork_vfork_event_catchpoint PARAMS ((int tempflag, char *cond_string, ! enum bptype bp_kind)); static void break_at_finish_at_depth_command_1 PARAMS ((char *arg, int flag, --- 221,227 ---- static void create_fork_vfork_event_catchpoint PARAMS ((int tempflag, char *cond_string, ! enum bptype bp_kind)); static void break_at_finish_at_depth_command_1 PARAMS ((char *arg, int flag, *************** *** 1063,1069 **** val = target_insert_exec_catchpoint (inferior_pid); break; default: ! val = -1; break; } if (val < 0) --- 1063,1069 ---- val = target_insert_exec_catchpoint (inferior_pid); break; default: ! val = -1; break; } if (val < 0) *************** *** 3742,3748 **** } /* cover routine for parse_exp_1 */ ! int cover_parse_exp_1 (args) args_for_parse_exp_1 *args; { --- 3742,3748 ---- } /* cover routine for parse_exp_1 */ ! int cover_parse_exp_1 (args) args_for_parse_exp_1 *args; { *************** *** 3751,3757 **** } /* cover routine for decode_line_1 */ ! int cover_decode_line_1 (args) args_for_decode_line_1 *args; { --- 3751,3757 ---- } /* cover routine for decode_line_1 */ ! int cover_decode_line_1 (args) args_for_decode_line_1 *args; { *************** *** 3759,3765 **** 1, (struct symtab *) NULL, 0, ! args->canonical_p); return 1; } --- 3759,3766 ---- 1, (struct symtab *) NULL, 0, ! args->canonical_p, ! ALL_SYMBOLS); return 1; } *************** *** 3976,3982 **** int thread = -1; /* All threads. */ /* Set a breakpoint on the specified hook. */ ! sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical); addr_end = hookname; if (sals.nelts == 0) --- 3977,3984 ---- int thread = -1; /* All threads. */ /* Set a breakpoint on the specified hook. */ ! sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical, ! USER_CHOICE); addr_end = hookname; if (sals.nelts == 0) *************** *** 4050,4056 **** char *cond_string; { solib_load_unload_1 (hookname, tempflag, dll_pathname, ! cond_string, bp_catch_load); } void --- 4052,4058 ---- char *cond_string; { solib_load_unload_1 (hookname, tempflag, dll_pathname, ! cond_string, bp_catch_load); } void *************** *** 4491,4499 **** && (!current_source_symtab || (arg && (*arg == '+' || *arg == '-')))) sals = decode_line_1 (&arg, 1, default_breakpoint_symtab, ! default_breakpoint_line, &canonical); else ! sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical); addr_end = arg; } --- 4493,4503 ---- && (!current_source_symtab || (arg && (*arg == '+' || *arg == '-')))) sals = decode_line_1 (&arg, 1, default_breakpoint_symtab, ! default_breakpoint_line, &canonical, ! USER_CHOICE); else ! sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical, ! USER_CHOICE); addr_end = arg; } *************** *** 4864,4873 **** beg_addr_string = addr_string; sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0, ! (char ***) NULL); free (beg_addr_string); old_chain = make_cleanup (free, sals.sals); for (i = 0; (i < sals.nelts); i++) { --- 4868,4882 ---- beg_addr_string = addr_string; sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0, ! (char ***) NULL, USER_CHOICE); free (beg_addr_string); + /* srikanth, 981001, CLLbs15582 decode_line_1 used not to return + if arg is bogus. However this has changed ... */ + if (sals.nelts == 0) + error ("Function \"%s\" not defined.", symbol); + old_chain = make_cleanup (free, sals.sals); for (i = 0; (i < sals.nelts); i++) { *************** *** 5230,5236 **** #ifdef GDB_TARGET_IS_HPPA && (!frame) #endif ! ) b->type = bp_type; else b->type = bp_watchpoint; --- 5239,5245 ---- #ifdef GDB_TARGET_IS_HPPA && (!frame) #endif ! ) b->type = bp_type; else b->type = bp_watchpoint; *************** *** 5410,5419 **** if (default_breakpoint_valid) sals = decode_line_1 (&arg, 1, default_breakpoint_symtab, ! default_breakpoint_line, (char ***) NULL); else sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, ! 0, (char ***) NULL); if (sals.nelts != 1) error ("Couldn't get information on specified line."); --- 5419,5429 ---- if (default_breakpoint_valid) sals = decode_line_1 (&arg, 1, default_breakpoint_symtab, ! default_breakpoint_line, (char ***) NULL, ! USER_CHOICE); else sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, ! 0, (char ***) NULL, USER_CHOICE); if (sals.nelts != 1) error ("Couldn't get information on specified line."); *************** *** 6419,6424 **** --- 6429,6439 ---- { sals = decode_line_spec (arg, 1); + /* srikanth, 981001, CLLbs15582, decode_line_spec() used not to + return if arg is not found, but now it does.... */ + if (sals.nelts == 0) + error ("Location not found."); + default_match = 0; } else *************** *** 6830,6836 **** input_radix = b->input_radix; s = b->addr_string; symbol = s; /* preserve original as decode_line_1 will advance pointer */ ! sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL); for (i = 0; i < sals.nelts; i++) { resolve_sal_pc (&sals.sals[i]); --- 6845,6853 ---- input_radix = b->input_radix; s = b->addr_string; symbol = s; /* preserve original as decode_line_1 will advance pointer */ ! sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL, ! USER_CHOICE); ! for (i = 0; i < sals.nelts; i++) { resolve_sal_pc (&sals.sals[i]); *************** *** 7425,7434 **** sals = decode_line_1 (&string, funfirstline, default_breakpoint_symtab, default_breakpoint_line, ! (char ***) NULL); else sals = decode_line_1 (&string, funfirstline, ! (struct symtab *) NULL, 0, (char ***) NULL); if (*string) error ("Junk at end of line specification: %s", string); return sals; --- 7442,7452 ---- sals = decode_line_1 (&string, funfirstline, default_breakpoint_symtab, default_breakpoint_line, ! (char ***) NULL, USER_CHOICE); else sals = decode_line_1 (&string, funfirstline, ! (struct symtab *) NULL, 0, (char ***) NULL, ! USER_CHOICE); if (*string) error ("Junk at end of line specification: %s", string); return sals; Index: gdb/source.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/source.c gdb/source.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/source.c Thu Nov 4 10:49:28 1999 --- gdb/source.c Wed Nov 10 11:34:31 1999 *************** *** 1199,1205 **** dummy_beg = 1; else { ! sals = decode_line_1 (&arg1, 0, 0, 0, 0); if (!sals.nelts) return; /* C++ */ --- 1199,1205 ---- dummy_beg = 1; else { ! sals = decode_line_1 (&arg1, 0, 0, 0, 0, USER_CHOICE); if (!sals.nelts) return; /* C++ */ *************** *** 1232,1240 **** else { if (dummy_beg) ! sals_end = decode_line_1 (&arg1, 0, 0, 0, 0); else ! sals_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line, 0); if (sals_end.nelts == 0) return; if (sals_end.nelts > 1) --- 1232,1241 ---- else { if (dummy_beg) ! sals_end = decode_line_1 (&arg1, 0, 0, 0, 0, USER_CHOICE); else ! sals_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line, 0, ! USER_CHOICE); if (sals_end.nelts == 0) return; if (sals_end.nelts > 1) Index: gdb/tracepoint.c /opt/gnu/bin/diff -r -c -N /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/tracepoint.c gdb/tracepoint.c *** /view/guo.wdb.c//CLO/Components/WDB/Src/gnu/gdb/tracepoint.c Wed Nov 10 11:29:50 1999 --- gdb/tracepoint.c Thu Nov 11 09:27:40 1999 *************** *** 64,76 **** extern void x_command PARAMS ((char *, int)); extern int addressprint; /* Print machine addresses? */ ! /* GDB commands implemented in other modules: ! */ extern void output_command PARAMS ((char *, int)); extern void registers_info PARAMS ((char *, int)); ! extern void args_info PARAMS ((char *, int)); ! extern void locals_info PARAMS ((char *, int)); /* If this definition isn't overridden by the header files, assume --- 64,75 ---- extern void x_command PARAMS ((char *, int)); extern int addressprint; /* Print machine addresses? */ ! /* GDB commands implemented in other modules: */ extern void output_command PARAMS ((char *, int)); extern void registers_info PARAMS ((char *, int)); ! extern void args_info PARAMS ((char *, int)); ! extern void locals_info PARAMS ((char *, int)); /* If this definition isn't overridden by the header files, assume *************** *** 154,160 **** struct collection_list; static void add_aexpr PARAMS ((struct collection_list *, struct agent_expr *)); static unsigned char *mem2hex (unsigned char *, unsigned char *, int); ! static void add_register PARAMS ((struct collection_list * collection, unsigned int regno)); static void free_actions_list PARAMS ((char **actions_list)); static void free_actions_list_cleanup_wrapper PARAMS ((void *)); --- 153,159 ---- struct collection_list; static void add_aexpr PARAMS ((struct collection_list *, struct agent_expr *)); static unsigned char *mem2hex (unsigned char *, unsigned char *, int); ! static void add_register PARAMS ((struct collection_list * collection, unsigned int regno)); static void free_actions_list PARAMS ((char **actions_list)); static void free_actions_list_cleanup_wrapper PARAMS ((void *)); *************** *** 401,407 **** printf_filtered ("TRACE %s\n", arg); addr_start = arg; ! sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical); addr_end = arg; if (!sals.nelts) return; /* ??? Presumably decode_line_1 has already warned? */ --- 400,407 ---- printf_filtered ("TRACE %s\n", arg); addr_start = arg; ! sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical, ! USER_CHOICE); addr_end = arg; if (!sals.nelts) return; /* ??? Presumably decode_line_1 has already warned? */ *************** *** 556,562 **** { struct tracepoint *t2; ! if (t == NULL) /* no tracepoint operand */ return; switch (opcode) --- 556,562 ---- { struct tracepoint *t2; ! if (t == NULL) /* no tracepoint operand */ return; switch (opcode) *************** *** 716,722 **** if (*args && strncasecmp (args, "all", 3) == 0) { ! args += 3; /* skip special argument "all" */ all = 1; if (*args) error ("Junk at end of arguments."); --- 716,722 ---- if (*args && strncasecmp (args, "all", 3) == 0) { ! args += 3; /* skip special argument "all" */ all = 1; if (*args) error ("Junk at end of arguments."); *************** *** 730,745 **** { ALL_TRACEPOINTS (t2) if (t1 == (struct tracepoint *) -1 || t1 == t2) ! { ! t2->pass_count = count; ! if (modify_tracepoint_hook) ! modify_tracepoint_hook (t2); ! if (from_tty) ! printf_filtered ("Setting tracepoint %d's passcount to %d\n", ! t2->number, count); ! } } ! if (! all) t1 = get_tracepoint_by_number (&args, 1); } while (*args); --- 730,745 ---- { ALL_TRACEPOINTS (t2) if (t1 == (struct tracepoint *) -1 || t1 == t2) ! { ! t2->pass_count = count; ! if (modify_tracepoint_hook) ! modify_tracepoint_hook (t2); ! if (from_tty) ! printf_filtered ("Setting tracepoint %d's passcount to %d\n", ! t2->number, count); ! } } ! if (!all) t1 = get_tracepoint_by_number (&args, 1); } while (*args); *************** *** 1055,1061 **** struct memrange { ! int type; /* 0 for absolute memory range, else basereg number */ bfd_signed_vma start; bfd_signed_vma end; }; --- 1055,1061 ---- struct memrange { ! int type; /* 0 for absolute memory range, else basereg number */ bfd_signed_vma start; bfd_signed_vma end; }; *************** *** 1215,1221 **** sprintf_vma (tmp, offset); printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n", ! SYMBOL_NAME (sym), len, tmp /* address */); } add_memrange (collect, -1, offset, len); /* 0 == memory */ break; --- 1215,1221 ---- sprintf_vma (tmp, offset); printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n", ! SYMBOL_NAME (sym), len, tmp /* address */ ); } add_memrange (collect, -1, offset, len); /* 0 == memory */ break; *************** *** 1320,1326 **** switch (SYMBOL_CLASS (sym)) { default: ! warning ("don't know how to trace local symbol %s", SYMBOL_NAME (sym)); case LOC_LOCAL: case LOC_STATIC: --- 1320,1326 ---- switch (SYMBOL_CLASS (sym)) { default: ! warning ("don't know how to trace local symbol %s", SYMBOL_NAME (sym)); case LOC_LOCAL: case LOC_STATIC: *************** *** 1418,1426 **** sprintf_vma (tmp2, list->list[i].start); if (info_verbose) { ! printf_filtered ("(%d, %s, %ld)\n", ! list->list[i].type, ! tmp2, (long) (list->list[i].end - list->list[i].start)); } if (count + 27 > MAX_AGENT_EXPR_LEN) --- 1418,1426 ---- sprintf_vma (tmp2, list->list[i].start); if (info_verbose) { ! printf_filtered ("(%d, %s, %ld)\n", ! list->list[i].type, ! tmp2, (long) (list->list[i].end - list->list[i].start)); } if (count + 27 > MAX_AGENT_EXPR_LEN) *************** *** 1431,1437 **** end = temp_buf; } ! sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) (list->list[i].end - list->list[i].start)); --- 1431,1437 ---- end = temp_buf; } ! sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) (list->list[i].end - list->list[i].start)); *************** *** 1719,1725 **** size = bfd_get_section_size_before_reloc (s); sprintf_vma (tmp1, lma); sprintf_vma (tmp2, lma + size); ! sprintf (target_buf + strlen (target_buf), ":%s,%s", tmp1, tmp2); } if (anysecs) --- 1719,1725 ---- size = bfd_get_section_size_before_reloc (s); sprintf_vma (tmp1, lma); sprintf_vma (tmp2, lma + size); ! sprintf (target_buf + strlen (target_buf), ":%s,%s", tmp1, tmp2); } if (anysecs) *************** *** 1762,1768 **** char tmp[40]; sprintf_vma (tmp, t->address); ! sprintf (buf, "QTDP:%x:%s:%c:%x:%x", t->number, tmp, /* address */ t->enabled == enabled ? 'E' : 'D', t->step_count, t->pass_count); --- 1762,1768 ---- char tmp[40]; sprintf_vma (tmp, t->address); ! sprintf (buf, "QTDP:%x:%s:%c:%x:%x", t->number, tmp, /* address */ t->enabled == enabled ? 'E' : 'D', t->step_count, t->pass_count); *************** *** 1788,1794 **** { QUIT; /* allow user to bail out with ^C */ sprintf (buf, "QTDP:-%x:%s:%s%c", ! t->number, tmp, /* address */ tdp_actions[ndx], ((tdp_actions[ndx + 1] || stepping_actions) ? '-' : 0)); --- 1788,1794 ---- { QUIT; /* allow user to bail out with ^C */ sprintf (buf, "QTDP:-%x:%s:%s%c", ! t->number, tmp, /* address */ tdp_actions[ndx], ((tdp_actions[ndx + 1] || stepping_actions) ? '-' : 0)); *************** *** 1804,1810 **** { QUIT; /* allow user to bail out with ^C */ sprintf (buf, "QTDP:-%x:%s:%s%s%s", ! t->number, tmp, /* address */ ((ndx == 0) ? "S" : ""), stepping_actions[ndx], (stepping_actions[ndx + 1] ? "-" : "")); --- 1804,1810 ---- { QUIT; /* allow user to bail out with ^C */ sprintf (buf, "QTDP:-%x:%s:%s%s%s", ! t->number, tmp, /* address */ ((ndx == 0) ? "S" : ""), stepping_actions[ndx], (stepping_actions[ndx + 1] ? "-" : "")); *************** *** 2139,2145 **** struct symtabs_and_lines sals; struct symtab_and_line sal; struct cleanup *old_chain; ! char startpc_str[40], endpc_str[40]; if (target_is_remote ()) { --- 2139,2145 ---- struct symtabs_and_lines sals; struct symtab_and_line sal; struct cleanup *old_chain; ! char startpc_str[40], endpc_str[40]; if (target_is_remote ()) { *************** *** 2232,2238 **** if (target_is_remote ()) { if (args == 0 || *args == 0) ! { /* XXX FIXME: what should default behavior be? */ printf_filtered ("Usage: tfind range ,\n"); return; } --- 2232,2238 ---- if (target_is_remote ()) { if (args == 0 || *args == 0) ! { /* XXX FIXME: what should default behavior be? */ printf_filtered ("Usage: tfind range ,\n"); return; } *************** *** 2273,2279 **** if (target_is_remote ()) { if (args == 0 || *args == 0) ! { /* XXX FIXME: what should default behavior be? */ printf_filtered ("Usage: tfind outside ,\n"); return; } --- 2273,2279 ---- if (target_is_remote ()) { if (args == 0 || *args == 0) ! { /* XXX FIXME: what should default behavior be? */ printf_filtered ("Usage: tfind outside ,\n"); return; } *************** *** 2388,2394 **** if (args == 0 || *args == 0) error ("requires an argument (function, line or *addr) to define a scope"); ! sals = decode_line_1 (&args, 1, NULL, 0, &canonical); if (sals.nelts == 0) return; /* presumably decode_line_1 has already warned */ --- 2388,2394 ---- if (args == 0 || *args == 0) error ("requires an argument (function, line or *addr) to define a scope"); ! sals = decode_line_1 (&args, 1, NULL, 0, &canonical, USER_CHOICE); if (sals.nelts == 0) return; /* presumably decode_line_1 has already warned */