aboutsummaryrefslogtreecommitdiff
path: root/gdb/dbxread.c
diff options
context:
space:
mode:
Diffstat (limited to 'gdb/dbxread.c')
-rw-r--r--gdb/dbxread.c817
1 files changed, 779 insertions, 38 deletions
diff --git a/gdb/dbxread.c b/gdb/dbxread.c
index 007e768..c1c4acc 100644
--- a/gdb/dbxread.c
+++ b/gdb/dbxread.c
@@ -1,5 +1,6 @@
/* Read dbx symbol tables and convert to internal format, for GDB.
- Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
+ Hacked by Michael Tiemann (tiemann@mcc.com)
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
@@ -46,7 +47,12 @@ static struct symbol *define_symbol ();
static void start_subfile ();
static int hashname ();
static void hash_symsegs ();
+
extern struct symtab *read_symsegs ();
+extern void free_all_symtabs ();
+
+/* C++ */
+static struct type **read_args ();
START_FILE
@@ -468,6 +474,7 @@ dbx_alloc_type (typenums)
type = (struct type *) obstack_alloc (symbol_obstack,
sizeof (struct type));
bzero (type, sizeof (struct type));
+ TYPE_VPTR_FIELDNO (type) = -1;
*type_addr = type;
}
return type;
@@ -682,6 +689,8 @@ start_symtab (name, start_addr)
if (s->ldsymoff == symnum * sizeof (struct nlist))
break;
current_symseg = s;
+ if (s != 0)
+ return;
type_vector_length = 160;
type_vector = (struct typevector *) xmalloc (sizeof (struct typevector) + type_vector_length * sizeof (struct type *));
@@ -767,6 +776,13 @@ end_symtab (end_addr)
register struct linetable *lv;
struct subfile *nextsub;
+ if (current_symseg != 0)
+ {
+ last_source_file = 0;
+ current_symseg = 0;
+ return;
+ }
+
/* Finish the lexical context of the last function in the file. */
if (context_stack)
@@ -779,12 +795,10 @@ end_symtab (end_addr)
}
/* Finish defining all the blocks of this symtab. */
- if (current_symseg == 0)
- {
- finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
- finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
- blockvector = make_blockvector ();
- }
+ finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
+ finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
+ blockvector = make_blockvector ();
+
current_subfile->line_vector_index = line_vector_index;
/* Now create the symtab objects proper, one for each subfile. */
@@ -793,22 +807,16 @@ end_symtab (end_addr)
for (subfile = subfiles; subfile; subfile = nextsub)
{
symtab = (struct symtab *) xmalloc (sizeof (struct symtab));
+ symtab->free_ptr = 0;
+
/* Fill in its components. */
- if (current_symseg)
- {
- bcopy (current_symseg, symtab, sizeof (struct symtab));
- symtab->free_code = free_linetable;
- symtab->free_ptr = 0;
- }
- else
- {
- symtab->blockvector = blockvector;
- type_vector->length = type_vector_length;
- symtab->typevector = type_vector;
- symtab->free_code = free_linetable;
- if (subfile->next == 0)
- symtab->free_ptr = (char *) type_vector;
- }
+ symtab->blockvector = blockvector;
+ type_vector->length = type_vector_length;
+ symtab->typevector = type_vector;
+ symtab->free_code = free_linetable;
+ if (subfile->next == 0)
+ symtab->free_ptr = (char *) type_vector;
+
symtab->filename = subfile->name;
lv = subfile->line_vector;
lv->nitems = subfile->line_vector_index;
@@ -1049,6 +1057,7 @@ symbol_file_command (name)
register int val;
extern void close ();
struct cleanup *old_chain;
+ struct symtab *symseg;
dont_repeat ();
@@ -1094,6 +1103,9 @@ symbol_file_command (name)
return;
}
+ printf ("Reading symbol data from %s...", name);
+ fflush (stdout);
+
/* Now read the string table, all at once. */
val = lseek (desc, N_SYMOFF (hdr) + hdr.a_syms, 0);
if (val < 0)
@@ -1102,15 +1114,52 @@ symbol_file_command (name)
if (val < 0)
perror_with_name (name);
stringtab = (char *) alloca (buffer);
+ if (stringtab == NULL)
+ {
+ free_all_symtabs ();
+ printf("%s: symbol table too large for alloca: %d bytes.\n", name,
+ buffer);
+ fflush (stdout);
+ return;
+ }
bcopy (&buffer, stringtab, sizeof buffer);
val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
if (val < 0)
perror_with_name (name);
+ /* Throw away the old symbol table. */
+
+ free_all_symtabs ();
+
#ifdef READ_GDB_SYMSEGS
/* That puts us at the symsegs. Read them. */
symseg_chain = read_symsegs (desc, name);
hash_symsegs ();
+
+ /* Free the symtabs made by read_symsegs, but not their contents,
+ which have been copied into symtabs on symtab_list. */
+ for (symseg = symseg_chain; symseg; symseg = symseg->next)
+ {
+ int i;
+ struct sourcevector *sv = (struct sourcevector *) symseg->linetable;
+
+ for (i = 0; i < sv->length; i++)
+ {
+ int j;
+ struct source *source = sv->source[i];
+ struct symtab *sp1
+ = (struct symtab *) xmalloc (sizeof (struct symtab));
+
+ bcopy (symseg, sp1, sizeof (struct symtab));
+ sp1->filename = savestring (source->name, strlen (source->name));
+ sp1->linetable = &source->contents;
+ sp1->free_code = free_nothing;
+ sp1->free_ptr = (i == 0) ? (char *) symseg : 0;
+
+ sp1->next = symtab_list;
+ symtab_list = sp1;
+ }
+ }
#else
/* Where people are using the 4.2 ld program, must not check for
symsegs, because that ld puts randonm garbage at the end of
@@ -1123,13 +1172,6 @@ symbol_file_command (name)
if (val < 0)
perror_with_name (name);
- printf ("Reading symbol data from %s...", name);
- fflush (stdout);
-
- /* Throw away the old symbol table. */
-
- free_all_symtabs ();
-
init_misc_functions ();
make_cleanup (discard_misc_bunches, 0);
init_header_files ();
@@ -1199,11 +1241,13 @@ read_dbx_symtab (desc, stringtab, nlistlen)
register struct symbol *sym, *prev;
int hash;
int num_object_files = 0;
+ struct cleanup *old_chain;
#ifdef N_BINCL
subfile_stack = 0;
#endif
+ old_chain = make_cleanup (free_all_symtabs, 0);
nlist_stream_global = stream;
nlist_size_global = nlistlen;
stringtab_global = stringtab;
@@ -1212,6 +1256,7 @@ read_dbx_symtab (desc, stringtab, nlistlen)
for (symnum = 0; symnum < nlistlen; symnum++)
{
+ QUIT; /* allow this to be interruptable */
fread (&buf, sizeof buf, 1, stream);
namestring = buf.n_un.n_strx ? buf.n_un.n_strx + stringtab : "";
if (buf.n_type & N_STAB)
@@ -1303,6 +1348,7 @@ read_dbx_symtab (desc, stringtab, nlistlen)
end_symtab (end_of_text_addr);
fclose (stream);
+ discard_cleanups (old_chain);
}
/* dbx allows the text of a symbol name to be continued into the
@@ -1517,6 +1563,317 @@ process_one_symbol (type, desc, value, name)
}
}
+/************************ READ_ADDL_SYM() ***********************************/
+
+static void
+read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
+ int desc;
+ register char *stringtab;
+ register int nlistlen;
+ unsigned text_addr;
+ int text_size;
+{
+ FILE *stream = fdopen (desc, "r");
+ struct nlist buf;
+ register char *namestring;
+ register struct symbol *sym, *prev;
+ int hash;
+ int num_object_files = 0;
+
+#ifdef N_BINCL
+ subfile_stack = 0;
+#endif
+
+ nlist_stream_global = stream;
+ nlist_size_global = nlistlen;
+ stringtab_global = stringtab;
+ last_source_file = 0;
+ bzero (global_sym_chain, sizeof global_sym_chain);
+
+ for (symnum = 0; symnum < nlistlen; symnum++)
+ {
+ unsigned type;
+
+ fread (&buf, sizeof buf, 1, stream);
+
+ type = buf.n_type & N_TYPE;
+ if( (type == N_TEXT) || (type == N_DATA) || (type == N_BSS) )
+ {
+ buf.n_value += text_addr;
+ } /* Right?? ###### */
+
+
+ namestring = buf.n_un.n_strx ? buf.n_un.n_strx + stringtab : "";
+ if (buf.n_type & N_STAB)
+ process_one_symbol (buf.n_type, buf.n_desc,
+ buf.n_value, namestring);
+ /* A static text symbol whose name ends in ".o"
+ can only mean the start of another object file.
+ So end the symtab of the source file we have been processing.
+ This is how we avoid counting the libraries as part
+ or the last source file.
+ Also this way we find end of first object file (crt0). */
+ else if (buf.n_type == N_TEXT
+ && !strcmp (namestring + strlen (namestring) - 2, ".o"))
+ {
+ if (num_object_files++ == 1)
+ first_object_file_end = buf.n_value;
+ if (last_source_file)
+ {
+ end_symtab (buf.n_value); /* All this not used##### */
+ }
+ }
+ else if (buf.n_type & N_EXT || buf.n_type == N_TEXT)
+ {
+ int used_up = 0;
+
+ /* Record the location of _etext. */
+ if (buf.n_type == (N_TEXT | N_EXT)
+ && !strcmp (namestring, "_etext"))
+ {
+ end_of_text_addr = buf.n_value;
+ }
+
+ /* Global symbol: see if we came across a dbx definition
+ for a corresponding symbol. If so, store the value.
+ Remove syms from the chain when their values are stored,
+ but search the whole chain, as there may be several syms
+ from different files with the same name. */
+ if (buf.n_type & N_EXT)
+ {
+ prev = 0;
+#ifdef NAMES_HAVE_UNDERSCORE
+ hash = hashname (namestring + 1);
+#else /* not NAMES_HAVE_UNDERSCORE */
+ hash = hashname (namestring);
+#endif /* not NAMES_HAVE_UNDERSCORE */
+ for (sym = global_sym_chain[hash];
+ sym;)
+ {
+ if (
+#ifdef NAMES_HAVE_UNDERSCORE
+ *namestring == '_'
+ && namestring[1] == SYMBOL_NAME (sym)[0]
+ &&
+ !strcmp (namestring + 2, SYMBOL_NAME (sym) + 1)
+#else /* NAMES_HAVE_UNDERSCORE */
+ namestring[0] == SYMBOL_NAME (sym)[0]
+ &&
+ !strcmp (namestring + 1, SYMBOL_NAME (sym) + 1)
+#endif /* NAMES_HAVE_UNDERSCORE */
+ )
+ {
+ if (prev)
+ SYMBOL_VALUE (prev) = SYMBOL_VALUE (sym);
+ else
+ global_sym_chain[hash]
+ = (struct symbol *) SYMBOL_VALUE (sym);
+ SYMBOL_VALUE (sym) = buf.n_value;
+ if (prev)
+ sym = (struct symbol *) SYMBOL_VALUE (prev);
+ else
+ sym = global_sym_chain[hash];
+
+ used_up = 1;
+ }
+ else
+ {
+ prev = sym;
+ sym = (struct symbol *) SYMBOL_VALUE (sym);
+ }
+ }
+ }
+
+ /* Defined global or text symbol: record as a misc function
+ if it didn't give its address to a debugger symbol above. */
+ if (buf.n_type <= (N_TYPE | N_EXT)
+ && buf.n_type != N_EXT
+ && ! used_up)
+ record_misc_function (namestring, buf.n_value);
+ }
+ }
+
+ if (last_source_file)
+ {
+ end_symtab (text_addr + text_size);
+ }
+
+ fclose (stream);
+}
+
+/***************************** CONDENSE_ADDL_MISC_BUNCHES *******************/
+
+static void
+condense_addl_misc_bunches ()
+{
+ register int i, j;
+ register struct misc_bunch *bunch;
+#ifdef NAMES_HAVE_UNDERSCORE
+ int offset = 1;
+#else
+ int offset = 0;
+#endif
+
+ misc_function_vector
+ = (struct misc_function *) xrealloc (misc_function_vector,
+ (misc_count + misc_function_count) * sizeof (struct misc_function));
+
+ j = misc_function_count;
+ bunch = misc_bunch;
+ while (bunch)
+ {
+ for (i = 0; i < misc_bunch_index; i++)
+ {
+ misc_function_vector[j] = bunch->contents[i];
+ misc_function_vector[j].name
+ = concat (misc_function_vector[j].name
+ + (misc_function_vector[j].name[0] == '_' ? offset : 0),
+ "", "");
+ j++;
+ }
+ bunch = bunch->next;
+ misc_bunch_index = MISC_BUNCH_SIZE;
+ }
+
+ misc_function_count += misc_count;
+
+ /* Sort the misc functions by address. */
+
+ qsort (misc_function_vector, misc_function_count,
+ sizeof (struct misc_function), compare_misc_functions);
+}
+
+/**************************** ADD_FILE_COMMAND() ****************************/
+/* This function allows the addition of incrementally linked object files.
+ Useful for debugging `sun_kick'. */
+
+void
+add_file_command (arg_string)
+ char* arg_string;
+{
+ register int desc;
+ struct exec hdr;
+ struct nlist *nlist;
+ char *stringtab;
+ long buffer;
+ register int val;
+ extern void close ();
+ struct cleanup *old_chain;
+ char* name;
+ unsigned text_addr;
+
+ for( ; *arg_string == ' '; arg_string++ );
+ name = arg_string;
+ for( ; *arg_string != ' ' ; arg_string++ );
+ *arg_string++ = (char) 0;
+ for( ; *arg_string == ' '; arg_string++ );
+ text_addr = (unsigned) atoi(arg_string);
+
+ printf("filename \"%s\", and text_addr = 0x%x\n", name, text_addr );
+
+ dont_repeat ();
+
+ if (name == 0)
+ {
+ if (symtab_list && !query ("Discard symbol table? ", 0))
+ error ("Not confirmed.");
+ free_all_symtabs ();
+ return;
+ }
+
+ /* if (symtab_list && !query ("Add new symbols from \"%s\"? ", name))
+ error ("Not confirmed.");
+ */
+ {
+ char *absolute_name;
+ desc = openp (getenv ("PATH"), 1, name, O_RDONLY, 0, &absolute_name);
+ if (desc < 0)
+ perror_with_name (name);
+ else
+ name = absolute_name;
+ }
+
+ old_chain = make_cleanup (close, desc);
+ make_cleanup (free_current_contents, &name);
+
+ val = myread (desc, &hdr, sizeof hdr);
+ if (val < 0)
+ perror_with_name (name);
+
+ if (N_BADMAG (hdr))
+ error ("File \"%s\" has a bad header.", name);
+
+ if (hdr.a_syms == 0)
+ {
+ printf ("%s does not have a symbol-table.\n", name);
+ fflush (stdout);
+ return;
+ }
+
+ /* Now read the string table, all at once. */
+ val = lseek (desc, N_SYMOFF (hdr) + hdr.a_syms, 0);
+ if (val < 0)
+ perror_with_name (name);
+ val = myread (desc, &buffer, sizeof buffer);
+ if (val < 0)
+ perror_with_name (name);
+ stringtab = (char *) alloca (buffer);
+ bcopy (&buffer, stringtab, sizeof buffer);
+ val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
+ if (val < 0)
+ perror_with_name (name);
+
+ /* That puts us at the symsegs. Read them. ########## Also need other
+ changes if they exist. */
+
+
+ /* Position to read the symbol table. Do not read it all at once. */
+ val = lseek (desc, N_SYMOFF (hdr), 0);
+ if (val < 0)
+ perror_with_name (name);
+
+ printf ("Reading symbol data from %s...", name);
+ fflush (stdout);
+
+ init_misc_functions ();
+ make_cleanup (discard_misc_bunches, 0);
+ init_header_files ();
+ make_cleanup (free_header_files, 0);
+
+ read_addl_syms (desc, stringtab, hdr.a_syms / sizeof(struct nlist)
+ ,text_addr, hdr.a_text) ;
+
+ /* Sort symbols alphabetically within each block. */
+
+ sort_syms ();
+
+ /* Go over the all misc functions and install them in vector. */
+
+ condense_addl_misc_bunches ();
+
+ /* Don't allow char * to have a typename (else would get caddr_t.) */
+
+ TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
+
+ /* Make a default for file to list. */
+
+ select_source_symtab (symtab_list);
+
+ do_cleanups (old_chain);
+
+ /* Free the symtabs made by read_symsegs, but not their contents,
+ which have been copied into symtabs on symtab_list. */
+ while (symseg_chain)
+ {
+ register struct symtab *s = symseg_chain->next;
+ free (symseg_chain);
+ symseg_chain = s;
+ }
+
+ printf ("done.\n");
+ fflush (stdout);
+}
+
static struct symbol *
define_symbol (value, string, desc)
int value;
@@ -1668,6 +2025,16 @@ define_symbol (value, string, desc)
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
&& (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
TYPE_NAME (SYMBOL_TYPE (sym)) = concat (SYMBOL_NAME (sym), "", "");
+ /* C++ vagaries: we may have a type which is derived from
+ a base type which did not have its name defined when the
+ derived class was output. We fill in the derived class's
+ base part member's name here in that case. */
+ else if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
+ || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
+ && TYPE_BASECLASS (SYMBOL_TYPE (sym))
+ && TYPE_FIELD_NAME (SYMBOL_TYPE (sym), 0) == 0)
+ TYPE_FIELD_NAME (SYMBOL_TYPE (sym), 0) = TYPE_NAME (TYPE_BASECLASS (SYMBOL_TYPE (sym)));
+
add_symbol_to_list (sym, &file_symbols);
break;
@@ -1771,6 +2138,10 @@ read_type (pp)
break;
}
/* Skip the name the cross-ref points to. */
+ /* Note: for C++, the cross reference may be to a base type which
+ has not yet been seen. In this case, we skip to the comma,
+ which will mark the end of the base class name. (The ':'
+ at the end of the base class name will be skipped as well.) */
*pp = (char *) index (*pp, ',');
/* Just allocate the type and leave it zero if nothing known */
return dbx_alloc_type (typenums);
@@ -1799,6 +2170,27 @@ read_type (pp)
smash_to_pointer_type (type, read_type (pp));
break;
+ case '@':
+ {
+ struct type *domain = read_type (pp);
+ char c;
+ struct type *ptrtype;
+
+ if (*(*pp)++ != ',')
+ error ("invalid member pointer data format, at symtab pos %d.",
+ symnum);
+
+ ptrtype = read_type (pp);
+ type = dbx_alloc_type (typenums);
+ smash_to_member_pointer_type (type, domain, ptrtype);
+ }
+ break;
+
+ case '&':
+ type = dbx_alloc_type (typenums);
+ smash_to_reference_type (type, read_type (pp));
+ break;
+
case 'f':
type = dbx_alloc_type (typenums);
smash_to_function_type (type, read_type (pp));
@@ -1892,9 +2284,23 @@ read_struct_type (pp, type)
struct nextfield
{
struct nextfield *next;
+ int visibility;
struct field field;
};
+ struct next_fnfield
+ {
+ struct next_fnfield *next;
+ int visibility;
+ struct fn_field fn_field;
+ };
+
+ struct next_fnfieldlist
+ {
+ struct next_fnfieldlist *next;
+ struct fn_fieldlist fn_fieldlist;
+ };
+
register struct nextfield *list = 0;
struct nextfield *new;
int totalsize;
@@ -1903,20 +2309,72 @@ read_struct_type (pp, type)
int nfields = 0;
register int n;
+ register struct next_fnfieldlist *mainlist = 0;
+ int nfn_fields = 0;
+ struct type *baseclass = NULL;
+ int read_possible_virtual_info = 0;
+
TYPE_CODE (type) = TYPE_CODE_STRUCT;
/* First comes the total size in bytes. */
TYPE_LENGTH (type) = read_number (pp, 0);
- /* Now come the fields, as NAME:TYPENUM,BITPOS,BITSIZE; for each one.
- At the end, we see a semicolon instead of a field. */
+ /* C++: Now, if the class is a derived class, then the next character
+ will be a '!', followed by the type of the base class. Allocate
+ pretend that that base class is a sub-structure of this one,
+ with its field name being the type name of the derived class. This
+ cannot cause a naming conflict, since field names cannot be
+ type names. This will magically recurse itself to gound terms
+ when all is read and done. */
+ if (**pp == '!')
+ {
+ *pp += 1;
+
+ switch (*(*pp)++)
+ {
+ case '0':
+ break;
+ case '1':
+ TYPE_VIA_PROTECTED (type) = 1;
+ break;
+ case '2':
+ TYPE_VIA_PUBLIC (type) = 1;
+ break;
+ default:
+ error ("Invalid symbol data: bad visibility format at symtab pos %d.",
+ symnum);
+ }
+
+ if (**pp == '\\') *pp = next_symbol_text ();
+ new = (struct nextfield *) alloca (sizeof (struct nextfield));
+ new->next = list;
+ list = new;
+
+ baseclass = read_type (pp);
+ list->field.type = baseclass;
+ list->field.name = TYPE_NAME (baseclass);
+ *pp += 1; /* skip ',' */
+ list->field.bitpos = 0;
+ list->field.bitsize = 0; /* this should be an unpacked field! */
+ nfields++;
+ }
+
+ /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
+ At the end, we see a semicolon instead of a field.
+
+ In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
+ a static field.
+
+ The `?' is a placeholder for one of '+' (public visibility),
+ '0' (protected visibility), and '-' (private visibility). */
while (**pp != ';')
{
+ int visibility;
+
/* Check for and handle cretinous dbx symbol name continuation! */
- if (**pp == '\\')
- *pp = next_symbol_text ();
+ if (**pp == '\\') *pp = next_symbol_text ();
/* Get space to record the next field's data. */
new = (struct nextfield *) alloca (sizeof (struct nextfield));
@@ -1927,9 +2385,48 @@ read_struct_type (pp, type)
p = *pp;
while (*p != ':') p++;
list->field.name = savestring (*pp, p - *pp);
+
+ /* Check to see if we have hit the methods yet. */
+ if (p[1] == ':')
+ break;
+
*pp = p + 1;
+
+ /* This means we have a visibility for a field coming. */
+ if (**pp == '/')
+ {
+ switch (*++*pp)
+ {
+ case '0':
+ visibility = 0;
+ *pp += 1;
+ break;
+
+ case '1':
+ visibility = 1;
+ *pp += 1;
+ break;
+
+ case '2':
+ visibility = 2;
+ *pp += 1;
+ break;
+ }
+ }
+ /* else normal dbx-style format. */
+
list->field.type = read_type (pp);
- if (**pp != ',')
+ if (**pp == ':')
+ {
+ list->field.bitpos = (long)-1;
+ p = ++(*pp);
+ while (*p != ';') p++;
+ list->field.bitsize = (long) savestring (*pp, p - *pp);
+ *pp = p + 1;
+ nfields++;
+ continue;
+ }
+ else if (**pp != ',')
error ("Invalid symbol data: bad structure-type format at symtab pos %d.",
symnum);
(*pp)++; /* Skip the comma. */
@@ -1950,18 +2447,218 @@ read_struct_type (pp, type)
nfields++;
}
- (*pp)++; /* Skip the terminating ';'. */
+ /* Now come the method fields, as NAME::methods
+ where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
+ At the end, we see a semicolon instead of a field.
+
+ For the case of overloaded operators, the format is
+ OPERATOR::*.methods, where OPERATOR is the string "operator",
+ `*' holds the place for an operator name (such as `+=')
+ and `.' marks the end of the operator name. */
+ if (p[1] == ':')
+ {
+ /* Now, read in the methods. To simplify matters, we
+ "unread" the name that has been read, so that we can
+ start from the top. */
+
+ p = *pp;
+
+ /* chill the list of fields: the last entry (at the head)
+ is a partially constructed entry which we now scrub. */
+ list = list->next;
+
+ /* For each list of method lists... */
+ do
+ {
+ int i;
+ struct next_fnfield *sublist = 0;
+ struct fn_field *fn_fields = 0;
+ int length = 0;
+ struct next_fnfieldlist *new_mainlist =
+ (struct next_fnfieldlist *)alloca (sizeof (struct next_fnfieldlist));
+
+ /* read in the name. */
+ while (*p != ':') p++;
+ if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && (*pp)[2] == '$')
+ {
+ static char opname[32] = "operator ";
+ char *o = opname + 9;
+
+ /* Skip past '::'. */
+ p += 2;
+ while (*p != '.')
+ *o++ = *p++;
+ new_mainlist->fn_fieldlist.name = savestring (opname, o - opname);
+ /* Skip past '.' */
+ *pp = p + 1;
+ }
+ else
+ {
+ i = 0;
+ new_mainlist->fn_fieldlist.name = savestring (*pp, p - *pp);
+ /* Skip past '::'. */
+ *pp = p + 2;
+ }
+
+ do
+ {
+ struct next_fnfield *new_sublist =
+ (struct next_fnfield *)alloca (sizeof (struct next_fnfield));
+
+ /* Check for and handle cretinous dbx symbol name continuation! */
+ if (**pp == '\\') *pp = next_symbol_text ();
+
+ new_sublist->fn_field.type = read_type (pp);
+ new_sublist->fn_field.args = read_args (pp, ':');
+ p = *pp;
+ while (*p != ';') p++;
+ new_sublist->fn_field.physname = savestring (*pp, p - *pp);
+ *pp = p + 1;
+ new_sublist->visibility = *(*pp)++ - '0';
+ if (**pp == '\\') *pp = next_symbol_text ();
+
+ if (*(*pp)++ == '*')
+ new_sublist->fn_field.voffset = read_number (pp, ';') + 1;
+ else
+ new_sublist->fn_field.voffset = 0;
+
+ new_sublist->next = sublist;
+ sublist = new_sublist;
+ length++;
+ }
+ while (**pp != ';');
+
+ *pp += 1;
+
+ new_mainlist->fn_fieldlist.fn_fields =
+ (struct fn_field *) obstack_alloc (symbol_obstack,
+ sizeof (struct fn_field) * length);
+ TYPE_FN_PRIVATE_BITS (new_mainlist->fn_fieldlist) =
+ (int *) obstack_alloc (symbol_obstack,
+ sizeof (int) * (1 + (length >> 5)));
+
+ TYPE_FN_PROTECTED_BITS (new_mainlist->fn_fieldlist) =
+ (int *) obstack_alloc (symbol_obstack,
+ sizeof (int) * (1 + (length >> 5)));
+
+ for (i = length; sublist; sublist = sublist->next)
+ {
+ new_mainlist->fn_fieldlist.fn_fields[--i] = sublist->fn_field;
+ if (sublist->visibility == 0)
+ B_SET (new_mainlist->fn_fieldlist.private_fn_field_bits, i);
+ else if (sublist->visibility == 1)
+ B_SET (new_mainlist->fn_fieldlist.protected_fn_field_bits, i);
+ }
+
+ new_mainlist->fn_fieldlist.length = length;
+ new_mainlist->next = mainlist;
+ mainlist = new_mainlist;
+ nfn_fields++;
+ }
+ while (**pp != ';');
+
+ *pp += 2;
+
+ if (**pp == '~')
+ {
+ read_possible_virtual_info = 1;
+ *pp += 1;
+ }
+ if (**pp == '-')
+ {
+ TYPE_HAS_DESTRUCTOR (type) = 1;
+ TYPE_HAS_CONSTRUCTOR (type) = 1;
+ *pp += 1;
+ }
+ else if (**pp == '+')
+ {
+ TYPE_HAS_CONSTRUCTOR (type) = 1;
+ *pp += 1;
+ }
+ }
+ else *pp += 1;
/* Now create the vector of fields, and record how big it is. */
TYPE_NFIELDS (type) = nfields;
TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack,
sizeof (struct field) * nfields);
+ TYPE_FIELD_PRIVATE_BITS (type) =
+ (int *) obstack_alloc (symbol_obstack,
+ sizeof (int) * (1 + (nfields >> 5)));
+ TYPE_FIELD_PROTECTED_BITS (type) =
+ (int *) obstack_alloc (symbol_obstack,
+ sizeof (int) * (1 + (nfields >> 5)));
+
+ TYPE_NFN_FIELDS (type) = nfn_fields;
+ TYPE_NFN_FIELDS_TOTAL (type) = nfn_fields;
+ if (baseclass)
+ TYPE_NFN_FIELDS_TOTAL (type) += TYPE_NFN_FIELDS_TOTAL (baseclass);
+
+ TYPE_FN_FIELDLISTS (type) =
+ (struct fn_fieldlist *) obstack_alloc (symbol_obstack,
+ sizeof (struct fn_fieldlist) * nfn_fields);
/* Copy the saved-up fields into the field vector. */
for (n = nfields; list; list = list->next)
- TYPE_FIELD (type, --n) = list->field;
+ {
+ TYPE_FIELD (type, --n) = list->field;
+ if (list->visibility == 0)
+ SET_TYPE_FIELD_PRIVATE (type, n);
+ else if (list->visibility == 1)
+ SET_TYPE_FIELD_PROTECTED (type, n);
+ }
+
+ for (n = nfn_fields; mainlist; mainlist = mainlist->next)
+ TYPE_FN_FIELDLISTS (type)[--n] = mainlist->fn_fieldlist;
+
+ TYPE_BASECLASS (type) = baseclass;
+
+ if (read_possible_virtual_info)
+ {
+ /* Read either a '%' or the final ';'. */
+ if (*(*pp)++ == '%')
+ {
+ /* Now we must record the virtual function table pointer's
+ field information. */
+
+ struct type *t;
+ int i;
+
+ t = read_type (pp);
+ p = (*pp)++;
+ while (*p != ';') p++;
+ TYPE_VPTR_BASETYPE (type) = t;
+ if (type == t)
+ {
+ if (TYPE_FIELD_NAME (t, 0) == 0)
+ TYPE_VPTR_FIELDNO (type) = i = 0;
+ else for (i = TYPE_NFIELDS (t) - 1; i >= 0; --i)
+ if (! strncmp (TYPE_FIELD_NAME (t, i), *pp,
+ strlen (TYPE_FIELD_NAME (t, i))))
+ {
+ TYPE_VPTR_FIELDNO (type) = i;
+ break;
+ }
+ if (i < 0)
+ error ("virtual function table field not found");
+ }
+ else
+ TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type));
+ *pp = p;
+ }
+ else
+ {
+ TYPE_VPTR_BASETYPE (type) = 0;
+ TYPE_VPTR_FIELDNO (type) = -1;
+ }
+ }
+ else
+ {
+ TYPE_VPTR_BASETYPE (type) = 0;
+ TYPE_VPTR_FIELDNO (type) = -1;
+ }
return type;
}
@@ -1995,8 +2692,7 @@ read_enum_type (pp, type)
while (**pp && **pp != ';')
{
/* Check for and handle cretinous dbx symbol name continuation! */
- if (**pp == '\\')
- *pp = next_symbol_text ();
+ if (**pp == '\\') *pp = next_symbol_text ();
p = *pp;
while (*p != ':') p++;
@@ -2169,6 +2865,48 @@ read_number (pp, end)
return n * sign;
}
+/* Read in an argument list. This is a list of types. It is terminated with
+ a ':', FYI. Return the list of types read in. */
+static struct type **
+read_args (pp, end)
+ char **pp;
+ int end;
+{
+ struct type *types[1024], **rval; /* allow for fns of 1023 parameters */
+ int n = 0;
+
+ while (**pp != end)
+ {
+ if (**pp != ',')
+ error ("Invalid argument list: no ',', at symtab pos %d", symnum);
+ *pp += 1;
+ types[n++] = read_type (pp);
+ }
+ *pp += 1; /* get past `end' (the ':' character) */
+
+ if (n == 1)
+ {
+ rval = (struct type **) xmalloc (2 * sizeof (struct type *));
+ }
+ else
+ {
+ rval = (struct type **) xmalloc (n * sizeof (struct type *));
+ }
+ bcopy (types, rval, n * sizeof (struct type *));
+ return rval;
+}
+
+/* This function is really horrible, but to avoid it, there would need
+ to be more filling in of forward references. */
+int
+fill_in_vptr_fieldno (type)
+ struct type *type;
+{
+ if (TYPE_VPTR_FIELDNO (type) < 0)
+ TYPE_VPTR_FIELDNO (type) = fill_in_vptr_fieldno (TYPE_BASECLASS (type));
+ return TYPE_VPTR_FIELDNO (type);
+}
+
static
initialize ()
{
@@ -2176,6 +2914,9 @@ initialize ()
add_com ("symbol-file", class_files, symbol_file_command,
"Load symbol table (in dbx format) from executable file FILE.");
+
+ add_com ("add-file", class_files, add_file_command,
+ "Load the symbols from FILE, assuming its codes is at TEXT_START.") ;
}
END_FILE
generated by cgit v1.1 at 2024-12-18 05:58:55 +0000