diff options
Diffstat (limited to 'gdb/symtab.c')
| -rw-r--r-- | gdb/symtab.c | 761 |
1 files changed, 612 insertions, 149 deletions
diff --git a/gdb/symtab.c b/gdb/symtab.c index 5b36c71..a8108d8 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -1,22 +1,21 @@ /* Symbol table lookup for the GNU debugger, GDB. - Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc. + Copyright (C) 1986, 1987, 1988, 1989 Free Software Foundation, Inc. -GDB is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY. No author or distributor accepts responsibility to anyone -for the consequences of using it or for whether it serves any -particular purpose or works at all, unless he says so in writing. -Refer to the GDB General Public License for full details. +This file is part of GDB. -Everyone is granted permission to copy, modify and redistribute GDB, -but only under the conditions described in the GDB General Public -License. A copy of this license is supposed to have been given to you -along with GDB so you can know your rights and responsibilities. It -should be in a file named COPYING. Among other things, the copyright -notice and this notice must be preserved on all copies. +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. -In other words, go ahead and share GDB, but don't try to stop -anyone else from sharing it farther. Help stamp out software hoarding! -*/ +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "defs.h" #include "symtab.h" @@ -26,6 +25,7 @@ anyone else from sharing it farther. Help stamp out software hoarding! #include <obstack.h> #include <assert.h> +char *index (); /* Allocate an obstack to hold objects that should be freed when we load a new symbol table. @@ -78,42 +78,88 @@ struct partial_symtab *lookup_partial_symtab (); struct symtab *psymtab_to_symtab (); static struct partial_symbol *lookup_partial_symbol (); -/* Lookup the symbol table of a source file named NAME. If there - isn't any symtab for it, lookup the psymtab and read in the - symbtab. */ +/* 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. */ -struct symtab * -lookup_symtab (name) +static struct symtab * +lookup_symtab_1 (name) char *name; { register struct symtab *s; register struct partial_symtab *ps; - register char *copy; + register char *slash = index (name, '/'); + register int len = strlen (name); for (s = symtab_list; s; s = s->next) if (!strcmp (name, s->filename)) return s; + for (ps = partial_symtab_list; ps; ps = ps->next) + if (!strcmp (name, ps->filename)) + { + if (ps->readin) + fatal ("Internal: readin pst found when no symtab found."); + s = psymtab_to_symtab (ps); + return s; + } + + if (!slash) + { + for (s = symtab_list; s; s = s->next) + { + int l = strlen (s->filename); + + if (s->filename[l - len -1] == '/' + && !strcmp (s->filename + l - len, name)) + return s; + } + + for (ps = partial_symtab_list; ps; ps = ps->next) + { + int l = strlen (ps->filename); + + if (ps->filename[l - len - 1] == '/' + && !strcmp (ps->filename + l - len, name)) + { + if (ps->readin) + fatal ("Internal: readin pst found when no symtab found."); + s = psymtab_to_symtab (ps); + return s; + } + } + } + return 0; +} + +/* Lookup the symbol table of a source file named NAME. Try a couple + of variations if the first lookup doesn't work. */ + +struct symtab * +lookup_symtab (name) + char *name; +{ + register struct symtab *s; + register char *copy; + + s = lookup_symtab_1 (name); + if (s) return s; + /* If name not found as specified, see if adding ".c" helps. */ copy = (char *) alloca (strlen (name) + 3); strcpy (copy, name); strcat (copy, ".c"); - for (s = symtab_list; s; s = s->next) - if (!strcmp (copy, s->filename)) - return s; - - ps = lookup_partial_symtab (name); - if (ps) - { - s = psymtab_to_symtab (ps); - return s; - } + s = lookup_symtab_1 (copy); + if (s) return s; + /* We didn't find anything; die. */ return 0; } -/* Lookup the partial symbol table of a source file named NAME. */ +/* Lookup the partial symbol table of a source file named NAME. This + only returns true on an exact match (ie. this semantics are + different from lookup_symtab. */ struct partial_symtab * lookup_partial_symtab (name) @@ -126,15 +172,6 @@ char *name; if (!strcmp (name, s->filename)) return s; - /* If name not found as specified, see if adding ".c" helps. */ - - copy = (char *) alloca (strlen (name) + 3); - strcpy (copy, name); - strcat (copy, ".c"); - for (s = partial_symtab_list; s; s = s->next) - if (!strcmp (copy, s->filename)) - return s; - return 0; } @@ -241,6 +278,41 @@ lookup_enum (name, block) return SYMBOL_TYPE (sym); } +/* Given a type TYPE, lookup the type of the component of type named + NAME. */ + +struct type * +lookup_struct_elt_type (type, name) + struct type *type; + char *name; +{ + struct type *t; + int i; + char *errmsg; + + if (TYPE_CODE (type) != TYPE_CODE_STRUCT + && TYPE_CODE (type) != TYPE_CODE_UNION) + { + terminal_ours (); + fflush (stdout); + fprintf (stderr, "Type "); + type_print (type, "", stderr, -1); + fprintf (stderr, " is not a structure or union type.\n"); + return_to_top_level (); + } + + for (i = TYPE_NFIELDS (type) - 1; i >= 0; i--) + if (!strcmp (TYPE_FIELD_NAME (type, i), name)) + return TYPE_FIELD_TYPE (type, i); + + terminal_ours (); + fflush (stdout); + fprintf (stderr, "Type "); + type_print (type, "", stderr, -1); + fprintf (stderr, " has no component named %s\n", name); + return_to_top_level (); +} + /* Given a type TYPE, return a type of pointers to that type. May need to construct such a type if this is the first use. @@ -361,6 +433,73 @@ lookup_member_type (type, domain) return mtype; } +struct type * +lookup_method_type (type, domain, args) + struct type *type, *domain, **args; +{ + register struct type *mtype = TYPE_MAIN_VARIANT (type); + struct type *main_type; + + main_type = mtype; + while (mtype) + { + if (TYPE_DOMAIN_TYPE (mtype) == domain) + { + struct type **t1 = args; + struct type **t2 = TYPE_ARG_TYPES (mtype); + if (t2) + { + int i; + for (i = 0; t1[i] != 0 && t1[i]->code != TYPE_CODE_VOID; i++) + if (t1[i] != t2[i]) + break; + if (t1[i] == t2[i]) + return mtype; + } + } + mtype = TYPE_NEXT_VARIANT (mtype); + } + + /* This is the first time anyone wanted this member type. */ + if (TYPE_FLAGS (type) & TYPE_FLAG_PERM) + mtype = (struct type *) xmalloc (sizeof (struct type)); + else + mtype = (struct type *) obstack_alloc (symbol_obstack, + sizeof (struct type)); + + bzero (mtype, sizeof (struct type)); + if (main_type == 0) + main_type = mtype; + else + { + TYPE_NEXT_VARIANT (mtype) = TYPE_NEXT_VARIANT (main_type); + TYPE_NEXT_VARIANT (main_type) = mtype; + } + TYPE_MAIN_VARIANT (mtype) = main_type; + TYPE_TARGET_TYPE (mtype) = type; + TYPE_DOMAIN_TYPE (mtype) = domain; + TYPE_ARG_TYPES (mtype) = args; + /* New type is permanent if type pointed to is permanent. */ + if (TYPE_FLAGS (type) & TYPE_FLAG_PERM) + TYPE_FLAGS (mtype) |= TYPE_FLAG_PERM; + + /* In practice, this is never used. */ + TYPE_LENGTH (mtype) = 1; + TYPE_CODE (mtype) = TYPE_CODE_METHOD; + +#if 0 + /* Now splice in the new member pointer type. */ + if (main_type) + { + /* This type was not "smashed". */ + TYPE_CHAIN (mtype) = TYPE_CHAIN (main_type); + TYPE_CHAIN (main_type) = mtype; + } +#endif + + return mtype; +} + /* Given a type TYPE, return a type which has offset OFFSET, via_virtual VIA_VIRTUAL, and via_public VIA_PUBLIC. May need to construct such a type if none exists. */ @@ -375,7 +514,7 @@ lookup_basetype_type (type, offset, via_virtual, via_public) if (offset != 0) { - printf ("type offset non-zero in lookup_basetype_type"); + printf ("Internal error: type offset non-zero in lookup_basetype_type"); offset = 0; } @@ -452,6 +591,38 @@ lookup_function_type (type) return ptype; } +/* Create an array type. Elements will be of type TYPE, and there will + be NUM of them. + + Eventually this should be extended to take two more arguments which + specify the bounds of the array and the type of the index. + It should also be changed to be a "lookup" function, with the + appropriate data structures added to the type field. + Then read array type should call here. */ + +struct type * +create_array_type (element_type, number) + struct type *element_type; + int number; +{ + struct type *result_type = (struct type *) + obstack_alloc (symbol_obstack, sizeof (struct type)); + + bzero (result_type, sizeof (struct type)); + + TYPE_CODE (result_type) = TYPE_CODE_ARRAY; + TYPE_TARGET_TYPE (result_type) = element_type; + TYPE_LENGTH (result_type) = number * TYPE_LENGTH (element_type); + TYPE_NFIELDS (result_type) = 1; + TYPE_FIELDS (result_type) = + (struct field *) obstack_alloc (symbol_obstack, sizeof (struct field)); + TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int; + TYPE_VPTR_FIELDNO (result_type) = -1; + + return result_type; +} + + /* Smash TYPE to be a type of pointers to TO_TYPE. If TO_TYPE is not permanent and has no pointer-type yet, record TYPE as its pointer-type. */ @@ -460,6 +631,8 @@ void smash_to_pointer_type (type, to_type) struct type *type, *to_type; { + int type_permanent = (TYPE_FLAGS (type) & TYPE_FLAG_PERM); + bzero (type, sizeof (struct type)); TYPE_TARGET_TYPE (type) = to_type; /* We assume the machine has only one representation for pointers! */ @@ -468,8 +641,12 @@ smash_to_pointer_type (type, to_type) TYPE_MAIN_VARIANT (type) = type; + if (type_permanent) + TYPE_FLAGS (type) |= TYPE_FLAG_PERM; + if (TYPE_POINTER_TYPE (to_type) == 0 - && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM)) + && (!(TYPE_FLAGS (to_type) & TYPE_FLAG_PERM) + || type_permanent)) { TYPE_POINTER_TYPE (to_type) = type; } @@ -492,6 +669,24 @@ smash_to_member_type (type, domain, to_type) TYPE_MAIN_VARIANT (type) = lookup_member_type (domain, to_type); } +/* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE. */ + +void +smash_to_method_type (type, domain, to_type, args) + struct type *type, *domain, *to_type, **args; +{ + bzero (type, sizeof (struct type)); + TYPE_TARGET_TYPE (type) = to_type; + TYPE_DOMAIN_TYPE (type) = domain; + TYPE_ARG_TYPES (type) = args; + + /* In practice, this is never needed. */ + TYPE_LENGTH (type) = 1; + TYPE_CODE (type) = TYPE_CODE_METHOD; + + TYPE_MAIN_VARIANT (type) = lookup_method_type (domain, to_type, args); +} + /* Smash TYPE to be a type of reference to TO_TYPE. If TO_TYPE is not permanent and has no pointer-type yet, record TYPE as its pointer-type. */ @@ -500,6 +695,8 @@ void smash_to_reference_type (type, to_type) struct type *type, *to_type; { + int type_permanent = (TYPE_FLAGS (type) & TYPE_FLAG_PERM); + bzero (type, sizeof (struct type)); TYPE_TARGET_TYPE (type) = to_type; /* We assume the machine has only one representation for pointers! */ @@ -508,8 +705,12 @@ smash_to_reference_type (type, to_type) TYPE_MAIN_VARIANT (type) = type; + if (type_permanent) + TYPE_FLAGS (type) |= TYPE_FLAG_PERM; + if (TYPE_REFERENCE_TYPE (to_type) == 0 - && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM)) + && (!(TYPE_FLAGS (to_type) & TYPE_FLAG_PERM) + || type_permanent)) { TYPE_REFERENCE_TYPE (to_type) = type; } @@ -523,19 +724,76 @@ void smash_to_function_type (type, to_type) struct type *type, *to_type; { + int type_permanent = (TYPE_FLAGS (type) & TYPE_FLAG_PERM); + bzero (type, sizeof (struct type)); TYPE_TARGET_TYPE (type) = to_type; TYPE_LENGTH (type) = 1; TYPE_CODE (type) = TYPE_CODE_FUNC; TYPE_NFIELDS (type) = 0; + if (type_permanent) + TYPE_FLAGS (type) |= TYPE_FLAG_PERM; + if (TYPE_FUNCTION_TYPE (to_type) == 0 - && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM)) + && (!(TYPE_FLAGS (to_type) & TYPE_FLAG_PERM) + || type_permanent)) { TYPE_FUNCTION_TYPE (to_type) = type; } } +/* Find which partial symtab on the partial_symtab_list contains + PC. Return 0 if none. */ + +struct partial_symtab * +find_pc_psymtab (pc) + register CORE_ADDR pc; +{ + register struct partial_symtab *ps; + + for (ps = partial_symtab_list; ps; ps = ps->next) + if (pc >= ps->textlow && pc < ps->texthigh) + return ps; + + return 0; +} + +/* Find which partial symbol within a psymtab contains PC. Return 0 + if none. Check all psymtabs if PSYMTAB is 0. */ +struct partial_symbol * +find_pc_psymbol (psymtab, pc) + struct partial_symtab *psymtab; + CORE_ADDR pc; +{ + struct partial_symbol *best, *p; + int best_pc; + + if (!psymtab) + psymtab = find_pc_psymtab (pc); + if (!psymtab) + return 0; + + best_pc = psymtab->textlow - 1; + + for (p = static_psymbols.list + psymtab->statics_offset; + (p - (static_psymbols.list + psymtab->statics_offset) + < psymtab->n_static_syms); + p++) + if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE + && SYMBOL_CLASS (p) == LOC_BLOCK + && pc >= SYMBOL_VALUE (p) + && SYMBOL_VALUE (p) > best_pc) + { + best_pc = SYMBOL_VALUE (p); + best = p; + } + if (best_pc == psymtab->textlow - 1) + return 0; + return best; +} + + static struct symbol *lookup_block_symbol (); /* Find the definition for a specified symbol name NAME @@ -602,8 +860,43 @@ lookup_symbol (name, block, namespace, is_a_field_of_this) } } + /* Check for the possibility of the symbol being a global function + that is stored on the misc function vector. Eventually, all + global symbols might be resolved in this way. */ + + if (namespace == VAR_NAMESPACE) + { + int index = lookup_misc_func (name); + + if (index != -1) + { + ps = find_pc_psymtab (misc_function_vector[index].address); + if (ps && !ps->readin) + { + s = psymtab_to_symtab (ps); + bv = BLOCKVECTOR (s); + block = BLOCKVECTOR_BLOCK (bv, 0); + sym = lookup_block_symbol (block, name, namespace); + /* sym == 0 if symbol was found in the psymtab but not + in the symtab. + Return 0 to use the misc_function definition of "foo_". + + This happens for Fortran "foo_" symbols, + which are "foo" in the symtab. + + This can also happen if "asm" is used to make a + regular symbol but not a debugging symbol, e.g. + asm(".globl _main"); + asm("_main:"); + */ + + return sym; + } + } + } + for (ps = partial_symtab_list; ps; ps = ps->next) - if (lookup_partial_symbol (ps, name, 1, namespace)) + if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace)) { s = psymtab_to_symtab(ps); bv = BLOCKVECTOR (s); @@ -631,7 +924,7 @@ lookup_symbol (name, block, namespace, is_a_field_of_this) } for (ps = partial_symtab_list; ps; ps = ps->next) - if (lookup_partial_symbol (ps, name, 0, namespace)) + if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace)) { s = psymtab_to_symtab(ps); bv = BLOCKVECTOR (s); @@ -659,8 +952,8 @@ lookup_partial_symbol (pst, name, global, namespace) int length = (global ? pst->n_global_syms : pst->n_static_syms); start = (global ? - global_psymbols + pst->globals_offset : - static_psymbols + pst->statics_offset ); + global_psymbols.list + pst->globals_offset : + static_psymbols.list + pst->statics_offset ); if (!length) return (struct partial_symbol *) 0; @@ -790,8 +1083,9 @@ lookup_block_symbol (block, name, namespace) && !strcmp (SYMBOL_NAME (sym), name) && SYMBOL_NAMESPACE (sym) == namespace) { - if (SYMBOL_CLASS (sym) == LOC_ARG || - SYMBOL_CLASS (sym) == LOC_REGPARM) + if (SYMBOL_CLASS (sym) == LOC_ARG + || SYMBOL_CLASS (sym) == LOC_REF_ARG + || SYMBOL_CLASS (sym) == LOC_REGPARM) parameter_sym = sym; else return sym; @@ -816,7 +1110,7 @@ block_function (bl) /* Subroutine of find_pc_line */ -static struct symtab * +struct symtab * find_pc_symtab (pc) register CORE_ADDR pc; { @@ -837,12 +1131,14 @@ find_pc_symtab (pc) } if (!s) - for (ps = partial_symtab_list; ps; ps = ps->next) - if (pc >= ps->textlow && pc < ps->texthigh) - { - s = psymtab_to_symtab (ps); - break; - } + { + ps = find_pc_psymtab (pc); + if (ps && ps->readin) + fatal ("Internal error: pc in read in psymtab, but not in symtab."); + + if (ps) + s = psymtab_to_symtab (ps); + } return s; } @@ -1176,7 +1472,8 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) { (*argptr)++; pc = parse_and_eval_address_1 (argptr); - values.sals = (struct symtab_and_line *)malloc (sizeof (struct symtab_and_line)); + values.sals = (struct symtab_and_line *) + malloc (sizeof (struct symtab_and_line)); values.nelts = 1; values.sals[0] = find_pc_line (pc, 0); values.sals[0].pc = pc; @@ -1250,29 +1547,51 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) else while (t) { class_name = TYPE_NAME (t); - while (*class_name++ != ' '); - - sym_class = lookup_symbol (class_name, 0, STRUCT_NAMESPACE, 0); - for (method_counter = TYPE_NFN_FIELDS (SYMBOL_TYPE (sym_class)) - 1; - method_counter >= 0; - --method_counter) + /* Ignore this class if it doesn't have a name. + This prevents core dumps, but is just a workaround + because we might not find the function in + certain cases, such as + struct D {virtual int f();} + struct C : D {virtual int g();} + (in this case g++ 1.35.1- does not put out a name + for D as such, it defines type 19 (for example) in + the same stab as C, and then does a + .stabs "D:T19" and a .stabs "D:t19". + Thus + "break C::f" should not be looking for field f in + the class named D, + but just for the field f in the baseclasses of C + (no matter what their names). + + However, I don't know how to replace the code below + that depends on knowing the name of D. */ + if (class_name) { - int field_counter; - struct fn_field *f = - TYPE_FN_FIELDLIST1 (SYMBOL_TYPE (sym_class), method_counter); - - method_name = TYPE_FN_FIELDLIST_NAME (SYMBOL_TYPE (sym_class), method_counter); - if (!strcmp (copy, method_name)) - for (field_counter = TYPE_FN_FIELDLIST_LENGTH (SYMBOL_TYPE (sym_class), method_counter) - 1; - field_counter >= 0; - --field_counter) - { - phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter); - physnames[i1] = (char*) alloca (strlen (phys_name) + 1); - strcpy (physnames[i1], phys_name); - sym_arr[i1] = lookup_symbol (phys_name, SYMBOL_BLOCK_VALUE (sym_class), VAR_NAMESPACE, 0); - if (sym_arr[i1]) i1++; - } + while (*class_name++ != ' '); + + sym_class = lookup_symbol (class_name, 0, STRUCT_NAMESPACE, 0); + for (method_counter = TYPE_NFN_FIELDS (SYMBOL_TYPE (sym_class)) - 1; + method_counter >= 0; + --method_counter) + { + int field_counter; + struct fn_field *f = + TYPE_FN_FIELDLIST1 (SYMBOL_TYPE (sym_class), method_counter); + + method_name = TYPE_FN_FIELDLIST_NAME (SYMBOL_TYPE (sym_class), method_counter); + if (!strcmp (copy, method_name)) + /* Find all the fields with that name. */ + for (field_counter = TYPE_FN_FIELDLIST_LENGTH (SYMBOL_TYPE (sym_class), method_counter) - 1; + field_counter >= 0; + --field_counter) + { + phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter); + physnames[i1] = (char*) alloca (strlen (phys_name) + 1); + strcpy (physnames[i1], phys_name); + sym_arr[i1] = lookup_symbol (phys_name, SYMBOL_BLOCK_VALUE (sym_class), VAR_NAMESPACE, 0); + if (sym_arr[i1]) i1++; + } + } } if (TYPE_N_BASECLASSES (t)) t = TYPE_BASECLASS(t, 1); @@ -1282,6 +1601,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) if (i1 == 1) { + /* There is exactly one field with that name. */ sym = sym_arr[0]; if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK) @@ -1303,6 +1623,8 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) } if (i1 > 0) { + /* There is more than one field with that name + (overloaded). Ask the user which one to use. */ return decode_line_2 (argptr, sym_arr, physnames, i1, funfirstline); } @@ -1361,7 +1683,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) { if (symtab_list == 0 && partial_symtab_list == 0) error ("No symbol table is loaded. Use the \"symbol-file\" command."); - select_source_symtab (symtab_list); + select_source_symtab (0); default_symtab = current_source_symtab; default_line = current_source_line; } @@ -1424,7 +1746,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) if (funfirstline) SKIP_PROLOGUE (pc); value = find_pc_line (pc, 0); -#ifdef convex +#ifdef PROLOGUE_FIRSTLINE_OVERLAP /* Convex: no need to suppress code on first line, if any */ value.pc = pc; #else @@ -1485,7 +1807,7 @@ decode_line_2 (argptr, sym_arr, physnames, nelts, funfirstline) char *getenv(); struct symtabs_and_lines values, return_values; register CORE_ADDR pc; - char *args, *arg1, *gdb_read_line (); + char *args, *arg1, *command_line_input (); int i; char *prompt; @@ -1518,7 +1840,7 @@ decode_line_2 (argptr, sym_arr, physnames, nelts, funfirstline) printf("%s ",prompt); fflush(stdout); - args = gdb_read_line (0, 0); + args = command_line_input (0, 0); if (args == 0) error_no_arg ("one or more choice numbers"); @@ -1584,10 +1906,8 @@ lookup_misc_func (name) } /* - * Slave routine for sources_info + * Slave routine for sources_info. Force line breaks at ,'s. */ -static int rows_output; - static void output_source_filename (name, next) char *name; @@ -1597,26 +1917,19 @@ int next; if (column != 0 && column + strlen (name) >= 70) { - printf ("\n"); + printf_filtered ("\n"); column = 0; - if (++rows_output >= 21) - { - printf ("--Type Return to print more--"); - fflush (stdout); - gdb_read_line (0, 0); - rows_output = 0; - } } else if (column != 0) { - printf (" "); + printf_filtered (" "); column++; } - printf ("%s", name); + printf_filtered ("%s", name); column += strlen (name); if (next) { - printf (","); + printf_filtered (","); column++; } @@ -1636,17 +1949,18 @@ sources_info () return; } - printf ("Source files for which symbols have been read in:\n\n"); - rows_output = 2; + printf_filtered ("Source files for which symbols have been read in:\n\n"); + for (s = symtab_list; s; s = s->next) output_source_filename (s->filename, s->next); - printf ("\n\n"); + printf_filtered ("\n\n"); - printf ("Source files for which symbols will be read in on demand:\n\n"); - rows_output += 2; + printf_filtered ("Source files for which symbols will be read in on demand:\n\n"); + for (ps = partial_symtab_list; ps; ps = ps->next) - output_source_filename (ps->filename, ps->next); - printf ("\n"); + if (!ps->readin) + output_source_filename (ps->filename, ps->next); + printf_filtered ("\n"); } /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP. @@ -1654,14 +1968,6 @@ sources_info () If CLASS is 1, list only functions. If CLASS is 2, list only type names. */ -#define MORE \ -{ print_count++; \ - if (print_count >= 21) \ - { printf ("--Type Return to print more--"); \ - print_count = 0; \ - fflush (stdout); \ - gdb_read_line (0, 0); } } - static void sort_block_syms (); static void @@ -1687,12 +1993,6 @@ list_symbols (regexp, class) if (val = (char *) re_comp (regexp)) error ("Invalid regexp: %s", val); - printf (regexp - ? "All %ss matching regular expression \"%s\":\n" - : "All defined %ss:\n", - classnames[class], - regexp); - /* Search through the partial_symtab_list *first* for all symbols matching the regexp. That way we don't have to reproduce all of the machinery below. */ @@ -1701,20 +2001,22 @@ list_symbols (regexp, class) struct partial_symbol *bound, *gbound, *sbound; int keep_going = 1; - gbound = global_psymbols + ps->globals_offset + ps->n_global_syms; - sbound = static_psymbols + ps->statics_offset + ps->n_static_syms; + if (ps->readin) continue; + + gbound = global_psymbols.list + ps->globals_offset + ps->n_global_syms; + sbound = static_psymbols.list + ps->statics_offset + ps->n_static_syms; bound = gbound; /* Go through all of the symbols stored in a partial symtab in one loop. */ - psym = global_psymbols + ps->globals_offset; + psym = global_psymbols.list + ps->globals_offset; while (keep_going) { if (psym >= bound) { if (bound == gbound && ps->n_static_syms != 0) { - psym = static_psymbols + ps->statics_offset; + psym = static_psymbols.list + ps->statics_offset; bound = sbound; } else @@ -1741,6 +2043,30 @@ list_symbols (regexp, class) } } + /* Printout here so as to get after the "Reading in symbols" + messages which will be generated above. */ + printf_filtered (regexp + ? "All %ss matching regular expression \"%s\":\n" + : "All defined %ss:\n", + classnames[class], + regexp); + + /* Here, *if* the class is correct (function only, right now), we + should search through the misc function vector for symbols that + match and call find_pc_psymtab on them. If find_pc_psymtab returns + 0, don't worry about it (already read in or no debugging info). */ + + if (class == 1) + { + for (i = 0; i < misc_function_count; i++) + if (regexp == 0 || re_exec (misc_function_vector[i].name)) + { + ps = find_pc_psymtab (misc_function_vector[i].address); + if (ps && !ps->readin) + psymtab_to_symtab (ps); + } + } + for (s = symtab_list; s; s = s->next) { found_in_file = 0; @@ -1770,29 +2096,15 @@ list_symbols (regexp, class) { if (!found_in_file) { - printf ("\nFile %s:\n", s->filename); + printf_filtered ("\nFile %s:\n", s->filename); print_count += 2; } found_in_file = 1; -#if 0 - MORE; -#else - { - print_count++; - if (print_count >= 21) - { - printf ("--Type Return to print more--"); - print_count = 0; - fflush (stdout); - gdb_read_line (0, 0); - } - } -#endif if (class != 2 && i == 1) - printf ("static "); + printf_filtered ("static "); if (class == 2 && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE) - printf ("typedef "); + printf_filtered ("typedef "); if (class < 3) { @@ -1800,7 +2112,15 @@ list_symbols (regexp, class) (SYMBOL_CLASS (sym) == LOC_TYPEDEF ? "" : SYMBOL_NAME (sym)), stdout, 0); - printf (";\n"); + + if (class == 2 + && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE + && (TYPE_NAME ((SYMBOL_TYPE (sym))) == 0 + || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (sym))), + SYMBOL_NAME (sym)))) + printf_filtered (" %s", SYMBOL_NAME (sym)); + + printf_filtered (";\n"); } else { @@ -1812,12 +2132,6 @@ list_symbols (regexp, class) type_print_method_args (TYPE_FN_FIELD_ARGS (t, i), buf, name, stdout); # endif } - if (class == 2 - && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE - && (TYPE_NAME ((SYMBOL_TYPE (sym))) == 0 - || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (sym))), - SYMBOL_NAME (sym)))) - printf (" %s", SYMBOL_NAME (sym)); } } } @@ -1915,6 +2229,155 @@ contained_in (a, b) return a->startaddr >= b->startaddr && a->endaddr <= b->endaddr; } + +/* Helper routine for make_symbol_completion_list. */ + +int return_val_size, return_val_index; +char **return_val; + +void +completion_list_add_symbol (symname) + char *symname; +{ + if (return_val_index + 3 > return_val_size) + return_val = + (char **)xrealloc (return_val, + (return_val_size *= 2) * sizeof (char *)); + + return_val[return_val_index] = + (char *)xmalloc (1 + strlen (symname)); + + strcpy (return_val[return_val_index], symname); + + return_val[++return_val_index] = (char *)NULL; +} + +/* Return a NULL terminated array of all symbols (regardless of class) which + begin by matching TEXT. If the answer is no symbols, then the return value + is an array which contains only a NULL pointer. + + Problem: All of the symbols have to be copied because readline + frees them. I'm not going to worry about this; hopefully there + won't be that many. */ + +char ** +make_symbol_completion_list (text) + char *text; +{ + register struct symtab *s; + register struct partial_symtab *ps; + register struct blockvector *bv; + struct blockvector *prev_bv = 0; + register struct block *b, *surrounding_static_block; + extern struct block *get_selected_block (); + register int i, j; + register struct symbol *sym; + struct partial_symbol *psym; + + int text_len = strlen (text); + return_val_size = 100; + return_val_index = 0; + return_val = + (char **)xmalloc ((1 + return_val_size) *sizeof (char *)); + return_val[0] = (char *)NULL; + + /* Look through the partial symtabs for all symbols which begin + by matching TEXT. Add each one that you find to the list. */ + + for (ps = partial_symtab_list; ps; ps = ps->next) + { + /* If the psymtab's been read in we'll get it when we search + through the blockvector. */ + if (ps->readin) continue; + + for (psym = global_psymbols.list + ps->globals_offset; + psym < (global_psymbols.list + ps->globals_offset + + ps->n_global_syms); + psym++) + { + QUIT; /* If interrupted, then quit. */ + if ((strncmp (SYMBOL_NAME (psym), text, text_len) == 0)) + completion_list_add_symbol (SYMBOL_NAME (psym)); + } + + for (psym = static_psymbols.list + ps->statics_offset; + psym < (static_psymbols.list + ps->statics_offset + + ps->n_static_syms); + psym++) + { + QUIT; + if ((strncmp (SYMBOL_NAME (psym), text, text_len) == 0)) + completion_list_add_symbol (SYMBOL_NAME (psym)); + } + } + + /* At this point scan through the misc function vector and add each + symbol you find to the list. Eventually we want to ignore + anything that isn't a text symbol (everything else will be + handled by the psymtab code above). */ + + for (i = 0; i < misc_function_count; i++) + if (!strncmp (text, misc_function_vector[i].name, text_len)) + completion_list_add_symbol (misc_function_vector[i].name); + + /* Search upwards from currently selected frame (so that we can + complete on local vars. */ + for (b = get_selected_block (); b; b = BLOCK_SUPERBLOCK (b)) + { + if (!BLOCK_SUPERBLOCK (b)) + surrounding_static_block = b; /* For elmin of dups */ + + /* Also catch fields of types defined in this places which + match our text string. Only complete on types visible + from current context. */ + for (i = 0; i < BLOCK_NSYMS (b); i++) + { + register struct symbol *sym = BLOCK_SYM (b, i); + + if (!strncmp (SYMBOL_NAME (sym), text, text_len)) + completion_list_add_symbol (SYMBOL_NAME (sym)); + + if (SYMBOL_CLASS (sym) == LOC_TYPEDEF) + { + struct type *t = SYMBOL_TYPE (sym); + enum type_code c = TYPE_CODE (t); + + if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT) + for (j = 0; j < TYPE_NFIELDS (t); j++) + if (TYPE_FIELD_NAME (t, j) && + !strncmp (TYPE_FIELD_NAME (t, j), text, text_len)) + completion_list_add_symbol (TYPE_FIELD_NAME (t, j)); + } + } + } + + /* Go through the symtabs and check the externs and statics for + symbols which match. */ + + for (s = symtab_list; s; s = s->next) + { + struct block *b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 0); + + for (i = 0; i < BLOCK_NSYMS (b); i++) + if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b, i)), text, text_len)) + completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b, i))); + } + + for (s = symtab_list; s; s = s->next) + { + struct block *b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1); + + /* Don't do this block twice. */ + if (b == surrounding_static_block) continue; + + for (i = 0; i < BLOCK_NSYMS (b); i++) + if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b, i)), text, text_len)) + completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b, i))); + } + + return (return_val); +} + void _initialize_symtab () { @@ -1935,7 +2398,7 @@ are listed."); obstack_init (symbol_obstack); obstack_init (psymbol_obstack); - builtin_type_void = init_type (TYPE_CODE_VOID, 0, 0, "void"); + builtin_type_void = init_type (TYPE_CODE_VOID, 1, 0, "void"); builtin_type_float = init_type (TYPE_CODE_FLT, sizeof (float), 0, "float"); builtin_type_double = init_type (TYPE_CODE_FLT, sizeof (double), 0, "double"); |