diff options
| -rw-r--r-- | gdb/ChangeLog | 18 | ||||
| -rw-r--r-- | gdb/breakpoint.c | 17 | ||||
| -rw-r--r-- | gdb/objfiles.c | 14 | ||||
| -rw-r--r-- | gdb/symfile.c | 40 | ||||
| -rw-r--r-- | gdb/symtab.c | 1590 |
5 files changed, 674 insertions, 1005 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 789f09b..3213e8a 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,21 @@ +Thu Feb 27 06:11:05 1992 John Gilmore (gnu at cygnus.com) + + * breakpoint.h (ALL_BREAKPOINTS_SAFE): Add. + * breakpoint.c (breakpoint_re_set): Use ALL_BREAKPOINTS_SAFE. + * symtab.c (find_pc_symtab): Handle having no objfiles. + * infcmd.c: Fix comment. + * objfiles.c (free_all_objfiles): Add. + * symfile.h (ALL_OBJFILES, ALL_OBJFILES_SAFE): Add. + * symfile.c (symbol_file_command): free all objfiles when + specifying a new symbol file. + (reread_symbols): Stat the file name, don't fstat the descriptor. + +Tue Feb 25 19:31:19 1992 Stu Grossman (grossman at cygnus.com) + + * dbxread.c (end_psymtab): Delete empty psymtabs. + * symfile.c (allocate_psymtab): Recycle empty psymtabs. + * symfile.h (struct objfile): Add free_psymtabs. + Sat Feb 22 02:00:32 1992 John Gilmore (gnu at cygnus.com) * Makefile.in (VERSION): Roll to gdb-4.4.4. diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index 61a7a9f..e24105c 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -113,7 +113,7 @@ static void breakpoints_info PARAMS ((char *, int)); static void -breakpoint_1 PARAMS ((int, int)); +breakpoint_1 PARAMS ((int, enum bptype)); static bpstat bpstat_alloc PARAMS ((struct breakpoint *, bpstat)); @@ -143,8 +143,17 @@ extern int demangle; /* Print de-mangled symbol names? */ /* Are we executing breakpoint commands? */ static int executing_breakpoint_commands; +/* Walk the following statement or block through all breakpoints. + ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current + breakpoint. */ + #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next) +#define ALL_BREAKPOINTS_SAFE(b,tmp) \ + for (b = breakpoint_chain; \ + b? (tmp=b->next, 1): 0; \ + b = tmp) + /* Chain of all breakpoints defined. */ struct breakpoint *breakpoint_chain; @@ -810,7 +819,7 @@ bpstat_stop_status (pc, frame_address) int real_breakpoint = 0; #endif /* Root of the chain of bpstat's */ - struct bpstat__struct root_bs[1]; + struct bpstat root_bs[1]; /* Pointer to the last thing in the chain currently. */ bpstat bs = root_bs; @@ -2229,11 +2238,11 @@ breakpoint_re_set_one (bint) void breakpoint_re_set () { - struct breakpoint *b; + struct breakpoint *b, *temp; static char message1[] = "Error in re-setting breakpoint %d:\n"; char message[sizeof (message1) + 30 /* slop */]; - ALL_BREAKPOINTS (b) + ALL_BREAKPOINTS_SAFE (b, temp) { b->symtab = 0; /* Be sure we don't point to old dead symtab */ sprintf (message, message1, b->number); /* Format possible error msg */ diff --git a/gdb/objfiles.c b/gdb/objfiles.c index a1fb22f..53ac034 100644 --- a/gdb/objfiles.c +++ b/gdb/objfiles.c @@ -163,6 +163,20 @@ free_objfile (objfile) (*objfile -> free) (objfile); } + +/* Free all the object files at once. */ + +void +free_all_objfiles () +{ + struct objfile *objfile, *temp; + + ALL_OBJFILES_SAFE (objfile, temp) + { + free_objfile (objfile); + } +} + /* Many places in gdb want to test just to see if we have any partial symbols available. This function returns zero if none are currently available, nonzero otherwise. */ diff --git a/gdb/symfile.c b/gdb/symfile.c index 450856a..7629fd8 100644 --- a/gdb/symfile.c +++ b/gdb/symfile.c @@ -554,15 +554,12 @@ symbol_file_command (args, from_tty) if (args == NULL) { - if (symfile_objfile) - { - if ((have_full_symbols () || have_partial_symbols ()) - && from_tty - && !query ("Discard symbol table from `%s'? ", - symfile_objfile -> name)) - error ("Not confirmed."); - free_objfile (symfile_objfile); - } + if ((have_full_symbols () || have_partial_symbols ()) + && from_tty + && !query ("Discard symbol table from `%s'? ", + symfile_objfile -> name)) + error ("Not confirmed."); + free_all_objfiles (); symfile_objfile = NULL; /* FIXME, this does not account for the main file and subsequent files (shared libs, dynloads, etc) having different formats. @@ -769,6 +766,8 @@ reread_symbols () struct objfile *objfile; long new_modtime; int reread_one = 0; + struct stat new_statbuf; + int res; /* With the addition of shared libraries, this should be modified, the load time should be saved in the partial symbol tables, since @@ -779,7 +778,14 @@ reread_symbols () the_big_top: for (objfile = object_files; objfile; objfile = objfile->next) { if (objfile->obfd) { - new_modtime = bfd_get_mtime (objfile->obfd); + res = stat (objfile->name, &new_statbuf); + if (res != 0) { + /* FIXME, should use print_sys_errmsg but it's not filtered. */ + printf_filtered ("`%s' has disappeared; keeping its symbols.\n", + objfile->name); + continue; + } + new_modtime = new_statbuf.st_mtime; if (new_modtime != objfile->mtime) { printf_filtered ("`%s' has changed; re-reading symbols.\n", objfile->name); @@ -799,7 +805,6 @@ the_big_top: if (reread_one) breakpoint_re_set (); } - /* Functions to handle complaints during symbol reading. */ @@ -957,9 +962,16 @@ allocate_psymtab (filename, objfile) { struct partial_symtab *psymtab; - psymtab = (struct partial_symtab *) - obstack_alloc (&objfile -> psymbol_obstack, - sizeof (struct partial_symtab)); + if (objfile -> free_psymtabs) + { + psymtab = objfile -> free_psymtabs; + objfile -> free_psymtabs = psymtab -> next; + } + else + psymtab = (struct partial_symtab *) + obstack_alloc (&objfile -> psymbol_obstack, + sizeof (struct partial_symtab)); + (void) memset (psymtab, 0, sizeof (struct partial_symtab)); psymtab -> filename = obsavestring (filename, strlen (filename), &objfile -> psymbol_obstack); diff --git a/gdb/symtab.c b/gdb/symtab.c index b5e83a7..9d1bf3f 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -1,5 +1,5 @@ /* Symbol table lookup for the GNU debugger, GDB. - Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc. + Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992 Free Software Foundation, Inc. This file is part of GDB. @@ -20,6 +20,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <stdio.h> #include "defs.h" #include "symtab.h" +#include "gdbtypes.h" #include "gdbcore.h" #include "frame.h" #include "target.h" @@ -27,6 +28,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "symfile.h" #include "gdbcmd.h" #include "regex.h" +#include "expression.h" #include "language.h" #include <obstack.h> @@ -37,20 +39,59 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <string.h> #include <sys/stat.h> -extern char *getenv (); +/* Prototypes for local functions */ -extern char *cplus_demangle (); -extern char *cplus_mangle_opname (); -extern struct value *value_of_this (); -extern void break_command (); -extern void select_source_symtab (); +static int +find_methods PARAMS ((struct type *, char *, char **, struct symbol **)); + +static void +completion_list_add_symbol PARAMS ((char *)); + +static struct symtabs_and_lines +decode_line_2 PARAMS ((struct symbol *[], int, int)); + +static void +rbreak_command PARAMS ((char *)); + +static void +types_info PARAMS ((char *)); + +static void +functions_info PARAMS ((char *)); + +static void +variables_info PARAMS ((char *)); + +static void +list_symbols PARAMS ((char *, int, int)); + +static void +sources_info PARAMS ((void)); + +static void +output_source_filename PARAMS ((char *, int *)); + +static char * +operator_chars PARAMS ((char *, char **)); + +static int +find_line_common PARAMS ((struct linetable *, int, int *)); + +static struct partial_symbol * +lookup_partial_symbol PARAMS ((struct partial_symtab *, const char *, + int, enum namespace)); + +static struct partial_symbol * +lookup_demangled_partial_symbol PARAMS ((const struct partial_symtab *, + const char *)); + +static struct symbol * +lookup_demangled_block_symbol PARAMS ((const struct block *, const char *)); -/* Functions this file defines */ -static int find_line_common (); -struct partial_symtab *lookup_partial_symtab (); -static struct partial_symbol *lookup_partial_symbol (); -static struct partial_symbol *lookup_demangled_partial_symbol (); -static struct symbol *lookup_demangled_block_symbol (); +static struct symtab * +lookup_symtab_1 PARAMS ((char *)); + +/* */ /* The single non-language-specific builtin type */ struct type *builtin_type_error; @@ -58,7 +99,8 @@ struct type *builtin_type_error; /* Block in which the most recently searched-for symbol was found. Might be better to make this a parameter to lookup_symbol and value_of_this. */ -struct block *block_found; + +const struct block *block_found; char no_symtab_msg[] = "No symbol table is loaded. Use the \"file\" command."; @@ -74,44 +116,68 @@ lookup_symtab_1 (name) register struct partial_symtab *ps; register char *slash = strchr (name, '/'); register int len = strlen (name); + register struct objfile *objfile; - 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) - error ("Internal: readin pst for `%s' found when no symtab found.", name); - return PSYMTAB_TO_SYMTAB (ps); - } + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (s = objfile -> symtabs; s != NULL; s = s -> next) + { + if (strcmp (name, s->filename) == 0) + { + return (s); + } + } + } + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (ps = objfile -> psymtabs; ps != NULL; ps = ps->next) + { + if (strcmp (name, ps -> filename) == 0) + { + if (ps -> readin) + { + error ("Internal: readin pst for `%s' found when no symtab found.", name); + } + return (PSYMTAB_TO_SYMTAB (ps)); + } + } + } if (!slash) { - for (s = symtab_list; s; s = s->next) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - int l = strlen (s->filename); - - if (s->filename[l - len -1] == '/' - && !strcmp (s->filename + l - len, name)) - return s; + for (s = objfile -> symtabs; s != NULL; s = s -> next) + { + int l = strlen (s->filename); + + if (s->filename[l - len -1] == '/' + && (strcmp (s->filename + l - len, name) == 0)) + { + return (s); + } + } } - for (ps = partial_symtab_list; ps; ps = ps->next) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - int l = strlen (ps->filename); - - if (ps->filename[l - len - 1] == '/' - && !strcmp (ps->filename + l - len, name)) + for (ps = objfile -> psymtabs; ps != NULL; ps = ps -> next) { - if (ps->readin) - error ("Internal: readin pst for `%s' found when no symtab found.", name); - return PSYMTAB_TO_SYMTAB (ps); + int l = strlen (ps -> filename); + + if (ps -> filename[l - len - 1] == '/' + && (strcmp (ps->filename + l - len, name) == 0)) + { + if (ps -> readin) + { + error ("Internal: readin pst for `%s' found when no symtab found.", name); + } + return (PSYMTAB_TO_SYMTAB (ps)); + } } } } - return 0; + return (NULL); } /* Lookup the symbol table of a source file named NAME. Try a couple @@ -147,81 +213,22 @@ struct partial_symtab * lookup_partial_symtab (name) char *name; { - register struct partial_symtab *s; - - for (s = partial_symtab_list; s; s = s->next) - if (!strcmp (name, s->filename)) - return s; + register struct partial_symtab *pst; + register struct objfile *objfile; - return 0; -} - -/* Return a typename for a struct/union/enum type - without the tag qualifier. If the type has a NULL name, - NULL is returned. */ -char * -type_name_no_tag (type) - register struct type *type; -{ - register char *name = TYPE_NAME (type); - - if (name == 0) - return 0; - - switch (TYPE_CODE (type)) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - case TYPE_CODE_STRUCT: - if(!strncmp(name,"struct ",7)) - return name + 7; - else return name; - case TYPE_CODE_UNION: - if(!strncmp(name,"union ",6)) - return name + 6; - else return name; - case TYPE_CODE_ENUM: - if(!strncmp(name,"enum ",5)) - return name + 5; - else return name; - default: - return name; - } -} - -/* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989. - - If this is a stubbed struct (i.e. declared as struct foo *), see if - we can find a full definition in some other file. If so, copy this - definition, so we can use it in future. If not, set a flag so we - don't waste too much time in future. (FIXME, this doesn't seem - to be happening...) - - This used to be coded as a macro, but I don't think it is called - often enough to merit such treatment. -*/ - -struct complaint stub_noname_complaint = - {"stub type has NULL name", 0, 0}; - -void -check_stub_type(type) - struct type *type; -{ - if (TYPE_FLAGS(type) & TYPE_FLAG_STUB) - { - char* name= type_name_no_tag (type); - struct symbol *sym; - if (name == 0) + for (pst = objfile -> psymtabs; pst != NULL; pst = pst -> next) { - complain (&stub_noname_complaint, 0); - return; + if (strcmp (name, pst -> filename) == 0) + { + return (pst); + } } - sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, - (struct symtab **)NULL); - if (sym) - memcpy (type, SYMBOL_TYPE(sym), sizeof (struct type)); - } + } + return (NULL); } - + /* Demangle a GDB method stub type. */ char * gdb_mangle_name (type, i, j) @@ -236,7 +243,6 @@ gdb_mangle_name (type, i, j) int is_constructor = strcmp(field_name, TYPE_NAME (type)) == 0; /* Need a new type prefix. */ - char *strchr (); char *const_prefix = method->is_const ? "C" : ""; char *volatile_prefix = method->is_volatile ? "V" : ""; char *newname = type_name_no_tag (type); @@ -278,502 +284,27 @@ gdb_mangle_name (type, i, j) return mangled_name; } -/* Lookup a primitive type named NAME. - Return zero if NAME is not a primitive type.*/ - -struct type * -lookup_primitive_typename (name) - char *name; -{ - struct type ** const *p; - - for (p = current_language->la_builtin_type_vector; *p; p++) - if(!strcmp((**p)->name, name)) - return **p; - return 0; -} - -/* Lookup a typedef or primitive type named NAME, - visible in lexical block BLOCK. - If NOERR is nonzero, return zero if NAME is not suitably defined. */ - -struct type * -lookup_typename (name, block, noerr) - char *name; - struct block *block; - int noerr; -{ - register struct symbol *sym = - lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **)NULL); - if (sym == 0 || SYMBOL_CLASS (sym) != LOC_TYPEDEF) - { - struct type *tmp; - tmp = lookup_primitive_typename (name); - if(tmp) - return tmp; - else if (!tmp && noerr) - return 0; - else - error ("No type named %s.", name); - } - return SYMBOL_TYPE (sym); -} - -struct type * -lookup_unsigned_typename (name) - char *name; -{ - char *uns = alloca (strlen(name) + 10); - - strcpy (uns, "unsigned "); - strcpy (uns+9, name); - return lookup_typename (uns, (struct block *)0, 0); -} - -/* Lookup a structure type named "struct NAME", - visible in lexical block BLOCK. */ - -struct type * -lookup_struct (name, block) - char *name; - struct block *block; -{ - register struct symbol *sym - = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **)NULL); - - if (sym == 0) - error ("No struct type named %s.", name); - if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) - error ("This context has class, union or enum %s, not a struct.", name); - return SYMBOL_TYPE (sym); -} - -/* Lookup a union type named "union NAME", - visible in lexical block BLOCK. */ - -struct type * -lookup_union (name, block) - char *name; - struct block *block; -{ - register struct symbol *sym - = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **)NULL); - - if (sym == 0) - error ("No union type named %s.", name); - if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION) - error ("This context has class, struct or enum %s, not a union.", name); - return SYMBOL_TYPE (sym); -} - -/* Lookup an enum type named "enum NAME", - visible in lexical block BLOCK. */ - -struct type * -lookup_enum (name, block) - char *name; - struct block *block; -{ - register struct symbol *sym - = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **)NULL); - if (sym == 0) - error ("No enum type named %s.", name); - if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM) - error ("This context has class, struct or union %s, not an enum.", name); - return SYMBOL_TYPE (sym); -} - -/* Lookup a template type named "template NAME<TYPE>", - visible in lexical block BLOCK. */ - -struct type * -lookup_template_type (name, type, block) - char *name; - struct type *type; - struct block *block; -{ - struct symbol *sym ; - char *nam = (char*) alloca(strlen(name) + strlen(type->name) + 4); - strcpy(nam, name); - strcat(nam, "<"); - strcat(nam, type->name); - strcat(nam, " >"); /* FIXME, extra space still introduced in gcc? */ - - sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **)NULL); - - if (sym == 0) - error ("No template type named %s.", name); - if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) - error ("This context has class, union or enum %s, not a struct.", name); - return SYMBOL_TYPE (sym); -} - -/* Given a type TYPE, lookup the type of the component of type named - NAME. - If NOERR is nonzero, return zero if NAME is not suitably defined. */ - -struct type * -lookup_struct_elt_type (type, name, noerr) - struct type *type; - char *name; - int noerr; -{ - int i; - - if ( TYPE_CODE (type) != TYPE_CODE_STRUCT - && TYPE_CODE (type) != TYPE_CODE_UNION) - { - target_terminal_ours (); - fflush (stdout); - fprintf (stderr, "Type "); - type_print (type, "", stderr, -1); - error (" is not a structure or union type."); - } - - check_stub_type (type); - - for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--) - { - char *t_field_name = TYPE_FIELD_NAME (type, i); - - if (t_field_name && !strcmp (t_field_name, name)) - return TYPE_FIELD_TYPE (type, i); - } - /* OK, it's not in this class. Recursively check the baseclasses. */ - for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) - { - struct type *t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), - name, 0); - if (t != NULL) - return t; - } - - if (noerr) - return NULL; - - target_terminal_ours (); - fflush (stdout); - fprintf (stderr, "Type "); - type_print (type, "", stderr, -1); - fprintf (stderr, " has no component named "); - fputs_filtered (name, stderr); - error ("."); - return (struct type *)-1; /* For lint */ -} - -/* 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. */ - -struct type * -lookup_pointer_type (type) - struct type *type; -{ - register struct type *ptype = TYPE_POINTER_TYPE (type); - if (ptype) return ptype; - - /* This is the first time anyone wanted a pointer to a TYPE. */ - if (TYPE_FLAGS (type) & TYPE_FLAG_PERM) - ptype = (struct type *) xmalloc (sizeof (struct type)); - else - ptype = (struct type *) obstack_alloc (symbol_obstack, - sizeof (struct type)); - - bzero (ptype, sizeof (struct type)); - TYPE_TARGET_TYPE (ptype) = type; - TYPE_POINTER_TYPE (type) = ptype; - /* New type is permanent if type pointed to is permanent. */ - if (TYPE_FLAGS (type) & TYPE_FLAG_PERM) - TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM; - /* We assume the machine has only one representation for pointers! */ - /* FIXME: This confuses host<->target data representations, and is a - poor assumption besides. */ - TYPE_LENGTH (ptype) = sizeof (char *); - TYPE_CODE (ptype) = TYPE_CODE_PTR; - return ptype; -} - -struct type * -lookup_reference_type (type) - struct type *type; -{ - register struct type *rtype = TYPE_REFERENCE_TYPE (type); - if (rtype) return rtype; - - /* This is the first time anyone wanted a pointer to a TYPE. */ - if (TYPE_FLAGS (type) & TYPE_FLAG_PERM) - rtype = (struct type *) xmalloc (sizeof (struct type)); - else - rtype = (struct type *) obstack_alloc (symbol_obstack, - sizeof (struct type)); - - bzero (rtype, sizeof (struct type)); - TYPE_TARGET_TYPE (rtype) = type; - TYPE_REFERENCE_TYPE (type) = rtype; - /* New type is permanent if type pointed to is permanent. */ - if (TYPE_FLAGS (type) & TYPE_FLAG_PERM) - TYPE_FLAGS (rtype) |= TYPE_FLAG_PERM; - /* We assume the machine has only one representation for pointers! */ - TYPE_LENGTH (rtype) = sizeof (char *); - TYPE_CODE (rtype) = TYPE_CODE_REF; - return rtype; -} - - -/* Implement direct support for MEMBER_TYPE in GNU C++. - May need to construct such a type if this is the first use. - The TYPE is the type of the member. The DOMAIN is the type - of the aggregate that the member belongs to. */ - -struct type * -lookup_member_type (type, domain) - struct type *type, *domain; -{ - register struct type *mtype; - - mtype = (struct type *) obstack_alloc (symbol_obstack, - sizeof (struct type)); - smash_to_member_type (mtype, domain, type); - return mtype; -} - -/* Allocate a stub method whose return type is TYPE. - This apparently happens for speed of symbol reading, since parsing - out the arguments to the method is cpu-intensive, the way we are doing - it. So, we will fill in arguments later. - This always returns a fresh type. */ + +/* Find which partial symtab on contains PC. Return 0 if none. */ -struct type * -allocate_stub_method (type) - struct type *type; +struct partial_symtab * +find_pc_psymtab (pc) + register CORE_ADDR pc; { - struct type *mtype = (struct type *) obstack_alloc (symbol_obstack, - sizeof (struct type)); - bzero (mtype, sizeof (struct type)); - TYPE_TARGET_TYPE (mtype) = type; - /* _DOMAIN_TYPE (mtype) = unknown yet */ - /* _ARG_TYPES (mtype) = unknown yet */ - TYPE_FLAGS (mtype) = TYPE_FLAG_STUB; - TYPE_CODE (mtype) = TYPE_CODE_METHOD; - TYPE_LENGTH (mtype) = 1; - return mtype; -} - -/* Ugly hack to convert method stubs into method types. + register struct partial_symtab *pst; + register struct objfile *objfile; - He ain't kiddin'. This demangles the name of the method into a string - including argument types, parses out each argument type, generates - a string casting a zero to that type, evaluates the string, and stuffs - the resulting type into an argtype vector!!! Then it knows the type - of the whole function (including argument types for overloading), - which info used to be in the stab's but was removed to hack back - the space required for them. */ -void -check_stub_method (type, i, j) - struct type *type; - int i, j; -{ - extern char *gdb_mangle_name (), *strchr (); - struct fn_field *f; - char *mangled_name = gdb_mangle_name (type, i, j); - char *demangled_name = cplus_demangle (mangled_name, 0); - char *argtypetext, *p; - int depth = 0, argcount = 1; - struct type **argtypes; - struct type *mtype; - - if (demangled_name == NULL) - error ("Internal: Cannot demangle mangled name `%s'.", mangled_name); - - /* Now, read in the parameters that define this type. */ - argtypetext = strchr (demangled_name, '(') + 1; - p = argtypetext; - while (*p) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - if (*p == '(') - depth += 1; - else if (*p == ')') - depth -= 1; - else if (*p == ',' && depth == 0) - argcount += 1; - - p += 1; - } - /* We need two more slots: one for the THIS pointer, and one for the - NULL [...] or void [end of arglist]. */ - argtypes = (struct type **) obstack_alloc (symbol_obstack, - (argcount+2) * sizeof (struct type *)); - p = argtypetext; - argtypes[0] = lookup_pointer_type (type); - argcount = 1; - - if (*p != ')') /* () means no args, skip while */ - { - depth = 0; - while (*p) + for (pst = objfile -> psymtabs; pst != NULL; pst = pst -> next) { - if (depth <= 0 && (*p == ',' || *p == ')')) + if (pc >= pst -> textlow && pc < pst -> texthigh) { - argtypes[argcount] = - parse_and_eval_type (argtypetext, p - argtypetext); - argcount += 1; - argtypetext = p + 1; + return (pst); } - - if (*p == '(') - depth += 1; - else if (*p == ')') - depth -= 1; - - p += 1; } } - - if (p[-2] != '.') /* ... */ - argtypes[argcount] = builtin_type_void; /* Ellist terminator */ - else - argtypes[argcount] = NULL; /* List terminator */ - - free (demangled_name); - - f = TYPE_FN_FIELDLIST1 (type, i); - TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name; - - /* Now update the old "stub" type into a real type. */ - mtype = TYPE_FN_FIELD_TYPE (f, j); - TYPE_DOMAIN_TYPE (mtype) = type; - TYPE_ARG_TYPES (mtype) = argtypes; - TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB; - TYPE_FN_FIELD_STUB (f, j) = 0; -} - -/* Given a type TYPE, return a type of functions that return that type. - May need to construct such a type if this is the first use. */ - -struct type * -lookup_function_type (type) - struct type *type; -{ - register struct type *ptype = TYPE_FUNCTION_TYPE (type); - if (ptype) return ptype; - - /* This is the first time anyone wanted a function returning a TYPE. */ - if (TYPE_FLAGS (type) & TYPE_FLAG_PERM) - ptype = (struct type *) xmalloc (sizeof (struct type)); - else - ptype = (struct type *) obstack_alloc (symbol_obstack, - sizeof (struct type)); - - bzero (ptype, sizeof (struct type)); - TYPE_TARGET_TYPE (ptype) = type; - TYPE_FUNCTION_TYPE (type) = ptype; - /* New type is permanent if type returned is permanent. */ - if (TYPE_FLAGS (type) & TYPE_FLAG_PERM) - TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM; - TYPE_LENGTH (ptype) = 1; - TYPE_CODE (ptype) = TYPE_CODE_FUNC; - TYPE_NFIELDS (ptype) = 0; - 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)); - struct type *range_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)); - - { - /* Create range type. */ - range_type = (struct type *) obstack_alloc (symbol_obstack, - sizeof (struct type)); - TYPE_CODE (range_type) = TYPE_CODE_RANGE; - TYPE_TARGET_TYPE (range_type) = builtin_type_int; /* FIXME */ - - /* This should never be needed. */ - TYPE_LENGTH (range_type) = sizeof (int); - - TYPE_NFIELDS (range_type) = 2; - TYPE_FIELDS (range_type) = - (struct field *) obstack_alloc (symbol_obstack, - 2 * sizeof (struct field)); - TYPE_FIELD_BITPOS (range_type, 0) = 0; /* FIXME */ - TYPE_FIELD_BITPOS (range_type, 1) = number-1; /* FIXME */ - TYPE_FIELD_TYPE (range_type, 0) = builtin_type_int; /* FIXME */ - TYPE_FIELD_TYPE (range_type, 1) = builtin_type_int; /* FIXME */ - } - TYPE_FIELD_TYPE(result_type,0)=range_type; - TYPE_VPTR_FIELDNO (result_type) = -1; - - return result_type; -} - - -/* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. - A MEMBER is a wierd thing -- it amounts to a typed offset into - a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't - include the offset (that's the value of the MEMBER itself), but does - include the structure type into which it points (for some reason). */ - -void -smash_to_member_type (type, domain, to_type) - struct type *type, *domain, *to_type; -{ - bzero (type, sizeof (struct type)); - TYPE_TARGET_TYPE (type) = to_type; - TYPE_DOMAIN_TYPE (type) = domain; - TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */ - TYPE_CODE (type) = TYPE_CODE_MEMBER; -} - -/* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE. - METHOD just means `function that gets an extra "this" argument'. */ - -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; - TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */ - TYPE_CODE (type) = TYPE_CODE_METHOD; -} - -/* 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; + return (NULL); } /* Find which partial symbol within a psymtab contains PC. Return 0 @@ -793,8 +324,8 @@ find_pc_psymbol (psymtab, pc) best_pc = psymtab->textlow - 1; - for (p = static_psymbols.list + psymtab->statics_offset; - (p - (static_psymbols.list + psymtab->statics_offset) + for (p = psymtab->objfile->static_psymbols.list + psymtab->statics_offset; + (p - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset) < psymtab->n_static_syms); p++) if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE @@ -824,9 +355,9 @@ find_pc_psymbol (psymtab, pc) struct symbol * lookup_symbol (name, block, namespace, is_a_field_of_this, symtab) - char *name; - register struct block *block; - enum namespace namespace; + const char *name; + register const struct block *block; + const enum namespace namespace; int *is_a_field_of_this; struct symtab **symtab; { @@ -834,6 +365,10 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab) register struct symtab *s; register struct partial_symtab *ps; struct blockvector *bv; + register struct objfile *objfile; + register struct block *b; + register int found; + register struct minimal_symbol *msymbol; /* Search specified block and its superiors. */ @@ -847,19 +382,26 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab) { /* Search the list of symtabs for one which contains the address of the start of this block. */ - struct block *b; - for (s = symtab_list; s; s = s->next) + for (found = 0, objfile = object_files; + !found && objfile != NULL; + objfile = objfile -> next) { - bv = BLOCKVECTOR (s); - b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - if (BLOCK_START (b) <= BLOCK_START (block) - && BLOCK_END (b) > BLOCK_START (block)) - break; + for (s = objfile -> symtabs; s != NULL; s = s -> next) + { + bv = BLOCKVECTOR (s); + b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); + if (BLOCK_START (b) <= BLOCK_START (block) + && BLOCK_END (b) > BLOCK_START (block)) + { + found++; + break; + } + } } *symtab = s; } - return sym; + return (sym); } block = BLOCK_SUPERBLOCK (block); } @@ -875,20 +417,23 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab) { struct block *b; /* Find the right symtab. */ - for (s = symtab_list; s; s = s->next) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - bv = BLOCKVECTOR (s); - b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - if (BLOCK_START (b) <= BLOCK_START (block) - && BLOCK_END (b) > BLOCK_START (block)) + for (s = objfile -> symtabs; s != NULL; s = s -> next) { - sym = lookup_demangled_block_symbol (b, name); - if (sym) + bv = BLOCKVECTOR (s); + b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); + if (BLOCK_START (b) <= BLOCK_START (block) + && BLOCK_END (b) > BLOCK_START (block)) { - block_found = b; - if (symtab != NULL) - *symtab = s; - return sym; + sym = lookup_demangled_block_symbol (b, name); + if (sym) + { + block_found = b; + if (symtab != NULL) + *symtab = s; + return sym; + } } } } @@ -913,34 +458,37 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab) /* Now search all global blocks. Do the symtab's first, then check the psymtab's */ - - for (s = symtab_list; s; s = s->next) + + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - bv = BLOCKVECTOR (s); - block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - sym = lookup_block_symbol (block, name, namespace); - if (sym) + for (s = objfile -> symtabs; s != NULL; s = s -> next) { - block_found = block; - if (symtab != NULL) - *symtab = s; - return sym; + bv = BLOCKVECTOR (s); + block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); + sym = lookup_block_symbol (block, name, namespace); + if (sym) + { + block_found = block; + if (symtab != NULL) + *symtab = s; + return sym; + } } } /* Check for the possibility of the symbol being a global function - that is stored on the misc function vector. Eventually, all + that is stored in one of the minimal symbol tables. Eventually, all global symbols might be resolved in this way. */ if (namespace == VAR_NAMESPACE) { - int ind = lookup_misc_func (name); - + msymbol = lookup_minimal_symbol (name, (struct objfile *) NULL); /* Look for a mangled C++ name for NAME. */ - if (ind == -1) + if (msymbol == NULL) { int name_len = strlen (name); +#if 0 /* FIXME: Needs to be fixed to use new minimal symbol tables */ for (ind = misc_function_count; --ind >= 0; ) /* Assume orginal name is prefix of mangled name. */ if (!strncmp (misc_function_vector[ind].name, name, name_len)) @@ -956,22 +504,22 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab) } } /* Loop terminates on no match with ind == -1. */ +#endif } - if (ind != -1) + if (msymbol != NULL) { - s = find_pc_symtab (misc_function_vector[ind].address); + s = find_pc_symtab (msymbol -> address); /* If S is zero, there are no debug symbols for this file. Skip this stuff and check for matching static symbols below. */ if (s) { bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - sym = lookup_block_symbol (block, misc_function_vector[ind].name, - namespace); - /* sym == 0 if symbol was found in the misc_function_vector + sym = lookup_block_symbol (block, msymbol -> name, namespace); + /* sym == 0 if symbol was found in the minimal symbol table but not in the symtab. - Return 0 to use the misc_function definition of "foo_". + Return 0 to use the msymbol definition of "foo_". This happens for Fortran "foo_" symbols, which are "foo" in the symtab. @@ -989,84 +537,105 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab) } } - for (ps = partial_symtab_list; ps; ps = ps->next) - 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) - error ("Internal: global symbol `%s' found in psymtab but not in symtab", name); - if (symtab != NULL) - *symtab = s; - return sym; - } + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (ps = objfile -> psymtabs; ps != NULL; ps = ps->next) + { + 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) + error ("Internal: global symbol `%s' found in psymtab but not in symtab", name); + if (symtab != NULL) + *symtab = s; + return sym; + } + } + } /* Now search all per-file blocks. Not strictly correct, but more useful than an error. Do the symtabs first, then check the psymtabs */ - for (s = symtab_list; s; s = s->next) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - bv = BLOCKVECTOR (s); - block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - sym = lookup_block_symbol (block, name, namespace); - if (sym) + for (s = objfile -> symtabs; s != NULL; s = s -> next) { - block_found = block; - if (symtab != NULL) - *symtab = s; - return sym; + bv = BLOCKVECTOR (s); + block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); + sym = lookup_block_symbol (block, name, namespace); + if (sym) + { + block_found = block; + if (symtab != NULL) + *symtab = s; + return sym; + } } } - for (ps = partial_symtab_list; ps; ps = ps->next) - 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) - error ("Internal: static symbol `%s' found in psymtab but not in symtab", name); - if (symtab != NULL) - *symtab = s; - return sym; - } + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (ps = objfile -> psymtabs; ps != NULL; ps = ps -> next) + { + 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) + error ("Internal: static symbol `%s' found in psymtab but not in symtab", name); + if (symtab != NULL) + *symtab = s; + return sym; + } + } + } /* Now search all per-file blocks for static mangled symbols. Do the symtabs first, then check the psymtabs. */ if (namespace == VAR_NAMESPACE) { - for (s = symtab_list; s; s = s->next) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - bv = BLOCKVECTOR (s); - block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - sym = lookup_demangled_block_symbol (block, name); - if (sym) + for (s = objfile -> symtabs; s != NULL; s = s -> next) { - block_found = block; - if (symtab != NULL) - *symtab = s; - return sym; + bv = BLOCKVECTOR (s); + block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); + sym = lookup_demangled_block_symbol (block, name); + if (sym) + { + block_found = block; + if (symtab != NULL) + *symtab = s; + return sym; + } } } - for (ps = partial_symtab_list; ps; ps = ps->next) - if (!ps->readin && lookup_demangled_partial_symbol (ps, name)) - { - s = PSYMTAB_TO_SYMTAB(ps); - bv = BLOCKVECTOR (s); - block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - sym = lookup_demangled_block_symbol (block, name); - if (!sym) - error ("Internal: mangled static symbol `%s' found in psymtab but not in symtab", name); - if (symtab != NULL) - *symtab = s; - return sym; - } + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (ps = objfile -> psymtabs; ps != NULL; ps = ps -> next) + { + if (!ps->readin && lookup_demangled_partial_symbol (ps, name)) + { + s = PSYMTAB_TO_SYMTAB(ps); + bv = BLOCKVECTOR (s); + block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); + sym = lookup_demangled_block_symbol (block, name); + if (!sym) + error ("Internal: mangled static symbol `%s' found in psymtab but not in symtab", name); + if (symtab != NULL) + *symtab = s; + return sym; + } + } + } } if (symtab != NULL) @@ -1078,8 +647,8 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab) static struct symbol * lookup_demangled_block_symbol (block, name) - register struct block *block; - char *name; + register const struct block *block; + const char *name; { register int bot, top, inc; register struct symbol *sym; @@ -1113,8 +682,8 @@ lookup_demangled_block_symbol (block, name) static struct partial_symbol * lookup_demangled_partial_symbol (pst, name) - struct partial_symtab *pst; - char *name; + const struct partial_symtab *pst; + const char *name; { struct partial_symbol *start, *psym; int length = pst->n_static_syms; @@ -1123,7 +692,7 @@ lookup_demangled_partial_symbol (pst, name) if (!length) return (struct partial_symbol *) 0; - start = static_psymbols.list + pst->statics_offset; + start = pst->objfile->static_psymbols.list + pst->statics_offset; for (psym = start; psym < start + length; psym++) { if (SYMBOL_NAME (psym)[0] == inc @@ -1149,7 +718,7 @@ lookup_demangled_partial_symbol (pst, name) static struct partial_symbol * lookup_partial_symbol (pst, name, global, namespace) struct partial_symtab *pst; - char *name; + const char *name; int global; enum namespace namespace; { @@ -1160,8 +729,8 @@ lookup_partial_symbol (pst, name, global, namespace) return (struct partial_symbol *) 0; start = (global ? - global_psymbols.list + pst->globals_offset : - static_psymbols.list + pst->statics_offset ); + pst->objfile->global_psymbols.list + pst->globals_offset : + pst->objfile->static_psymbols.list + pst->statics_offset ); if (global) /* This means we can use a binary */ /* search. */ @@ -1212,19 +781,28 @@ struct partial_symtab * find_main_psymtab () { register struct partial_symtab *pst; - for (pst = partial_symtab_list; pst; pst = pst->next) - if (lookup_partial_symbol (pst, "main", 1, VAR_NAMESPACE)) - return pst; - return NULL; + register struct objfile *objfile; + + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (pst = objfile -> psymtabs; pst; pst = pst->next) + { + if (lookup_partial_symbol (pst, "main", 1, VAR_NAMESPACE)) + { + return (pst); + } + } + } + return (NULL); } /* Look for a symbol in block BLOCK. */ struct symbol * lookup_block_symbol (block, name, namespace) - register struct block *block; - char *name; - enum namespace namespace; + register const struct block *block; + const char *name; + const enum namespace namespace; { register int bot, top, inc; register struct symbol *sym, *parameter_sym; @@ -1334,32 +912,44 @@ find_pc_symtab (pc) { register struct block *b; struct blockvector *bv; - register struct symtab *s; + register struct symtab *s = 0; register struct partial_symtab *ps; + register struct objfile *objfile; + register int found; /* Search all symtabs for one whose file contains our pc */ - for (s = symtab_list; s; s = s->next) + for (found = 0, objfile = object_files; + !found && objfile != NULL; + objfile = objfile -> next) { - bv = BLOCKVECTOR (s); - b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - if (BLOCK_START (b) <= pc - && BLOCK_END (b) > pc) - break; + for (s = objfile -> symtabs; s != NULL; s = s -> next) + { + bv = BLOCKVECTOR (s); + b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); + if (BLOCK_START (b) <= pc + && BLOCK_END (b) > pc) + { + found++; + break; + } + } } if (!s) { ps = find_pc_psymtab (pc); if (ps && ps->readin) - printf_filtered ( - "(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc); - + { + printf_filtered ("(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc); + } if (ps) - s = PSYMTAB_TO_SYMTAB (ps); + { + s = PSYMTAB_TO_SYMTAB (ps); + } } - return s; + return (s); } /* Find the source file and line number for a given PC value. @@ -1468,10 +1058,10 @@ find_pc_line (pc, notcurrent) best_pc = prev_pc; best_line = prev_line; best_symtab = s; - if (i < len) + /* If another line is in the linetable, and its PC is closer + than the best_end we currently have, take it as best_end. */ + if (i < len && (best_end == 0 || best_end > item->pc)) best_end = item->pc; - else - best_end = 0; } /* Is this file's first line closer than the first lines of other files? If so, record this file, and its first line, as best alternate. */ @@ -1495,9 +1085,12 @@ find_pc_line (pc, notcurrent) val.symtab = best_symtab; val.line = best_line; val.pc = best_pc; - val.end = (best_end ? best_end - : (alt_pc ? alt_pc - : BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)))); + if (best_end && (alt_pc == 0 || best_end < alt_pc)) + val.end = best_end; + else if (alt_pc) + val.end = alt_pc; + else + val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); } return val; } @@ -1711,7 +1304,7 @@ operator_chars (p, end) * physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*)); */ -int +static int find_methods (t, name, physnames, sym_arr) struct type *t; char *name; @@ -1804,7 +1397,7 @@ find_methods (t, name, physnames, sym_arr) FILE:FUNCTION -- likewise, but prefer functions in that file. *EXPR -- line in which address EXPR appears. - FUNCTION may be an undebuggable function found in misc_function_vector. + FUNCTION may be an undebuggable function found in minimal symbol table. If the argument FUNFIRSTLINE is nonzero, we want the first line of real code inside a function when a function is specified. @@ -1825,7 +1418,6 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) struct symtab *default_symtab; int default_line; { - struct symtabs_and_lines decode_line_2 (); struct symtabs_and_lines values; struct symtab_and_line val; register char *p, *p1; @@ -1837,7 +1429,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) struct symtab *sym_symtab; register CORE_ADDR pc; - register int i; + register struct minimal_symbol *msymbol; char *copy; struct symbol *sym_class; int i1; @@ -2016,7 +1608,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) s = lookup_symtab (copy); if (s == 0) { - if (symtab_list == 0 && partial_symtab_list == 0) + if (!have_full_symbols () && !have_partial_symbols ()) error (no_symtab_msg); error ("No source file named %s.", copy); } @@ -2127,7 +1719,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) advance to next line, recalculate its line number (might not be N+1). */ if (val.pc != pc && val.end && - find_pc_misc_function (pc) == find_pc_misc_function (val.end)) { + lookup_minimal_symbol_by_pc (pc) == lookup_minimal_symbol_by_pc (val.end)) { pc = val.end; /* First pc of next line */ val = find_pc_line (pc, 0); } @@ -2163,11 +1755,12 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) error ("Line number not known for symbol \"%s\"", copy); } - if ((i = lookup_misc_func (copy)) >= 0) + msymbol = lookup_minimal_symbol (copy, (struct objfile *) NULL); + if (msymbol != NULL) { val.symtab = 0; val.line = 0; - val.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET; + val.pc = msymbol -> address + FUNCTION_START_OFFSET; if (funfirstline) SKIP_PROLOGUE (val.pc); values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line)); @@ -2176,7 +1769,8 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line) return values; } - if (symtab_list == 0 && partial_symtab_list == 0 && misc_function_count == 0) + if (!have_full_symbols () && + !have_partial_symbols () && !have_minimal_symbols ()) error (no_symtab_msg); error ("Function %s not defined.", copy); @@ -2201,7 +1795,7 @@ decode_line_spec (string, funfirstline) /* Given a list of NELTS symbols in sym_arr (with corresponding mangled names in physnames), return a list of lines to operate on (ask user if necessary). */ -struct symtabs_and_lines +static struct symtabs_and_lines decode_line_2 (sym_arr, nelts, funfirstline) struct symbol *sym_arr[]; int nelts; @@ -2209,7 +1803,7 @@ decode_line_2 (sym_arr, nelts, funfirstline) { struct symtabs_and_lines values, return_values; register CORE_ADDR pc; - char *args, *arg1, *command_line_input (); + char *args, *arg1; int i; char *prompt; @@ -2244,7 +1838,7 @@ decode_line_2 (sym_arr, nelts, funfirstline) printf("%s ",prompt); fflush(stdout); - args = command_line_input (0, 0); + args = command_line_input ((char *) NULL, 0); if (args == 0) error_no_arg ("one or more choice numbers"); @@ -2295,19 +1889,6 @@ decode_line_2 (sym_arr, nelts, funfirstline) return return_values; } -/* Return the index of misc function named NAME. */ - -int -lookup_misc_func (name) - register char *name; -{ - register int i; - - for (i = 0; i < misc_function_count; i++) - if (!strcmp (misc_function_vector[i].name, name)) - return i; - return -1; /* not found */ -} /* Slave routine for sources_info. Force line breaks at ,'s. NAME is the name to print and *FIRST is nonzero if this is the first @@ -2317,7 +1898,7 @@ output_source_filename (name, first) char *name; int *first; { - static int column; + static unsigned int column; /* Table of files printed so far. Since a single source file can result in several partial symbol tables, we need to avoid printing it more than once. Note: if some of the psymtabs are read in and @@ -2352,7 +1933,7 @@ output_source_filename (name, first) if (tab_cur_size == tab_alloc_size) { tab_alloc_size *= 2; - tab = (char **) xrealloc (tab, tab_alloc_size * sizeof (*tab)); + tab = (char **) xrealloc ((char *) tab, tab_alloc_size * sizeof (*tab)); } tab[tab_cur_size++] = name; @@ -2386,9 +1967,10 @@ sources_info () { register struct symtab *s; register struct partial_symtab *ps; + register struct objfile *objfile; int first; - if (symtab_list == 0 && partial_symtab_list == 0) + if (!have_full_symbols () && !have_partial_symbols ()) { error (no_symtab_msg); } @@ -2396,16 +1978,28 @@ sources_info () printf_filtered ("Source files for which symbols have been read in:\n\n"); first = 1; - for (s = symtab_list; s; s = s->next) - output_source_filename (s->filename, &first); + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (s = objfile -> symtabs; s != NULL; s = s -> next) + { + output_source_filename (s -> filename, &first); + } + } printf_filtered ("\n\n"); printf_filtered ("Source files for which symbols will be read in on demand:\n\n"); first = 1; - for (ps = partial_symtab_list; ps; ps = ps->next) - if (!ps->readin) - output_source_filename (ps->filename, &first); + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (ps = objfile -> psymtabs; ps != NULL; ps = ps -> next) + { + if (!ps->readin) + { + output_source_filename (ps -> filename, &first); + } + } + } printf_filtered ("\n"); } @@ -2432,90 +2026,105 @@ list_symbols (regexp, class, bpt) register int i, j; register struct symbol *sym; struct partial_symbol *psym; + struct objfile *objfile; + struct minimal_symbol *msymbol; char *val; static char *classnames[] = {"variable", "function", "type", "method"}; int found_in_file = 0; int found_misc = 0; - static enum misc_function_type types[] - = {mf_data, mf_text, mf_abs, mf_unknown}; - static enum misc_function_type types2[] - = {mf_bss, mf_text, mf_abs, mf_unknown}; - enum misc_function_type ourtype = types[class]; - enum misc_function_type ourtype2 = types2[class]; + static enum minimal_symbol_type types[] + = {mst_data, mst_text, mst_abs, mst_unknown}; + static enum minimal_symbol_type types2[] + = {mst_bss, mst_text, mst_abs, mst_unknown}; + enum minimal_symbol_type ourtype = types[class]; + enum minimal_symbol_type ourtype2 = types2[class]; if (regexp) if (0 != (val = re_comp (regexp))) error ("Invalid regexp (%s): %s", val, regexp); - /* Search through the partial_symtab_list *first* for all symbols + /* Search through the partial symtabs *first* for all symbols matching the regexp. That way we don't have to reproduce all of the machinery below. */ - for (ps = partial_symtab_list; ps; ps = ps->next) - { - struct partial_symbol *bound, *gbound, *sbound; - int keep_going = 1; - 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.list + ps->globals_offset; - while (keep_going) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (ps = objfile -> psymtabs; ps != NULL; ps = ps -> next) { - if (psym >= bound) + struct partial_symbol *bound, *gbound, *sbound; + int keep_going = 1; + + if (ps->readin) continue; + + gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms; + sbound = objfile->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 = objfile->global_psymbols.list + ps->globals_offset; + while (keep_going) { - if (bound == gbound && ps->n_static_syms != 0) + if (psym >= bound) { - psym = static_psymbols.list + ps->statics_offset; - bound = sbound; + if (bound == gbound && ps->n_static_syms != 0) + { + psym = objfile->static_psymbols.list + ps->statics_offset; + bound = sbound; + } + else + keep_going = 0; + continue; } else - keep_going = 0; - continue; - } - else - { - QUIT; - - /* If it would match (logic taken from loop below) - load the file and go on to the next one */ - if ((regexp == 0 || re_exec (SYMBOL_NAME (psym))) - && ((class == 0 && SYMBOL_CLASS (psym) != LOC_TYPEDEF - && SYMBOL_CLASS (psym) != LOC_BLOCK) - || (class == 1 && SYMBOL_CLASS (psym) == LOC_BLOCK) - || (class == 2 && SYMBOL_CLASS (psym) == LOC_TYPEDEF) - || (class == 3 && SYMBOL_CLASS (psym) == LOC_BLOCK))) { - (void) PSYMTAB_TO_SYMTAB(ps); - keep_going = 0; + QUIT; + + /* If it would match (logic taken from loop below) + load the file and go on to the next one */ + if ((regexp == 0 || re_exec (SYMBOL_NAME (psym))) + && ((class == 0 && SYMBOL_CLASS (psym) != LOC_TYPEDEF + && SYMBOL_CLASS (psym) != LOC_BLOCK) + || (class == 1 && SYMBOL_CLASS (psym) == LOC_BLOCK) + || (class == 2 && SYMBOL_CLASS (psym) == LOC_TYPEDEF) + || (class == 3 && SYMBOL_CLASS (psym) == LOC_BLOCK))) + { + (void) PSYMTAB_TO_SYMTAB(ps); + keep_going = 0; + } } + psym++; } - psym++; } } - /* Here, we search through the misc function vector for functions that + /* Here, we search through the minimal symbol tables for functions that match, and call find_pc_symtab on them to force their symbols to be read. The symbol will then be found during the scan of symtabs below. If find_pc_symtab fails, set found_misc so that we will rescan to print any matching symbols without debug info. */ - if (class == 1) { - for (i = 0; i < misc_function_count; i++) { - if (misc_function_vector[i].type != ourtype - && misc_function_vector[i].type != ourtype2) - continue; - if (regexp == 0 || re_exec (misc_function_vector[i].name)) { - if (0 == find_pc_symtab (misc_function_vector[i].address)) - found_misc = 1; - } + if (class == 1) + { + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (msymbol = objfile -> msymbols; + msymbol -> name != NULL; msymbol++) + { + if (msymbol -> type == ourtype || msymbol -> type == ourtype2) + { + if (regexp == 0 || re_exec (msymbol -> name)) + { + if (0 == find_pc_symtab (msymbol -> address)) + { + found_misc = 1; + } + } + } + } + } } - } /* Printout here so as to get after the "Reading in symbols" messages which will be generated above. */ @@ -2526,111 +2135,124 @@ list_symbols (regexp, class, bpt) classnames[class], regexp); - for (s = symtab_list; s; s = s->next) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - found_in_file = 0; - bv = BLOCKVECTOR (s); - /* Often many files share a blockvector. - Scan each blockvector only once so that - we don't get every symbol many times. - It happens that the first symtab in the list - for any given blockvector is the main file. */ - if (bv != prev_bv) - for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++) - { - b = BLOCKVECTOR_BLOCK (bv, i); - /* Skip the sort if this block is always sorted. */ - if (!BLOCK_SHOULD_SORT (b)) - sort_block_syms (b); - for (j = 0; j < BLOCK_NSYMS (b); j++) + for (s = objfile -> symtabs; s != NULL; s = s -> next) + { + found_in_file = 0; + bv = BLOCKVECTOR (s); + /* Often many files share a blockvector. + Scan each blockvector only once so that + we don't get every symbol many times. + It happens that the first symtab in the list + for any given blockvector is the main file. */ + if (bv != prev_bv) + for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++) { - QUIT; - sym = BLOCK_SYM (b, j); - if ((regexp == 0 || re_exec (SYMBOL_NAME (sym))) - && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF - && SYMBOL_CLASS (sym) != LOC_BLOCK) - || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK) - || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF) - || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK))) + b = BLOCKVECTOR_BLOCK (bv, i); + /* Skip the sort if this block is always sorted. */ + if (!BLOCK_SHOULD_SORT (b)) + sort_block_syms (b); + for (j = 0; j < BLOCK_NSYMS (b); j++) { - if (bpt) - { - /* Set a breakpoint here, if it's a function */ - if (class == 1) - break_command (SYMBOL_NAME(sym), 0); - } - else if (!found_in_file) - { - fputs_filtered ("\nFile ", stdout); - fputs_filtered (s->filename, stdout); - fputs_filtered (":\n", stdout); - } - found_in_file = 1; - - if (class != 2 && i == STATIC_BLOCK) - printf_filtered ("static "); - - /* Typedef that is not a C++ class */ - if (class == 2 - && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE) - typedef_print (SYMBOL_TYPE(sym), sym, stdout); - /* variable, func, or typedef-that-is-c++-class */ - else if (class < 2 || - (class == 2 && - SYMBOL_NAMESPACE(sym) == STRUCT_NAMESPACE)) - { - type_print (SYMBOL_TYPE (sym), - (SYMBOL_CLASS (sym) == LOC_TYPEDEF - ? "" : SYMBOL_NAME (sym)), - stdout, 0); - - printf_filtered (";\n"); - } - else + QUIT; + sym = BLOCK_SYM (b, j); + if ((regexp == 0 || re_exec (SYMBOL_NAME (sym))) + && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF + && SYMBOL_CLASS (sym) != LOC_BLOCK) + || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK) + || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF) + || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK))) { + if (bpt) + { + /* Set a breakpoint here, if it's a function */ + if (class == 1) + break_command (SYMBOL_NAME(sym), 0); + } + else if (!found_in_file) + { + fputs_filtered ("\nFile ", stdout); + fputs_filtered (s->filename, stdout); + fputs_filtered (":\n", stdout); + } + found_in_file = 1; + + if (class != 2 && i == STATIC_BLOCK) + printf_filtered ("static "); + + /* Typedef that is not a C++ class */ + if (class == 2 + && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE) + typedef_print (SYMBOL_TYPE(sym), sym, stdout); + /* variable, func, or typedef-that-is-c++-class */ + else if (class < 2 || + (class == 2 && + SYMBOL_NAMESPACE(sym) == STRUCT_NAMESPACE)) + { + type_print (SYMBOL_TYPE (sym), + (SYMBOL_CLASS (sym) == LOC_TYPEDEF + ? "" : SYMBOL_NAME (sym)), + stdout, 0); + + printf_filtered (";\n"); + } + else + { # if 0 - char buf[1024]; - type_print_base (TYPE_FN_FIELD_TYPE(t, i), stdout, 0, 0); - type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t, i), stdout, 0); - sprintf (buf, " %s::", type_name_no_tag (t)); - type_print_method_args (TYPE_FN_FIELD_ARGS (t, i), buf, name, stdout); + char buf[1024]; + type_print_base (TYPE_FN_FIELD_TYPE(t, i), stdout, 0, 0); + type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t, i), stdout, 0); + sprintf (buf, " %s::", type_name_no_tag (t)); + type_print_method_args (TYPE_FN_FIELD_ARGS (t, i), buf, name, stdout); # endif + } } } } - } - prev_bv = bv; + prev_bv = bv; + } } - /* If there are no eyes, avoid all contact. I mean, if there are - no debug symbols, then print directly from the misc_function_vector. */ - - if (found_misc || class != 1) { - found_in_file = 0; - for (i = 0; i < misc_function_count; i++) { - if (misc_function_vector[i].type != ourtype - && misc_function_vector[i].type != ourtype2) - continue; - if (regexp == 0 || re_exec (misc_function_vector[i].name)) { - /* Functions: Look up by address. */ - if (class == 1) - if (0 != find_pc_symtab (misc_function_vector[i].address)) - continue; - /* Variables/Absolutes: Look up by name */ - if (0 != lookup_symbol (misc_function_vector[i].name, - (struct block *)0, VAR_NAMESPACE, 0, (struct symtab **)0)) - continue; - if (!found_in_file) { - printf_filtered ("\nNon-debugging symbols:\n"); - found_in_file = 1; + no debug symbols, then print directly from the msymbol_vector. */ + + if (found_misc || class != 1) + { + found_in_file = 0; + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (msymbol = objfile -> msymbols; + msymbol -> name != NULL; msymbol++) + { + if (msymbol -> type == ourtype || msymbol -> type == ourtype2) + { + if (regexp == 0 || re_exec (msymbol -> name)) + { + /* Functions: Look up by address. */ + if (class != 1 && + (find_pc_symtab (msymbol -> address) != NULL)) + { + /* Variables/Absolutes: Look up by name */ + if (lookup_symbol (msymbol -> name, + (struct block *) 0, VAR_NAMESPACE, 0, + (struct symtab **) 0) == NULL) + { + if (!found_in_file) + { + printf_filtered ("\nNon-debugging symbols:\n"); + found_in_file = 1; + } + printf_filtered (" %08x %s\n", + msymbol -> address, + msymbol -> name); + } + } + } + } + } } - printf_filtered (" %08x %s\n", - misc_function_vector[i].address, - misc_function_vector[i].name); - } } - } } static void @@ -2672,30 +2294,6 @@ rbreak_command (regexp) list_symbols (regexp, 1, 1); } -/* Helper function to initialize the standard scalar types. */ - -struct type * -init_type (code, length, uns, name) - enum type_code code; - int length, uns; - char *name; -{ - register struct type *type; - - type = (struct type *) xmalloc (sizeof (struct type)); - bzero (type, sizeof *type); - TYPE_CODE (type) = code; - TYPE_LENGTH (type) = length; - TYPE_FLAGS (type) = uns ? TYPE_FLAG_UNSIGNED : 0; - TYPE_FLAGS (type) |= TYPE_FLAG_PERM; - TYPE_NFIELDS (type) = 0; - TYPE_NAME (type) = name; - - /* C++ fancies. */ - if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION) - INIT_CPLUS_SPECIFIC(type); - return type; -} /* Return Nonzero if block a is lexically nested within block b, or if a and b have the same pc range. @@ -2716,14 +2314,13 @@ contained_in (a, b) int return_val_size, return_val_index; char **return_val; -void +static 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 = (char **) xrealloc ((char *) return_val, + (return_val_size *= 2) * sizeof (char *)); return_val[return_val_index] = (char *)xmalloc (1 + strlen (symname)); @@ -2747,8 +2344,9 @@ make_symbol_completion_list (text) { register struct symtab *s; register struct partial_symtab *ps; + register struct minimal_symbol *msymbol; + register struct objfile *objfile; register struct block *b, *surrounding_static_block = 0; - extern struct block *get_selected_block (); register int i, j; struct partial_symbol *psym; @@ -2762,41 +2360,52 @@ make_symbol_completion_list (text) /* 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) + for (objfile = object_files; objfile != NULL; objfile = objfile -> 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++) + for (ps = objfile -> psymtabs; ps != NULL; ps = ps -> next) { - 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)); + /* If the psymtab's been read in we'll get it when we search + through the blockvector. */ + if (ps->readin) continue; + + for (psym = objfile->global_psymbols.list + ps->globals_offset; + psym < (objfile->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 = objfile->static_psymbols.list + ps->statics_offset; + psym < (objfile->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 + /* At this point scan through the misc symbol vectors 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); + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) + { + for (msymbol = objfile -> msymbols; + msymbol ->name != NULL; msymbol++) + { + if (strncmp (text, msymbol -> name, text_len) == 0) + { + completion_list_add_symbol (msymbol -> name); + } + } + } /* Search upwards from currently selected frame (so that we can complete on local vars. */ @@ -2832,25 +2441,31 @@ make_symbol_completion_list (text) /* Go through the symtabs and check the externs and statics for symbols which match. */ - for (s = symtab_list; s; s = s->next) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - - 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 = objfile ->symtabs; s != NULL; s = s -> next) + { + b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); + + 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) + for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { - b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); - - /* 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))); + for (s = objfile -> symtabs; s != NULL; s = s -> next) + { + b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); + + /* 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); @@ -2887,12 +2502,12 @@ add_param_to_type (type,sym) int num = ++(TYPE_NFIELDS(*type)); if(TYPE_NFIELDS(*type)-1) - TYPE_FIELDS(*type) = - (struct field *)xrealloc((char *)(TYPE_FIELDS(*type)), - num*sizeof(struct field)); + TYPE_FIELDS(*type) = (struct field *) + (*current_objfile->xrealloc) ((char *)(TYPE_FIELDS(*type)), + num*sizeof(struct field)); else - TYPE_FIELDS(*type) = - (struct field *)xmalloc(num*sizeof(struct field)); + TYPE_FIELDS(*type) = (struct field *) + (*current_objfile->xmalloc) (num*sizeof(struct field)); TYPE_FIELD_BITPOS(*type,num-1) = num-1; TYPE_FIELD_BITSIZE(*type,num-1) = 0; @@ -2924,7 +2539,7 @@ _initialize_symtab () add_info ("methods", methods_info, "All method names, or those matching REGEXP::REGEXP.\n\ If the class qualifier is ommited, it is assumed to be the current scope.\n\ -If the first REGEXP is ommited, then all methods matching the second REGEXP\n\ +If the first REGEXP is omitted, then all methods matching the second REGEXP\n\ are listed."); #endif add_info ("sources", sources_info, @@ -2934,5 +2549,6 @@ are listed."); "Set a breakpoint for all functions matching REGEXP."); /* Initialize the one built-in type that isn't language dependent... */ - builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>"); + builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0, + "<unknown type>", (struct objfile *) NULL); } |