1 /* Build symbol tables in GDB's internal format.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This module provides subroutines used for creating and adding to
21 the symbol table. These routines are called from various symbol-
22 file-reading routines.
24 They originated in dbxread.c of gdb-4.2, and were split out to
25 make xcoffread.c more maintainable by sharing code. */
31 #include "breakpoint.h"
32 #include "gdbcore.h" /* for bfd stuff for symfile.h */
33 #include "symfile.h" /* Needed for "struct complaint" */
35 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
39 /* Ask buildsym.h to define the vars it normally declares `extern'. */
41 #include "buildsym.h" /* Our own declarations */
45 patch_block_stabs PARAMS ((struct pending *, struct pending_stabs *,
49 read_huge_number PARAMS ((char **, int, long *, int *));
52 dbx_alloc_type PARAMS ((int [2], struct objfile *));
55 compare_line_numbers PARAMS ((const void *, const void *));
57 static struct blockvector *
58 make_blockvector PARAMS ((struct objfile *));
61 fix_common_block PARAMS ((struct symbol *, int));
64 cleanup_undefined_types PARAMS ((void));
67 read_range_type PARAMS ((char **, int [2], struct objfile *));
70 read_enum_type PARAMS ((char **, struct type *, struct objfile *));
73 read_struct_type PARAMS ((char **, struct type *, struct objfile *));
76 read_array_type PARAMS ((char **, struct type *, struct objfile *));
79 read_args PARAMS ((char **, int, struct objfile *));
83 static const char vptr_name[] = { '_','v','p','t','r',CPLUS_MARKER,'\0' };
84 static const char vb_name[] = { '_','v','b',CPLUS_MARKER,'\0' };
86 /* Define this as 1 if a pcc declaration of a char or short argument
87 gives the correct address. Otherwise assume pcc gives the
88 address of the corresponding int, which is not the same on a
89 big-endian machine. */
91 #ifndef BELIEVE_PCC_PROMOTION
92 #define BELIEVE_PCC_PROMOTION 0
95 /* During some calls to read_type (and thus to read_range_type), this
96 contains the name of the type being defined. Range types are only
97 used in C as basic types. We use the name to distinguish the otherwise
98 identical basic types "int" and "long" and their unsigned versions.
99 FIXME, this should disappear with better type management. */
101 static char *long_kludge_name;
103 /* Make a list of forward references which haven't been defined. */
104 static struct type **undef_types;
105 static int undef_types_allocated, undef_types_length;
107 /* Initial sizes of data structures. These are realloc'd larger if needed,
108 and realloc'd down to the size actually used, when completed. */
110 #define INITIAL_CONTEXT_STACK_SIZE 10
111 #define INITIAL_TYPE_VECTOR_LENGTH 160
112 #define INITIAL_LINE_VECTOR_LENGTH 1000
114 /* Complaints about the symbols we have encountered. */
116 struct complaint innerblock_complaint =
117 {"inner block not inside outer block in %s", 0, 0};
119 struct complaint blockvector_complaint =
120 {"block at %x out of order", 0, 0};
123 struct complaint dbx_class_complaint =
124 {"encountered DBX-style class variable debugging information.\n\
125 You seem to have compiled your program with \
126 \"g++ -g0\" instead of \"g++ -g\".\n\
127 Therefore GDB will not know about your class variables", 0, 0};
130 struct complaint invalid_cpp_abbrev_complaint =
131 {"invalid C++ abbreviation `%s'", 0, 0};
133 struct complaint invalid_cpp_type_complaint =
134 {"C++ abbreviated type name unknown at symtab pos %d", 0, 0};
136 struct complaint member_fn_complaint =
137 {"member function type missing, got '%c'", 0, 0};
139 struct complaint const_vol_complaint =
140 {"const/volatile indicator missing, got '%c'", 0, 0};
142 struct complaint error_type_complaint =
143 {"debug info mismatch between compiler and debugger", 0, 0};
145 struct complaint invalid_member_complaint =
146 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
148 struct complaint range_type_base_complaint =
149 {"base type %d of range type is not defined", 0, 0};
151 struct complaint reg_value_complaint =
152 {"register number too large in symbol %s", 0, 0};
158 register char *p = name;
159 register int total = p[0];
172 /* Ensure result is positive. */
173 if (total < 0) total += (1000 << 6);
174 return total % HASHSIZE;
178 /* Look up a dbx type-number pair. Return the address of the slot
179 where the type for that number-pair is stored.
180 The number-pair is in TYPENUMS.
182 This can be used for finding the type associated with that pair
183 or for associating a new type with the pair. */
186 dbx_lookup_type (typenums)
189 register int filenum = typenums[0], index = typenums[1];
192 if (filenum < 0 || filenum >= n_this_object_header_files)
193 error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
194 filenum, index, symnum);
198 /* Type is defined outside of header files.
199 Find it in this object file's type vector. */
200 if (index >= type_vector_length)
202 old_len = type_vector_length;
204 type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
205 type_vector = (struct type **)
206 malloc (type_vector_length * sizeof (struct type *));
208 while (index >= type_vector_length)
209 type_vector_length *= 2;
210 type_vector = (struct type **)
211 xrealloc ((char *) type_vector,
212 (type_vector_length * sizeof (struct type *)));
213 bzero (&type_vector[old_len],
214 (type_vector_length - old_len) * sizeof (struct type *));
216 return &type_vector[index];
220 register int real_filenum = this_object_header_files[filenum];
221 register struct header_file *f;
224 if (real_filenum >= n_header_files)
227 f = &header_files[real_filenum];
229 f_orig_length = f->length;
230 if (index >= f_orig_length)
232 while (index >= f->length)
234 f->vector = (struct type **)
235 xrealloc ((char *) f->vector, f->length * sizeof (struct type *));
236 bzero (&f->vector[f_orig_length],
237 (f->length - f_orig_length) * sizeof (struct type *));
239 return &f->vector[index];
243 /* Make sure there is a type allocated for type numbers TYPENUMS
244 and return the type object.
245 This can create an empty (zeroed) type object.
246 TYPENUMS may be (-1, -1) to return a new type object that is not
247 put into the type vector, and so may not be referred to by number. */
250 dbx_alloc_type (typenums, objfile)
252 struct objfile *objfile;
254 register struct type **type_addr;
255 register struct type *type;
257 if (typenums[0] != -1)
259 type_addr = dbx_lookup_type (typenums);
268 /* If we are referring to a type not known at all yet,
269 allocate an empty type for it.
270 We will fill it in later if we find out how. */
273 type = alloc_type (objfile);
281 /* maintain the lists of symbols and blocks */
283 /* Add a symbol to one of the lists of symbols. */
285 add_symbol_to_list (symbol, listhead)
286 struct symbol *symbol;
287 struct pending **listhead;
289 /* We keep PENDINGSIZE symbols in each link of the list.
290 If we don't have a link with room in it, add a new link. */
291 if (*listhead == 0 || (*listhead)->nsyms == PENDINGSIZE)
293 register struct pending *link;
296 link = free_pendings;
297 free_pendings = link->next;
300 link = (struct pending *) xmalloc (sizeof (struct pending));
302 link->next = *listhead;
307 (*listhead)->symbol[(*listhead)->nsyms++] = symbol;
310 /* Find a symbol on a pending list. */
312 find_symbol_in_list (list, name, length)
313 struct pending *list;
320 for (j = list->nsyms; --j >= 0; ) {
321 char *pp = SYMBOL_NAME (list->symbol[j]);
322 if (*pp == *name && strncmp (pp, name, length) == 0 && pp[length] == '\0')
323 return list->symbol[j];
330 /* At end of reading syms, or in case of quit,
331 really free as many `struct pending's as we can easily find. */
335 really_free_pendings (foo)
338 struct pending *next, *next1;
340 struct pending_block *bnext, *bnext1;
343 for (next = free_pendings; next; next = next1)
350 #if 0 /* Now we make the links in the symbol_obstack, so don't free them. */
351 for (bnext = pending_blocks; bnext; bnext = bnext1)
353 bnext1 = bnext->next;
359 for (next = file_symbols; next; next = next1)
366 for (next = global_symbols; next; next = next1)
374 /* Take one of the lists of symbols and make a block from it.
375 Keep the order the symbols have in the list (reversed from the input file).
376 Put the block on the list of pending blocks. */
379 finish_block (symbol, listhead, old_blocks, start, end, objfile)
380 struct symbol *symbol;
381 struct pending **listhead;
382 struct pending_block *old_blocks;
383 CORE_ADDR start, end;
384 struct objfile *objfile;
386 register struct pending *next, *next1;
387 register struct block *block;
388 register struct pending_block *pblock;
389 struct pending_block *opblock;
392 /* Count the length of the list of symbols. */
394 for (next = *listhead, i = 0;
396 i += next->nsyms, next = next->next)
399 block = (struct block *) obstack_alloc (&objfile -> symbol_obstack,
400 (sizeof (struct block) + ((i - 1) * sizeof (struct symbol *))));
402 /* Copy the symbols into the block. */
404 BLOCK_NSYMS (block) = i;
405 for (next = *listhead; next; next = next->next)
408 for (j = next->nsyms - 1; j >= 0; j--)
409 BLOCK_SYM (block, --i) = next->symbol[j];
412 BLOCK_START (block) = start;
413 BLOCK_END (block) = end;
414 BLOCK_SUPERBLOCK (block) = 0; /* Filled in when containing block is made */
415 BLOCK_GCC_COMPILED (block) = processing_gcc_compilation;
417 /* Put the block in as the value of the symbol that names it. */
421 SYMBOL_BLOCK_VALUE (symbol) = block;
422 BLOCK_FUNCTION (block) = symbol;
425 BLOCK_FUNCTION (block) = 0;
427 /* Now "free" the links of the list, and empty the list. */
429 for (next = *listhead; next; next = next1)
432 next->next = free_pendings;
433 free_pendings = next;
437 /* Install this block as the superblock
438 of all blocks made since the start of this scope
439 that don't have superblocks yet. */
442 for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
444 if (BLOCK_SUPERBLOCK (pblock->block) == 0) {
446 /* Check to be sure the blocks are nested as we receive them.
447 If the compiler/assembler/linker work, this just burns a small
449 if (BLOCK_START (pblock->block) < BLOCK_START (block)
450 || BLOCK_END (pblock->block) > BLOCK_END (block)) {
451 complain(&innerblock_complaint, symbol? SYMBOL_NAME (symbol):
453 BLOCK_START (pblock->block) = BLOCK_START (block);
454 BLOCK_END (pblock->block) = BLOCK_END (block);
457 BLOCK_SUPERBLOCK (pblock->block) = block;
462 /* Record this block on the list of all blocks in the file.
463 Put it after opblock, or at the beginning if opblock is 0.
464 This puts the block in the list after all its subblocks. */
466 /* Allocate in the symbol_obstack to save time.
467 It wastes a little space. */
468 pblock = (struct pending_block *)
469 obstack_alloc (&objfile -> symbol_obstack,
470 sizeof (struct pending_block));
471 pblock->block = block;
474 pblock->next = opblock->next;
475 opblock->next = pblock;
479 pblock->next = pending_blocks;
480 pending_blocks = pblock;
484 static struct blockvector *
485 make_blockvector (objfile)
486 struct objfile *objfile;
488 register struct pending_block *next;
489 register struct blockvector *blockvector;
492 /* Count the length of the list of blocks. */
494 for (next = pending_blocks, i = 0; next; next = next->next, i++);
496 blockvector = (struct blockvector *)
497 obstack_alloc (&objfile -> symbol_obstack,
498 (sizeof (struct blockvector)
499 + (i - 1) * sizeof (struct block *)));
501 /* Copy the blocks into the blockvector.
502 This is done in reverse order, which happens to put
503 the blocks into the proper order (ascending starting address).
504 finish_block has hair to insert each block into the list
505 after its subblocks in order to make sure this is true. */
507 BLOCKVECTOR_NBLOCKS (blockvector) = i;
508 for (next = pending_blocks; next; next = next->next) {
509 BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
512 #if 0 /* Now we make the links in the obstack, so don't free them. */
513 /* Now free the links of the list, and empty the list. */
515 for (next = pending_blocks; next; next = next1)
523 #if 1 /* FIXME, shut this off after a while to speed up symbol reading. */
524 /* Some compilers output blocks in the wrong order, but we depend
525 on their being in the right order so we can binary search.
526 Check the order and moan about it. FIXME. */
527 if (BLOCKVECTOR_NBLOCKS (blockvector) > 1)
528 for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++) {
529 if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i-1))
530 > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i))) {
531 complain (&blockvector_complaint,
532 (char *) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)));
540 /* Start recording information about source code that came from an included
541 (or otherwise merged-in) source file with a different name. */
544 start_subfile (name, dirname)
548 register struct subfile *subfile;
550 /* See if this subfile is already known as a subfile of the
551 current main source file. */
553 for (subfile = subfiles; subfile; subfile = subfile->next)
555 if (!strcmp (subfile->name, name))
557 current_subfile = subfile;
562 /* This subfile is not known. Add an entry for it.
563 Make an entry for this subfile in the list of all subfiles
564 of the current main source file. */
566 subfile = (struct subfile *) xmalloc (sizeof (struct subfile));
567 subfile->next = subfiles;
569 current_subfile = subfile;
571 /* Save its name and compilation directory name */
572 subfile->name = strdup (name);
574 subfile->dirname = NULL;
576 subfile->dirname = strdup (dirname);
578 /* Initialize line-number recording for this subfile. */
579 subfile->line_vector = 0;
582 /* Handle the N_BINCL and N_EINCL symbol types
583 that act like N_SOL for switching source files
584 (different subfiles, as we call them) within one object file,
585 but using a stack rather than in an arbitrary order. */
590 register struct subfile_stack *tem
591 = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack));
593 tem->next = subfile_stack;
595 if (current_subfile == 0 || current_subfile->name == 0)
597 tem->name = current_subfile->name;
598 tem->prev_index = header_file_prev_index;
605 register struct subfile_stack *link = subfile_stack;
611 subfile_stack = link->next;
612 header_file_prev_index = link->prev_index;
618 /* Manage the vector of line numbers for each subfile. */
621 record_line (subfile, line, pc)
622 register struct subfile *subfile;
626 struct linetable_entry *e;
627 /* Ignore the dummy line number in libg.o */
632 /* Make sure line vector exists and is big enough. */
633 if (!subfile->line_vector) {
634 subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH;
635 subfile->line_vector = (struct linetable *)
636 xmalloc (sizeof (struct linetable)
637 + subfile->line_vector_length * sizeof (struct linetable_entry));
638 subfile->line_vector->nitems = 0;
641 if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length)
643 subfile->line_vector_length *= 2;
644 subfile->line_vector = (struct linetable *)
645 xrealloc ((char *) subfile->line_vector, (sizeof (struct linetable)
646 + subfile->line_vector_length * sizeof (struct linetable_entry)));
649 e = subfile->line_vector->item + subfile->line_vector->nitems++;
650 e->line = line; e->pc = pc;
654 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
657 compare_line_numbers (ln1p, ln2p)
661 return (((struct linetable_entry *) ln1p) -> line -
662 ((struct linetable_entry *) ln2p) -> line);
666 /* Start a new symtab for a new source file.
667 This is called when a dbx symbol of type N_SO is seen;
668 it indicates the start of data for one original source file. */
671 start_symtab (name, dirname, start_addr)
674 CORE_ADDR start_addr;
677 last_source_file = name;
678 last_source_start_addr = start_addr;
681 global_stabs = 0; /* AIX COFF */
684 /* Context stack is initially empty. Allocate first one with room for
685 10 levels; reuse it forever afterward. */
686 if (context_stack == 0) {
687 context_stack_size = INITIAL_CONTEXT_STACK_SIZE;
688 context_stack = (struct context_stack *)
689 xmalloc (context_stack_size * sizeof (struct context_stack));
691 context_stack_depth = 0;
693 /* Leave FILENUM of 0 free for builtin types and this file's types. */
694 n_this_object_header_files = 1;
695 header_file_prev_index = -1;
697 type_vector_length = 0;
698 type_vector = (struct type **) 0;
700 /* Initialize the list of sub source files with one entry
701 for this file (the top-level source file). */
705 start_subfile (name, dirname);
708 /* for all the stabs in a given stab vector, build appropriate types
709 and fix their symbols in given symbol vector. */
712 patch_block_stabs (symbols, stabs, objfile)
713 struct pending *symbols;
714 struct pending_stabs *stabs;
715 struct objfile *objfile;
722 /* for all the stab entries, find their corresponding symbols and
723 patch their types! */
725 for (ii = 0; ii < stabs->count; ++ii)
727 char *name = stabs->stab[ii];
728 char *pp = (char*) strchr (name, ':');
729 struct symbol *sym = find_symbol_in_list (symbols, name, pp-name);
732 #ifndef IBM6000_TARGET
733 printf ("ERROR! stab symbol not found!\n"); /* FIXME */
739 if (*(pp-1) == 'F' || *(pp-1) == 'f')
742 lookup_function_type (read_type (&pp, objfile));
746 SYMBOL_TYPE (sym) = read_type (&pp, objfile);
753 /* Finish the symbol definitions for one main source file,
754 close off all the lexical contexts for that file
755 (creating struct block's for them), then make the struct symtab
756 for that file and put it in the list of all such.
758 END_ADDR is the address of the end of the file's text. */
761 end_symtab (end_addr, sort_pending, sort_linevec, objfile)
765 struct objfile *objfile;
767 register struct symtab *symtab;
768 register struct blockvector *blockvector;
769 register struct subfile *subfile;
770 struct subfile *nextsub;
772 /* Finish the lexical context of the last function in the file;
773 pop the context stack. */
775 if (context_stack_depth > 0)
777 register struct context_stack *cstk;
778 context_stack_depth--;
779 cstk = &context_stack[context_stack_depth];
780 /* Make a block for the local symbols within. */
781 finish_block (cstk->name, &local_symbols, cstk->old_blocks,
782 cstk->start_addr, end_addr, objfile);
784 /* Debug: if context stack still has something in it, we are in
786 if (context_stack_depth > 0)
790 /* It is unfortunate that in aixcoff, pending blocks might not be ordered
791 in this stage. Especially, blocks for static functions will show up at
792 the end. We need to sort them, so tools like `find_pc_function' and
793 `find_pc_block' can work reliably. */
794 if (sort_pending && pending_blocks) {
795 /* FIXME! Remove this horrid bubble sort and use qsort!!! */
798 struct pending_block *pb, *pbnext;
800 pb = pending_blocks, pbnext = pb->next;
805 /* swap blocks if unordered! */
807 if (BLOCK_START(pb->block) < BLOCK_START(pbnext->block)) {
808 struct block *tmp = pb->block;
809 pb->block = pbnext->block;
814 pbnext = pbnext->next;
819 /* Cleanup any undefined types that have been left hanging around
820 (this needs to be done before the finish_blocks so that
821 file_symbols is still good). */
822 cleanup_undefined_types ();
825 patch_block_stabs (global_symbols, global_stabs, objfile);
826 free ((PTR)global_stabs);
830 if (pending_blocks == 0
832 && global_symbols == 0) {
833 /* Ignore symtabs that have no functions with real debugging info */
836 /* Define the STATIC_BLOCK and GLOBAL_BLOCK, and build the blockvector. */
837 finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr, objfile);
838 finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr, objfile);
839 blockvector = make_blockvector (objfile);
842 #ifdef PROCESS_LINENUMBER_HOOK
843 PROCESS_LINENUMBER_HOOK (); /* Needed for aixcoff. */
846 /* Now create the symtab objects proper, one for each subfile. */
847 /* (The main file is the last one on the chain.) */
849 for (subfile = subfiles; subfile; subfile = nextsub)
852 /* If we have blocks of symbols, make a symtab.
853 Otherwise, just ignore this file and any line number info in it. */
856 if (subfile->line_vector) {
857 /* First, shrink the linetable to make more memory. */
858 linetablesize = sizeof (struct linetable) +
859 subfile->line_vector->nitems * sizeof (struct linetable_entry);
860 subfile->line_vector = (struct linetable *)
861 xrealloc ((char *) subfile->line_vector, linetablesize);
864 qsort (subfile->line_vector->item, subfile->line_vector->nitems,
865 sizeof (struct linetable_entry), compare_line_numbers);
868 /* Now, allocate a symbol table. */
869 symtab = allocate_symtab (subfile->name, objfile);
871 /* Fill in its components. */
872 symtab->blockvector = blockvector;
873 if (subfile->line_vector)
875 /* Reallocate the line table on the symbol obstack */
876 symtab->linetable = (struct linetable *)
877 obstack_alloc (&objfile -> symbol_obstack, linetablesize);
878 memcpy (symtab->linetable, subfile->line_vector, linetablesize);
882 symtab->linetable = NULL;
884 symtab->dirname = subfile->dirname;
885 symtab->free_code = free_linetable;
886 symtab->free_ptr = 0;
888 #ifdef IBM6000_TARGET
889 /* In case we need to duplicate symbol tables (to represent include
890 files), and in case our system needs relocation, we want to
891 relocate the main symbol table node only (for the main file,
892 not for the include files). */
894 symtab->nonreloc = TRUE;
897 if (subfile->line_vector)
898 free ((PTR)subfile->line_vector);
900 nextsub = subfile->next;
904 #ifdef IBM6000_TARGET
905 /* all include symbol tables are non-relocatable, except the main source
908 symtab->nonreloc = FALSE;
912 free ((char *) type_vector);
914 type_vector_length = 0;
916 last_source_file = 0;
918 previous_stab_code = 0;
924 /* Push a context block. Args are an identifying nesting level (checkable
925 when you pop it), and the starting PC address of this context. */
927 struct context_stack *
928 push_context (desc, valu)
932 register struct context_stack *new;
934 if (context_stack_depth == context_stack_size)
936 context_stack_size *= 2;
937 context_stack = (struct context_stack *)
938 xrealloc ((char *) context_stack,
939 (context_stack_size * sizeof (struct context_stack)));
942 new = &context_stack[context_stack_depth++];
944 new->locals = local_symbols;
945 new->old_blocks = pending_blocks;
946 new->start_addr = valu;
954 /* Initialize anything that needs initializing when starting to read
955 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
967 /* Initialize anything that needs initializing when a completely new
968 symbol file is specified (not just adding some symbols from another
969 file, e.g. a shared library). */
974 /* Empty the hash table of global syms looking for values. */
975 bzero (global_sym_chain, sizeof global_sym_chain);
980 /* Scan through all of the global symbols defined in the object file,
981 assigning values to the debugging symbols that need to be assigned
982 to. Get these symbols from the minimal symbol table. */
985 scan_file_globals (objfile)
986 struct objfile *objfile;
989 struct minimal_symbol *msymbol;
990 struct symbol *sym, *prev;
992 for (msymbol = objfile -> msymbols; msymbol -> name != NULL; msymbol++)
996 prev = (struct symbol *) 0;
998 /* Get the hash index and check all the symbols
999 under that hash index. */
1001 hash = hashname (msymbol -> name);
1003 for (sym = global_sym_chain[hash]; sym;)
1005 if (*(msymbol -> name) == SYMBOL_NAME (sym)[0]
1006 && !strcmp(msymbol -> name + 1, SYMBOL_NAME (sym) + 1))
1008 /* Splice this symbol out of the hash chain and
1009 assign the value we have to it. */
1011 SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
1013 global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
1015 /* Check to see whether we need to fix up a common block. */
1016 /* Note: this code might be executed several times for
1017 the same symbol if there are multiple references. */
1018 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
1019 fix_common_block (sym, msymbol -> address);
1021 SYMBOL_VALUE_ADDRESS (sym) = msymbol -> address;
1024 sym = SYMBOL_VALUE_CHAIN (prev);
1026 sym = global_sym_chain[hash];
1031 sym = SYMBOL_VALUE_CHAIN (sym);
1038 /* Read a number by which a type is referred to in dbx data,
1039 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
1040 Just a single number N is equivalent to (0,N).
1041 Return the two numbers by storing them in the vector TYPENUMS.
1042 TYPENUMS will then be used as an argument to dbx_lookup_type. */
1045 read_type_number (pp, typenums)
1047 register int *typenums;
1052 typenums[0] = read_number (pp, ',');
1053 typenums[1] = read_number (pp, ')');
1058 typenums[1] = read_number (pp, 0);
1062 /* To handle GNU C++ typename abbreviation, we need to be able to
1063 fill in a type's name as soon as space for that type is allocated.
1064 `type_synonym_name' is the name of the type being allocated.
1065 It is cleared as soon as it is used (lest all allocated types
1067 static char *type_synonym_name;
1071 define_symbol (valu, string, desc, type, objfile)
1076 struct objfile *objfile;
1078 register struct symbol *sym;
1079 char *p = (char *) strchr (string, ':');
1083 struct type *temptype;
1085 #ifdef IBM6000_TARGET
1086 /* We would like to eliminate nameless symbols, but keep their types.
1087 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
1088 to type 2, but, should not creat a symbol to address that type. Since
1089 the symbol will be nameless, there is no way any user can refer to it. */
1094 /* Ignore syms with empty names. */
1098 /* Ignore old-style symbols from cc -go */
1102 #ifdef IBM6000_TARGET
1103 /* If a nameless stab entry, all we need is the type, not the symbol.
1105 nameless = (p == string);
1108 sym = (struct symbol *)obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
1110 if (processing_gcc_compilation) {
1111 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
1112 number of bytes occupied by a type or object, which we ignore. */
1113 SYMBOL_LINE(sym) = desc;
1115 SYMBOL_LINE(sym) = 0; /* unknown */
1118 if (string[0] == CPLUS_MARKER)
1120 /* Special GNU C++ names. */
1124 SYMBOL_NAME (sym) = obsavestring ("this", strlen ("this"),
1125 &objfile -> symbol_obstack);
1127 case 'v': /* $vtbl_ptr_type */
1128 /* Was: SYMBOL_NAME (sym) = "vptr"; */
1131 SYMBOL_NAME (sym) = obsavestring ("eh_throw", strlen ("eh_throw"),
1132 &objfile -> symbol_obstack);
1136 /* This was an anonymous type that was never fixed up. */
1147 = (char *) obstack_alloc (&objfile -> symbol_obstack, ((p - string) + 1));
1148 /* Open-coded bcopy--saves function call time. */
1150 register char *p1 = string;
1151 register char *p2 = SYMBOL_NAME (sym);
1158 /* Determine the type of name being defined. */
1159 /* The Acorn RISC machine's compiler can put out locals that don't
1160 start with "234=" or "(3,4)=", so assume anything other than the
1161 deftypes we know how to handle is a local. */
1162 /* (Peter Watkins @ Computervision)
1163 Handle Sun-style local fortran array types 'ar...' .
1164 (gnu@cygnus.com) -- this strchr() handles them properly?
1165 (tiemann@cygnus.com) -- 'C' is for catch. */
1167 #ifdef IBM6000_TARGET
1169 /* 'R' is for register parameters. */
1171 if (!strchr ("cfFGpPrStTvVXCR", *p))
1174 if (!strchr ("cfFGpPrStTvVXC", *p))
1180 /* c is a special case, not followed by a type-number.
1181 SYMBOL:c=iVALUE for an integer constant symbol.
1182 SYMBOL:c=rVALUE for a floating constant symbol.
1183 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1184 e.g. "b:c=e6,0" for "const b = blob1"
1185 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1189 error ("Invalid symbol data at symtab pos %d.", symnum);
1194 double d = atof (p);
1197 SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile,
1200 obstack_alloc (&objfile -> type_obstack,
1202 memcpy (dbl_valu, &d, sizeof (double));
1203 SWAP_TARGET_AND_HOST (dbl_valu, sizeof (double));
1204 SYMBOL_VALUE_BYTES (sym) = dbl_valu;
1205 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
1210 SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile,
1212 SYMBOL_VALUE (sym) = atoi (p);
1213 SYMBOL_CLASS (sym) = LOC_CONST;
1217 /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1218 e.g. "b:c=e6,0" for "const b = blob1"
1219 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1223 read_type_number (&p, typenums);
1225 error ("Invalid symbol data: no comma in enum const symbol");
1227 SYMBOL_TYPE (sym) = *dbx_lookup_type (typenums);
1228 SYMBOL_VALUE (sym) = atoi (p);
1229 SYMBOL_CLASS (sym) = LOC_CONST;
1233 error ("Invalid symbol data at symtab pos %d.", symnum);
1235 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1236 add_symbol_to_list (sym, &file_symbols);
1240 /* Now usually comes a number that says which data type,
1241 and possibly more stuff to define the type
1242 (all of which is handled by read_type) */
1244 if (deftype == 'p' && *p == 'F')
1245 /* pF is a two-letter code that means a function parameter in Fortran.
1246 The type-number specifies the type of the return value.
1247 Translate it into a pointer-to-function type. */
1251 = lookup_pointer_type (lookup_function_type (read_type (&p, objfile)));
1254 #ifdef IBM6000_TARGET
1255 else if (deftype == 'R')
1256 SYMBOL_TYPE (sym) = read_type (&p, objfile);
1261 struct type *type_read;
1262 synonym = *p == 't';
1267 type_synonym_name = obsavestring (SYMBOL_NAME (sym),
1268 strlen (SYMBOL_NAME (sym)),
1269 &objfile -> symbol_obstack);
1272 /* Here we save the name of the symbol for read_range_type, which
1273 ends up reading in the basic types. In stabs, unfortunately there
1274 is no distinction between "int" and "long" types except their
1275 names. Until we work out a saner type policy (eliminating most
1276 builtin types and using the names specified in the files), we
1277 save away the name so that far away from here in read_range_type,
1278 we can examine it to decide between "int" and "long". FIXME. */
1279 long_kludge_name = SYMBOL_NAME (sym);
1280 type_read = read_type (&p, objfile);
1282 if ((deftype == 'F' || deftype == 'f')
1283 && TYPE_CODE (type_read) != TYPE_CODE_FUNC)
1286 /* This code doesn't work -- it needs to realloc and can't. */
1287 struct type *new = (struct type *)
1288 obstack_alloc (&objfile -> type_obstack,
1289 sizeof (struct type));
1291 /* Generate a template for the type of this function. The
1292 types of the arguments will be added as we read the symbol
1294 *new = *lookup_function_type (type_read);
1295 SYMBOL_TYPE(sym) = new;
1296 TYPE_OBJFILE (new) = objfile;
1297 in_function_type = new;
1299 SYMBOL_TYPE (sym) = lookup_function_type (type_read);
1303 SYMBOL_TYPE (sym) = type_read;
1309 /* The name of a caught exception. */
1310 SYMBOL_CLASS (sym) = LOC_LABEL;
1311 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1312 SYMBOL_VALUE_ADDRESS (sym) = valu;
1313 add_symbol_to_list (sym, &local_symbols);
1317 SYMBOL_CLASS (sym) = LOC_BLOCK;
1318 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1319 add_symbol_to_list (sym, &file_symbols);
1323 SYMBOL_CLASS (sym) = LOC_BLOCK;
1324 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1325 add_symbol_to_list (sym, &global_symbols);
1329 /* For a class G (global) symbol, it appears that the
1330 value is not correct. It is necessary to search for the
1331 corresponding linker definition to find the value.
1332 These definitions appear at the end of the namelist. */
1333 i = hashname (SYMBOL_NAME (sym));
1334 SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
1335 global_sym_chain[i] = sym;
1336 SYMBOL_CLASS (sym) = LOC_STATIC;
1337 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1338 add_symbol_to_list (sym, &global_symbols);
1341 /* This case is faked by a conditional above,
1342 when there is no code letter in the dbx data.
1343 Dbx data never actually contains 'l'. */
1345 SYMBOL_CLASS (sym) = LOC_LOCAL;
1346 SYMBOL_VALUE (sym) = valu;
1347 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1348 add_symbol_to_list (sym, &local_symbols);
1352 /* Normally this is a parameter, a LOC_ARG. On the i960, it
1353 can also be a LOC_LOCAL_ARG depending on symbol type. */
1354 #ifndef DBX_PARM_SYMBOL_CLASS
1355 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
1357 SYMBOL_CLASS (sym) = DBX_PARM_SYMBOL_CLASS (type);
1358 SYMBOL_VALUE (sym) = valu;
1359 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1361 /* This doesn't work yet. */
1362 add_param_to_type (&in_function_type, sym);
1364 add_symbol_to_list (sym, &local_symbols);
1366 /* If it's gcc-compiled, if it says `short', believe it. */
1367 if (processing_gcc_compilation || BELIEVE_PCC_PROMOTION)
1370 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
1371 /* This macro is defined on machines (e.g. sparc) where
1372 we should believe the type of a PCC 'short' argument,
1373 but shouldn't believe the address (the address is
1374 the address of the corresponding int). Note that
1375 this is only different from the BELIEVE_PCC_PROMOTION
1376 case on big-endian machines.
1378 My guess is that this correction, as opposed to changing
1379 the parameter to an 'int' (as done below, for PCC
1380 on most machines), is the right thing to do
1381 on all machines, but I don't want to risk breaking
1382 something that already works. On most PCC machines,
1383 the sparc problem doesn't come up because the calling
1384 function has to zero the top bytes (not knowing whether
1385 the called function wants an int or a short), so there
1386 is no practical difference between an int and a short
1387 (except perhaps what happens when the GDB user types
1388 "print short_arg = 0x10000;").
1390 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
1391 actually produces the correct address (we don't need to fix it
1392 up). I made this code adapt so that it will offset the symbol
1393 if it was pointing at an int-aligned location and not
1394 otherwise. This way you can use the same gdb for 4.0.x and
1397 If the parameter is shorter than an int, and is integral
1398 (e.g. char, short, or unsigned equivalent), and is claimed to
1399 be passed on an integer boundary, don't believe it! Offset the
1400 parameter's address to the tail-end of that integer. */
1402 temptype = lookup_fundamental_type (objfile, FT_INTEGER);
1403 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
1404 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
1405 && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
1407 SYMBOL_VALUE (sym) += TYPE_LENGTH (temptype)
1408 - TYPE_LENGTH (SYMBOL_TYPE (sym));
1412 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
1414 /* If PCC says a parameter is a short or a char,
1415 it is really an int. */
1416 temptype = lookup_fundamental_type (objfile, FT_INTEGER);
1417 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
1418 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
1420 SYMBOL_TYPE (sym) = TYPE_UNSIGNED (SYMBOL_TYPE (sym))
1421 ? lookup_fundamental_type (objfile, FT_UNSIGNED_INTEGER)
1426 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
1429 /* Parameter which is in a register. */
1430 SYMBOL_CLASS (sym) = LOC_REGPARM;
1431 SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
1432 if (SYMBOL_VALUE (sym) >= NUM_REGS)
1434 complain (®_value_complaint, SYMBOL_NAME (sym));
1435 SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
1437 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1438 add_symbol_to_list (sym, &local_symbols);
1441 #ifdef IBM6000_TARGET
1445 /* Register variable (either global or local). */
1446 SYMBOL_CLASS (sym) = LOC_REGISTER;
1447 SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
1448 if (SYMBOL_VALUE (sym) >= NUM_REGS)
1450 complain (®_value_complaint, SYMBOL_NAME (sym));
1451 SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
1453 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1454 if (within_function)
1455 add_symbol_to_list (sym, &local_symbols);
1457 add_symbol_to_list (sym, &file_symbols);
1461 /* Static symbol at top level of file */
1462 SYMBOL_CLASS (sym) = LOC_STATIC;
1463 SYMBOL_VALUE_ADDRESS (sym) = valu;
1464 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1465 add_symbol_to_list (sym, &file_symbols);
1469 #ifdef IBM6000_TARGET
1470 /* For a nameless type, we don't want a create a symbol, thus we
1471 did not use `sym'. Return without further processing. */
1473 if (nameless) return NULL;
1475 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1476 SYMBOL_VALUE (sym) = valu;
1477 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1478 if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
1479 TYPE_NAME (SYMBOL_TYPE (sym)) =
1480 obsavestring (SYMBOL_NAME (sym),
1481 strlen (SYMBOL_NAME (sym)),
1482 &objfile -> symbol_obstack);
1483 /* C++ vagaries: we may have a type which is derived from
1484 a base type which did not have its name defined when the
1485 derived class was output. We fill in the derived class's
1486 base part member's name here in that case. */
1487 else if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
1488 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
1489 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
1492 for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
1493 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
1494 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
1495 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
1498 add_symbol_to_list (sym, &file_symbols);
1502 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
1503 SYMBOL_VALUE (sym) = valu;
1504 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
1505 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1506 TYPE_NAME (SYMBOL_TYPE (sym))
1507 = obconcat (&objfile -> type_obstack, "",
1508 (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM
1510 : (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
1511 ? "struct " : "union ")),
1513 add_symbol_to_list (sym, &file_symbols);
1517 register struct symbol *typedef_sym = (struct symbol *)
1518 obstack_alloc (&objfile -> type_obstack,
1519 sizeof (struct symbol));
1520 SYMBOL_NAME (typedef_sym) = SYMBOL_NAME (sym);
1521 SYMBOL_TYPE (typedef_sym) = SYMBOL_TYPE (sym);
1523 SYMBOL_CLASS (typedef_sym) = LOC_TYPEDEF;
1524 SYMBOL_VALUE (typedef_sym) = valu;
1525 SYMBOL_NAMESPACE (typedef_sym) = VAR_NAMESPACE;
1526 add_symbol_to_list (typedef_sym, &file_symbols);
1531 /* Static symbol of local scope */
1532 SYMBOL_CLASS (sym) = LOC_STATIC;
1533 SYMBOL_VALUE_ADDRESS (sym) = valu;
1534 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1535 add_symbol_to_list (sym, &local_symbols);
1539 /* Reference parameter */
1540 SYMBOL_CLASS (sym) = LOC_REF_ARG;
1541 SYMBOL_VALUE (sym) = valu;
1542 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1543 add_symbol_to_list (sym, &local_symbols);
1547 /* This is used by Sun FORTRAN for "function result value".
1548 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1549 that Pascal uses it too, but when I tried it Pascal used
1550 "x:3" (local symbol) instead. */
1551 SYMBOL_CLASS (sym) = LOC_LOCAL;
1552 SYMBOL_VALUE (sym) = valu;
1553 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1554 add_symbol_to_list (sym, &local_symbols);
1558 error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype, symnum);
1563 /* What about types defined as forward references inside of a small lexical
1565 /* Add a type to the list of undefined types to be checked through
1566 once this file has been read in. */
1568 add_undefined_type (type)
1571 if (undef_types_length == undef_types_allocated)
1573 undef_types_allocated *= 2;
1574 undef_types = (struct type **)
1575 xrealloc ((char *) undef_types,
1576 undef_types_allocated * sizeof (struct type *));
1578 undef_types[undef_types_length++] = type;
1581 /* Go through each undefined type, see if it's still undefined, and fix it
1582 up if possible. We have two kinds of undefined types:
1584 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
1585 Fix: update array length using the element bounds
1586 and the target type's length.
1587 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
1588 yet defined at the time a pointer to it was made.
1589 Fix: Do a full lookup on the struct/union tag. */
1591 cleanup_undefined_types ()
1595 for (type = undef_types; type < undef_types + undef_types_length; type++) {
1596 switch (TYPE_CODE (*type)) {
1598 case TYPE_CODE_STRUCT:
1599 case TYPE_CODE_UNION:
1600 case TYPE_CODE_ENUM:
1602 /* Reasonable test to see if it's been defined since. */
1603 if (TYPE_NFIELDS (*type) == 0)
1605 struct pending *ppt;
1607 /* Name of the type, without "struct" or "union" */
1608 char *typename = TYPE_NAME (*type);
1610 if (!strncmp (typename, "struct ", 7))
1612 if (!strncmp (typename, "union ", 6))
1614 if (!strncmp (typename, "enum ", 5))
1617 for (ppt = file_symbols; ppt; ppt = ppt->next)
1618 for (i = 0; i < ppt->nsyms; i++)
1620 struct symbol *sym = ppt->symbol[i];
1622 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
1623 && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
1624 && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
1626 && !strcmp (SYMBOL_NAME (sym), typename))
1627 memcpy (*type, SYMBOL_TYPE (sym), sizeof (struct type));
1631 /* It has been defined; don't mark it as a stub. */
1632 TYPE_FLAGS (*type) &= ~TYPE_FLAG_STUB;
1636 case TYPE_CODE_ARRAY:
1638 struct type *range_type;
1641 if (TYPE_LENGTH (*type) != 0) /* Better be unknown */
1643 if (TYPE_NFIELDS (*type) != 1)
1645 range_type = TYPE_FIELD_TYPE (*type, 0);
1646 if (TYPE_CODE (range_type) != TYPE_CODE_RANGE)
1649 /* Now recompute the length of the array type, based on its
1650 number of elements and the target type's length. */
1651 lower = TYPE_FIELD_BITPOS (range_type, 0);
1652 upper = TYPE_FIELD_BITPOS (range_type, 1);
1653 TYPE_LENGTH (*type) = (upper - lower + 1)
1654 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type));
1660 error ("GDB internal error. cleanup_undefined_types with bad\
1661 type %d.", TYPE_CODE (*type));
1665 undef_types_length = 0;
1668 /* Skip rest of this symbol and return an error type.
1670 General notes on error recovery: error_type always skips to the
1671 end of the symbol (modulo cretinous dbx symbol name continuation).
1672 Thus code like this:
1674 if (*(*pp)++ != ';')
1675 return error_type (pp);
1677 is wrong because if *pp starts out pointing at '\0' (typically as the
1678 result of an earlier error), it will be incremented to point to the
1679 start of the next symbol, which might produce strange results, at least
1680 if you run off the end of the string table. Instead use
1683 return error_type (pp);
1689 foo = error_type (pp);
1693 And in case it isn't obvious, the point of all this hair is so the compiler
1694 can define new types and new syntaxes, and old versions of the
1695 debugger will be able to read the new symbol tables. */
1701 complain (&error_type_complaint, 0);
1704 /* Skip to end of symbol. */
1705 while (**pp != '\0')
1708 /* Check for and handle cretinous dbx symbol name continuation! */
1709 if ((*pp)[-1] == '\\')
1710 *pp = next_symbol_text ();
1714 return builtin_type_error;
1717 /* Read a dbx type reference or definition;
1718 return the type that is meant.
1719 This can be just a number, in which case it references
1720 a type already defined and placed in type_vector.
1721 Or the number can be followed by an =, in which case
1722 it means to define a new type according to the text that
1726 read_type (pp, objfile)
1728 struct objfile *objfile;
1730 register struct type *type = 0;
1735 /* Read type number if present. The type number may be omitted.
1736 for instance in a two-dimensional array declared with type
1737 "ar1;1;10;ar1;1;10;4". */
1738 if ((**pp >= '0' && **pp <= '9')
1741 read_type_number (pp, typenums);
1743 /* Type is not being defined here. Either it already exists,
1744 or this is a forward reference to it. dbx_alloc_type handles
1747 return dbx_alloc_type (typenums, objfile);
1749 /* Type is being defined here. */
1750 #if 0 /* Callers aren't prepared for a NULL result! FIXME -- metin! */
1754 /* if such a type already exists, this is an unnecessary duplication
1755 of the stab string, which is common in (RS/6000) xlc generated
1756 objects. In that case, simply return NULL and let the caller take
1759 tt = *dbx_lookup_type (typenums);
1760 if (tt && tt->length && tt->code)
1769 /* 'typenums=' not present, type is anonymous. Read and return
1770 the definition, but don't put it in the type vector. */
1771 typenums[0] = typenums[1] = -1;
1779 enum type_code code;
1781 /* Used to index through file_symbols. */
1782 struct pending *ppt;
1785 /* Name including "struct", etc. */
1788 /* Name without "struct", etc. */
1789 char *type_name_only;
1795 /* Set the type code according to the following letter. */
1799 code = TYPE_CODE_STRUCT;
1803 code = TYPE_CODE_UNION;
1807 code = TYPE_CODE_ENUM;
1811 return error_type (pp);
1814 to = type_name = (char *)
1815 obstack_alloc (&objfile -> type_obstack,
1817 ((char *) strchr (*pp, ':') - (*pp)) + 1));
1819 /* Copy the prefix. */
1821 while (*to++ = *from++)
1825 type_name_only = to;
1827 /* Copy the name. */
1829 while ((*to++ = *from++) != ':')
1833 /* Set the pointer ahead of the name which we just read. */
1837 /* The following hack is clearly wrong, because it doesn't
1838 check whether we are in a baseclass. I tried to reproduce
1839 the case that it is trying to fix, but I couldn't get
1840 g++ to put out a cross reference to a basetype. Perhaps
1841 it doesn't do it anymore. */
1842 /* Note: for C++, the cross reference may be to a base type which
1843 has not yet been seen. In this case, we skip to the comma,
1844 which will mark the end of the base class name. (The ':'
1845 at the end of the base class name will be skipped as well.)
1846 But sometimes (ie. when the cross ref is the last thing on
1847 the line) there will be no ','. */
1848 from = (char *) strchr (*pp, ',');
1854 /* Now check to see whether the type has already been declared. */
1855 /* This is necessary at least in the case where the
1856 program says something like
1858 The compiler puts out a cross-reference; we better find
1859 set the length of the structure correctly so we can
1860 set the length of the array. */
1861 for (ppt = file_symbols; ppt; ppt = ppt->next)
1862 for (i = 0; i < ppt->nsyms; i++)
1864 struct symbol *sym = ppt->symbol[i];
1866 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
1867 && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
1868 && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
1869 && !strcmp (SYMBOL_NAME (sym), type_name_only))
1871 obstack_free (&objfile -> type_obstack, type_name);
1872 type = SYMBOL_TYPE (sym);
1877 /* Didn't find the type to which this refers, so we must
1878 be dealing with a forward reference. Allocate a type
1879 structure for it, and keep track of it so we can
1880 fill in the rest of the fields when we get the full
1882 type = dbx_alloc_type (typenums, objfile);
1883 TYPE_CODE (type) = code;
1884 TYPE_NAME (type) = type_name;
1885 INIT_CPLUS_SPECIFIC(type);
1886 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
1888 add_undefined_type (type);
1892 case '-': /* RS/6000 built-in type */
1894 type = builtin_type (pp); /* (in xcoffread.c) */
1909 read_type_number (pp, xtypenums);
1910 type = *dbx_lookup_type (xtypenums);
1915 type = lookup_fundamental_type (objfile, FT_VOID);
1916 if (typenums[0] != -1)
1917 *dbx_lookup_type (typenums) = type;
1921 type1 = read_type (pp, objfile);
1922 /* FIXME -- we should be doing smash_to_XXX types here. */
1923 #ifdef IBM6000_TARGET
1924 /* postponed type decoration should be allowed. */
1925 if (typenums[1] > 0 && typenums[1] < type_vector_length &&
1926 (type = type_vector[typenums[1]])) {
1927 smash_to_pointer_type (type, type1);
1931 type = lookup_pointer_type (type1);
1932 if (typenums[0] != -1)
1933 *dbx_lookup_type (typenums) = type;
1938 struct type *domain = read_type (pp, objfile);
1939 struct type *memtype;
1942 /* Invalid member type data format. */
1943 return error_type (pp);
1946 memtype = read_type (pp, objfile);
1947 type = dbx_alloc_type (typenums, objfile);
1948 smash_to_member_type (type, domain, memtype);
1953 if ((*pp)[0] == '#')
1955 /* We'll get the parameter types from the name. */
1956 struct type *return_type;
1959 return_type = read_type (pp, objfile);
1960 if (*(*pp)++ != ';')
1961 complain (&invalid_member_complaint, (char *) symnum);
1962 type = allocate_stub_method (return_type);
1963 if (typenums[0] != -1)
1964 *dbx_lookup_type (typenums) = type;
1968 struct type *domain = read_type (pp, objfile);
1969 struct type *return_type;
1972 if (*(*pp)++ != ',')
1973 error ("invalid member type data format, at symtab pos %d.",
1976 return_type = read_type (pp, objfile);
1977 args = read_args (pp, ';', objfile);
1978 type = dbx_alloc_type (typenums, objfile);
1979 smash_to_method_type (type, domain, return_type, args);
1984 type1 = read_type (pp, objfile);
1985 type = lookup_reference_type (type1);
1986 if (typenums[0] != -1)
1987 *dbx_lookup_type (typenums) = type;
1991 type1 = read_type (pp, objfile);
1992 type = lookup_function_type (type1);
1993 if (typenums[0] != -1)
1994 *dbx_lookup_type (typenums) = type;
1998 type = read_range_type (pp, typenums, objfile);
1999 if (typenums[0] != -1)
2000 *dbx_lookup_type (typenums) = type;
2004 type = dbx_alloc_type (typenums, objfile);
2005 type = read_enum_type (pp, type, objfile);
2006 *dbx_lookup_type (typenums) = type;
2010 type = dbx_alloc_type (typenums, objfile);
2011 if (!TYPE_NAME (type))
2012 TYPE_NAME (type) = type_synonym_name;
2013 type_synonym_name = 0;
2014 type = read_struct_type (pp, type, objfile);
2018 type = dbx_alloc_type (typenums, objfile);
2019 if (!TYPE_NAME (type))
2020 TYPE_NAME (type) = type_synonym_name;
2021 type_synonym_name = 0;
2022 type = read_struct_type (pp, type, objfile);
2023 TYPE_CODE (type) = TYPE_CODE_UNION;
2028 return error_type (pp);
2031 type = dbx_alloc_type (typenums, objfile);
2032 type = read_array_type (pp, type, objfile);
2036 --*pp; /* Go back to the symbol in error */
2037 /* Particularly important if it was \0! */
2038 return error_type (pp);
2045 /* If this is an overriding temporary alteration for a header file's
2046 contents, and this type number is unknown in the global definition,
2047 put this type into the global definition at this type number. */
2048 if (header_file_prev_index >= 0)
2050 register struct type **tp
2051 = explicit_lookup_type (header_file_prev_index, typenums[1]);
2059 /* This page contains subroutines of read_type. */
2061 /* Read the description of a structure (or union type)
2062 and return an object describing the type. */
2064 static struct type *
2065 read_struct_type (pp, type, objfile)
2067 register struct type *type;
2068 struct objfile *objfile;
2070 /* Total number of methods defined in this class.
2071 If the class defines two `f' methods, and one `g' method,
2072 then this will have the value 3. */
2073 int total_length = 0;
2077 struct nextfield *next;
2078 int visibility; /* 0=public, 1=protected, 2=public */
2084 struct next_fnfield *next;
2085 struct fn_field fn_field;
2088 struct next_fnfieldlist
2090 struct next_fnfieldlist *next;
2091 struct fn_fieldlist fn_fieldlist;
2094 register struct nextfield *list = 0;
2095 struct nextfield *new;
2098 int non_public_fields = 0;
2101 register struct next_fnfieldlist *mainlist = 0;
2104 TYPE_CODE (type) = TYPE_CODE_STRUCT;
2105 INIT_CPLUS_SPECIFIC(type);
2107 /* First comes the total size in bytes. */
2109 TYPE_LENGTH (type) = read_number (pp, 0);
2111 /* C++: Now, if the class is a derived class, then the next character
2112 will be a '!', followed by the number of base classes derived from.
2113 Each element in the list contains visibility information,
2114 the offset of this base class in the derived structure,
2115 and then the base type. */
2118 int i, n_baseclasses, offset;
2119 struct type *baseclass;
2122 /* Nonzero if it is a virtual baseclass, i.e.,
2126 struct C : public B, public virtual A {};
2128 B is a baseclass of C; A is a virtual baseclass for C. This is a C++
2129 2.0 language feature. */
2134 ALLOCATE_CPLUS_STRUCT_TYPE(type);
2136 n_baseclasses = read_number (pp, ',');
2137 TYPE_FIELD_VIRTUAL_BITS (type) =
2138 (B_TYPE *) obstack_alloc (&objfile -> type_obstack,
2139 B_BYTES (n_baseclasses));
2140 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), n_baseclasses);
2142 for (i = 0; i < n_baseclasses; i++)
2145 *pp = next_symbol_text ();
2156 /* Bad visibility format. */
2157 return error_type (pp);
2165 non_public_fields++;
2171 /* Bad visibility format. */
2172 return error_type (pp);
2175 SET_TYPE_FIELD_VIRTUAL (type, i);
2178 /* Offset of the portion of the object corresponding to
2179 this baseclass. Always zero in the absence of
2180 multiple inheritance. */
2181 offset = read_number (pp, ',');
2182 baseclass = read_type (pp, objfile);
2183 *pp += 1; /* skip trailing ';' */
2185 /* Make this baseclass visible for structure-printing purposes. */
2186 new = (struct nextfield *) alloca (sizeof (struct nextfield));
2189 list->visibility = via_public;
2190 list->field.type = baseclass;
2191 list->field.name = type_name_no_tag (baseclass);
2192 list->field.bitpos = offset;
2193 list->field.bitsize = 0; /* this should be an unpacked field! */
2196 TYPE_N_BASECLASSES (type) = n_baseclasses;
2199 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
2200 At the end, we see a semicolon instead of a field.
2202 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2205 The `?' is a placeholder for one of '/2' (public visibility),
2206 '/1' (protected visibility), '/0' (private visibility), or nothing
2207 (C style symbol table, public visibility). */
2209 /* We better set p right now, in case there are no fields at all... */
2214 /* Check for and handle cretinous dbx symbol name continuation! */
2215 if (**pp == '\\') *pp = next_symbol_text ();
2217 /* Get space to record the next field's data. */
2218 new = (struct nextfield *) alloca (sizeof (struct nextfield));
2222 /* Get the field name. */
2224 if (*p == CPLUS_MARKER)
2226 /* Special GNU C++ name. */
2231 struct type *context;
2242 complain (&invalid_cpp_abbrev_complaint, *pp);
2243 prefix = "INVALID_C++_ABBREV";
2247 context = read_type (pp, objfile);
2248 name = type_name_no_tag (context);
2251 complain (&invalid_cpp_type_complaint, (char *) symnum);
2254 list->field.name = obconcat (&objfile -> type_obstack,
2258 complain (&invalid_cpp_abbrev_complaint, *pp);
2259 list->field.type = read_type (pp, objfile);
2260 (*pp)++; /* Skip the comma. */
2261 list->field.bitpos = read_number (pp, ';');
2262 /* This field is unpacked. */
2263 list->field.bitsize = 0;
2264 list->visibility = 0; /* private */
2265 non_public_fields++;
2267 /* GNU C++ anonymous type. */
2271 complain (&invalid_cpp_abbrev_complaint, *pp);
2277 while (*p != ':') p++;
2278 list->field.name = obsavestring (*pp, p - *pp,
2279 &objfile -> type_obstack);
2281 /* C++: Check to see if we have hit the methods yet. */
2287 /* This means we have a visibility for a field coming. */
2293 list->visibility = 0; /* private */
2294 non_public_fields++;
2299 list->visibility = 1; /* protected */
2300 non_public_fields++;
2305 list->visibility = 2; /* public */
2310 else /* normal dbx-style format. */
2311 list->visibility = 2; /* public */
2313 list->field.type = read_type (pp, objfile);
2316 /* Static class member. */
2317 list->field.bitpos = (long)-1;
2319 while (*p != ';') p++;
2320 list->field.bitsize = (long) savestring (*pp, p - *pp);
2325 else if (**pp != ',')
2326 /* Bad structure-type format. */
2327 return error_type (pp);
2329 (*pp)++; /* Skip the comma. */
2330 list->field.bitpos = read_number (pp, ',');
2331 list->field.bitsize = read_number (pp, ';');
2334 /* FIXME-tiemann: Can't the compiler put out something which
2335 lets us distinguish these? (or maybe just not put out anything
2336 for the field). What is the story here? What does the compiler
2337 really do? Also, patch gdb.texinfo for this case; I document
2338 it as a possible problem there. Search for "DBX-style". */
2340 /* This is wrong because this is identical to the symbols
2341 produced for GCC 0-size arrays. For example:
2346 The code which dumped core in such circumstances should be
2347 fixed not to dump core. */
2349 /* g++ -g0 can put out bitpos & bitsize zero for a static
2350 field. This does not give us any way of getting its
2351 class, so we can't know its name. But we can just
2352 ignore the field so we don't dump core and other nasty
2354 if (list->field.bitpos == 0
2355 && list->field.bitsize == 0)
2357 complain (&dbx_class_complaint, 0);
2358 /* Ignore this field. */
2364 /* Detect an unpacked field and mark it as such.
2365 dbx gives a bit size for all fields.
2366 Note that forward refs cannot be packed,
2367 and treat enums as if they had the width of ints. */
2368 if (TYPE_CODE (list->field.type) != TYPE_CODE_INT
2369 && TYPE_CODE (list->field.type) != TYPE_CODE_ENUM)
2370 list->field.bitsize = 0;
2371 if ((list->field.bitsize == 8 * TYPE_LENGTH (list->field.type)
2372 || (TYPE_CODE (list->field.type) == TYPE_CODE_ENUM
2373 && (list->field.bitsize
2374 == 8 * TYPE_LENGTH (lookup_fundamental_type (objfile, FT_INTEGER)))
2378 list->field.bitpos % 8 == 0)
2379 list->field.bitsize = 0;
2385 /* chill the list of fields: the last entry (at the head)
2386 is a partially constructed entry which we now scrub. */
2389 /* Now create the vector of fields, and record how big it is.
2390 We need this info to record proper virtual function table information
2391 for this class's virtual functions. */
2393 TYPE_NFIELDS (type) = nfields;
2394 TYPE_FIELDS (type) = (struct field *)
2395 obstack_alloc (&objfile -> type_obstack, sizeof (struct field) * nfields);
2397 if (non_public_fields)
2399 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2401 TYPE_FIELD_PRIVATE_BITS (type) =
2402 (B_TYPE *) obstack_alloc (&objfile -> type_obstack,
2404 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
2406 TYPE_FIELD_PROTECTED_BITS (type) =
2407 (B_TYPE *) obstack_alloc (&objfile -> type_obstack,
2409 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
2412 /* Copy the saved-up fields into the field vector. */
2414 for (n = nfields; list; list = list->next)
2417 TYPE_FIELD (type, n) = list->field;
2418 if (list->visibility == 0)
2419 SET_TYPE_FIELD_PRIVATE (type, n);
2420 else if (list->visibility == 1)
2421 SET_TYPE_FIELD_PROTECTED (type, n);
2424 /* Now come the method fields, as NAME::methods
2425 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
2426 At the end, we see a semicolon instead of a field.
2428 For the case of overloaded operators, the format is
2429 op$::*.methods, where $ is the CPLUS_MARKER (usually '$'),
2430 `*' holds the place for an operator name (such as `+=')
2431 and `.' marks the end of the operator name. */
2434 /* Now, read in the methods. To simplify matters, we
2435 "unread" the name that has been read, so that we can
2436 start from the top. */
2438 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2439 /* For each list of method lists... */
2443 struct next_fnfield *sublist = 0;
2444 struct type *look_ahead_type = NULL;
2446 struct next_fnfieldlist *new_mainlist =
2447 (struct next_fnfieldlist *)alloca (sizeof (struct next_fnfieldlist));
2452 /* read in the name. */
2453 while (*p != ':') p++;
2454 if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && (*pp)[2] == CPLUS_MARKER)
2456 /* This is a completely wierd case. In order to stuff in the
2457 names that might contain colons (the usual name delimiter),
2458 Mike Tiemann defined a different name format which is
2459 signalled if the identifier is "op$". In that case, the
2460 format is "op$::XXXX." where XXXX is the name. This is
2461 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2462 /* This lets the user type "break operator+".
2463 We could just put in "+" as the name, but that wouldn't
2465 static char opname[32] = {'o', 'p', CPLUS_MARKER};
2466 char *o = opname + 3;
2468 /* Skip past '::'. */
2470 if (**pp == '\\') *pp = next_symbol_text ();
2474 main_fn_name = savestring (opname, o - opname);
2480 main_fn_name = savestring (*pp, p - *pp);
2481 /* Skip past '::'. */
2484 new_mainlist->fn_fieldlist.name = main_fn_name;
2488 struct next_fnfield *new_sublist =
2489 (struct next_fnfield *)alloca (sizeof (struct next_fnfield));
2491 /* Check for and handle cretinous dbx symbol name continuation! */
2492 if (look_ahead_type == NULL) /* Normal case. */
2494 if (**pp == '\\') *pp = next_symbol_text ();
2496 new_sublist->fn_field.type = read_type (pp, objfile);
2498 /* Invalid symtab info for method. */
2499 return error_type (pp);
2502 { /* g++ version 1 kludge */
2503 new_sublist->fn_field.type = look_ahead_type;
2504 look_ahead_type = NULL;
2509 while (*p != ';') p++;
2511 /* If this is just a stub, then we don't have the
2513 if (TYPE_FLAGS (new_sublist->fn_field.type) & TYPE_FLAG_STUB)
2514 new_sublist->fn_field.is_stub = 1;
2515 new_sublist->fn_field.physname = savestring (*pp, p - *pp);
2518 /* Set this method's visibility fields. */
2519 switch (*(*pp)++ - '0')
2522 new_sublist->fn_field.is_private = 1;
2525 new_sublist->fn_field.is_protected = 1;
2529 if (**pp == '\\') *pp = next_symbol_text ();
2532 case 'A': /* Normal functions. */
2533 new_sublist->fn_field.is_const = 0;
2534 new_sublist->fn_field.is_volatile = 0;
2537 case 'B': /* `const' member functions. */
2538 new_sublist->fn_field.is_const = 1;
2539 new_sublist->fn_field.is_volatile = 0;
2542 case 'C': /* `volatile' member function. */
2543 new_sublist->fn_field.is_const = 0;
2544 new_sublist->fn_field.is_volatile = 1;
2547 case 'D': /* `const volatile' member function. */
2548 new_sublist->fn_field.is_const = 1;
2549 new_sublist->fn_field.is_volatile = 1;
2552 case '*': /* File compiled with g++ version 1 -- no info */
2557 complain (&const_vol_complaint, (char *) (long) **pp);
2564 /* virtual member function, followed by index. */
2565 /* The sign bit is set to distinguish pointers-to-methods
2566 from virtual function indicies. Since the array is
2567 in words, the quantity must be shifted left by 1
2568 on 16 bit machine, and by 2 on 32 bit machine, forcing
2569 the sign bit out, and usable as a valid index into
2570 the array. Remove the sign bit here. */
2571 new_sublist->fn_field.voffset =
2572 (0x7fffffff & read_number (pp, ';')) + 2;
2574 if (**pp == '\\') *pp = next_symbol_text ();
2576 if (**pp == ';' || **pp == '\0')
2577 /* Must be g++ version 1. */
2578 new_sublist->fn_field.fcontext = 0;
2581 /* Figure out from whence this virtual function came.
2582 It may belong to virtual function table of
2583 one of its baseclasses. */
2584 look_ahead_type = read_type (pp, objfile);
2586 { /* g++ version 1 overloaded methods. */ }
2589 new_sublist->fn_field.fcontext = look_ahead_type;
2591 return error_type (pp);
2594 look_ahead_type = NULL;
2600 /* static member function. */
2601 new_sublist->fn_field.voffset = VOFFSET_STATIC;
2602 if (strncmp (new_sublist->fn_field.physname,
2603 main_fn_name, strlen (main_fn_name)))
2604 new_sublist->fn_field.is_stub = 1;
2609 complain (&member_fn_complaint, (char *) (long) (*pp)[-1]);
2610 /* Fall through into normal member function. */
2613 /* normal member function. */
2614 new_sublist->fn_field.voffset = 0;
2615 new_sublist->fn_field.fcontext = 0;
2619 new_sublist->next = sublist;
2620 sublist = new_sublist;
2622 if (**pp == '\\') *pp = next_symbol_text ();
2624 while (**pp != ';' && **pp != '\0');
2628 new_mainlist->fn_fieldlist.fn_fields =
2629 (struct fn_field *) obstack_alloc (&objfile -> type_obstack,
2630 sizeof (struct fn_field) * length);
2631 for (i = length; (i--, sublist); sublist = sublist->next)
2632 new_mainlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
2634 new_mainlist->fn_fieldlist.length = length;
2635 new_mainlist->next = mainlist;
2636 mainlist = new_mainlist;
2638 total_length += length;
2639 if (**pp == '\\') *pp = next_symbol_text ();
2641 while (**pp != ';');
2649 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2650 obstack_alloc (&objfile -> type_obstack,
2651 sizeof (struct fn_fieldlist) * nfn_fields);
2652 TYPE_NFN_FIELDS (type) = nfn_fields;
2653 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
2658 for (i = 0; i < TYPE_N_BASECLASSES (type); ++i)
2659 TYPE_NFN_FIELDS_TOTAL (type) +=
2660 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type, i));
2663 for (n = nfn_fields; mainlist; mainlist = mainlist->next) {
2664 --n; /* Circumvent Sun3 compiler bug */
2665 TYPE_FN_FIELDLISTS (type)[n] = mainlist->fn_fieldlist;
2672 if (**pp == '=' || **pp == '+' || **pp == '-')
2674 /* Obsolete flags that used to indicate the presence
2675 of constructors and/or destructors. */
2679 /* Read either a '%' or the final ';'. */
2680 if (*(*pp)++ == '%')
2682 /* We'd like to be able to derive the vtable pointer field
2683 from the type information, but when it's inherited, that's
2684 hard. A reason it's hard is because we may read in the
2685 info about a derived class before we read in info about
2686 the base class that provides the vtable pointer field.
2687 Once the base info has been read, we could fill in the info
2688 for the derived classes, but for the fact that by then,
2689 we don't remember who needs what. */
2692 int predicted_fieldno = -1;
2695 /* Now we must record the virtual function table pointer's
2696 field information. */
2704 /* In version 2, we derive the vfield ourselves. */
2705 for (n = 0; n < nfields; n++)
2707 if (! strncmp (TYPE_FIELD_NAME (type, n), vptr_name,
2708 sizeof (vptr_name) -1))
2710 predicted_fieldno = n;
2714 if (predicted_fieldno < 0)
2715 for (n = 0; n < TYPE_N_BASECLASSES (type); n++)
2716 if (! TYPE_FIELD_VIRTUAL (type, n)
2717 && TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, n)) >= 0)
2719 predicted_fieldno = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, n));
2725 t = read_type (pp, objfile);
2727 while (*p != '\0' && *p != ';')
2730 /* Premature end of symbol. */
2731 return error_type (pp);
2733 TYPE_VPTR_BASETYPE (type) = t;
2736 if (TYPE_FIELD_NAME (t, TYPE_N_BASECLASSES (t)) == 0)
2738 /* FIXME-tiemann: what's this? */
2740 TYPE_VPTR_FIELDNO (type) = i = TYPE_N_BASECLASSES (t);
2745 else for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); --i)
2746 if (! strncmp (TYPE_FIELD_NAME (t, i), vptr_name,
2747 sizeof (vptr_name) -1))
2749 TYPE_VPTR_FIELDNO (type) = i;
2753 /* Virtual function table field not found. */
2754 return error_type (pp);
2757 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
2760 if (TYPE_VPTR_FIELDNO (type) != predicted_fieldno)
2761 error ("TYPE_VPTR_FIELDNO miscalculated");
2771 /* Read a definition of an array type,
2772 and create and return a suitable type object.
2773 Also creates a range type which represents the bounds of that
2775 static struct type *
2776 read_array_type (pp, type, objfile)
2778 register struct type *type;
2779 struct objfile *objfile;
2781 struct type *index_type, *element_type, *range_type;
2785 /* Format of an array type:
2786 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2789 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2790 for these, produce a type like float[][]. */
2792 index_type = read_type (pp, objfile);
2794 /* Improper format of array type decl. */
2795 return error_type (pp);
2798 if (!(**pp >= '0' && **pp <= '9'))
2803 lower = read_number (pp, ';');
2805 if (!(**pp >= '0' && **pp <= '9'))
2810 upper = read_number (pp, ';');
2812 element_type = read_type (pp, objfile);
2821 /* Create range type. */
2822 range_type = (struct type *)
2823 obstack_alloc (&objfile -> type_obstack, sizeof (struct type));
2824 bzero (range_type, sizeof (struct type));
2825 TYPE_OBJFILE (range_type) = objfile;
2826 TYPE_CODE (range_type) = TYPE_CODE_RANGE;
2827 TYPE_TARGET_TYPE (range_type) = index_type;
2829 /* This should never be needed. */
2830 TYPE_LENGTH (range_type) = sizeof (int);
2832 TYPE_NFIELDS (range_type) = 2;
2833 TYPE_FIELDS (range_type) =
2834 (struct field *) obstack_alloc (&objfile -> type_obstack,
2835 2 * sizeof (struct field));
2836 TYPE_FIELD_BITPOS (range_type, 0) = lower;
2837 TYPE_FIELD_BITPOS (range_type, 1) = upper;
2840 TYPE_CODE (type) = TYPE_CODE_ARRAY;
2841 TYPE_TARGET_TYPE (type) = element_type;
2842 TYPE_LENGTH (type) = (upper - lower + 1) * TYPE_LENGTH (element_type);
2843 TYPE_NFIELDS (type) = 1;
2844 TYPE_FIELDS (type) =
2845 (struct field *) obstack_alloc (&objfile -> type_obstack,
2846 sizeof (struct field));
2847 TYPE_FIELD_TYPE (type, 0) = range_type;
2849 /* If we have an array whose element type is not yet known, but whose
2850 bounds *are* known, record it to be adjusted at the end of the file. */
2851 if (TYPE_LENGTH (element_type) == 0 && !adjustable)
2852 add_undefined_type (type);
2858 /* Read a definition of an enumeration type,
2859 and create and return a suitable type object.
2860 Also defines the symbols that represent the values of the type. */
2862 static struct type *
2863 read_enum_type (pp, type, objfile)
2865 register struct type *type;
2866 struct objfile *objfile;
2871 register struct symbol *sym;
2873 struct pending **symlist;
2874 struct pending *osyms, *syms;
2877 if (within_function)
2878 symlist = &local_symbols;
2880 symlist = &file_symbols;
2882 o_nsyms = osyms ? osyms->nsyms : 0;
2884 /* Read the value-names and their values.
2885 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2886 A semicolon or comma instead of a NAME means the end. */
2887 while (**pp && **pp != ';' && **pp != ',')
2889 /* Check for and handle cretinous dbx symbol name continuation! */
2890 if (**pp == '\\') *pp = next_symbol_text ();
2893 while (*p != ':') p++;
2894 name = obsavestring (*pp, p - *pp, &objfile -> symbol_obstack);
2896 n = read_number (pp, ',');
2898 sym = (struct symbol *) obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
2899 bzero (sym, sizeof (struct symbol));
2900 SYMBOL_NAME (sym) = name;
2901 SYMBOL_CLASS (sym) = LOC_CONST;
2902 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2903 SYMBOL_VALUE (sym) = n;
2904 add_symbol_to_list (sym, symlist);
2909 (*pp)++; /* Skip the semicolon. */
2911 /* Now fill in the fields of the type-structure. */
2913 TYPE_LENGTH (type) = sizeof (int);
2914 TYPE_CODE (type) = TYPE_CODE_ENUM;
2915 TYPE_NFIELDS (type) = nsyms;
2916 TYPE_FIELDS (type) = (struct field *)
2917 obstack_alloc (&objfile -> type_obstack,
2918 sizeof (struct field) * nsyms);
2920 /* Find the symbols for the values and put them into the type.
2921 The symbols can be found in the symlist that we put them on
2922 to cause them to be defined. osyms contains the old value
2923 of that symlist; everything up to there was defined by us. */
2924 /* Note that we preserve the order of the enum constants, so
2925 that in something like "enum {FOO, LAST_THING=FOO}" we print
2926 FOO, not LAST_THING. */
2928 for (syms = *symlist, n = 0; syms; syms = syms->next)
2933 for (; j < syms->nsyms; j++,n++)
2935 struct symbol *xsym = syms->symbol[j];
2936 SYMBOL_TYPE (xsym) = type;
2937 TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
2938 TYPE_FIELD_VALUE (type, n) = 0;
2939 TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
2940 TYPE_FIELD_BITSIZE (type, n) = 0;
2947 /* This screws up perfectly good C programs with enums. FIXME. */
2948 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2949 if(TYPE_NFIELDS(type) == 2 &&
2950 ((!strcmp(TYPE_FIELD_NAME(type,0),"TRUE") &&
2951 !strcmp(TYPE_FIELD_NAME(type,1),"FALSE")) ||
2952 (!strcmp(TYPE_FIELD_NAME(type,1),"TRUE") &&
2953 !strcmp(TYPE_FIELD_NAME(type,0),"FALSE"))))
2954 TYPE_CODE(type) = TYPE_CODE_BOOL;
2960 /* Read a number from the string pointed to by *PP.
2961 The value of *PP is advanced over the number.
2962 If END is nonzero, the character that ends the
2963 number must match END, or an error happens;
2964 and that character is skipped if it does match.
2965 If END is zero, *PP is left pointing to that character.
2967 If the number fits in a long, set *VALUE and set *BITS to 0.
2968 If not, set *BITS to be the number of bits in the number.
2970 If encounter garbage, set *BITS to -1. */
2973 read_huge_number (pp, end, valu, bits)
2994 /* Leading zero means octal. GCC uses this to output values larger
2995 than an int (because that would be hard in decimal). */
3002 upper_limit = LONG_MAX / radix;
3003 while ((c = *p++) >= '0' && c <= ('0' + radix))
3005 if (n <= upper_limit)
3008 n += c - '0'; /* FIXME this overflows anyway */
3013 /* This depends on large values being output in octal, which is
3020 /* Ignore leading zeroes. */
3024 else if (c == '2' || c == '3')
3050 /* Large decimal constants are an error (because it is hard to
3051 count how many bits are in them). */
3057 /* -0x7f is the same as 0x80. So deal with it by adding one to
3058 the number of bits. */
3073 static struct type *
3074 read_range_type (pp, typenums, objfile)
3077 struct objfile *objfile;
3083 struct type *result_type;
3085 /* First comes a type we are a subrange of.
3086 In C it is usually 0, 1 or the type being defined. */
3087 read_type_number (pp, rangenums);
3088 self_subrange = (rangenums[0] == typenums[0] &&
3089 rangenums[1] == typenums[1]);
3091 /* A semicolon should now follow; skip it. */
3095 /* The remaining two operands are usually lower and upper bounds
3096 of the range. But in some special cases they mean something else. */
3097 read_huge_number (pp, ';', &n2, &n2bits);
3098 read_huge_number (pp, ';', &n3, &n3bits);
3100 if (n2bits == -1 || n3bits == -1)
3101 return error_type (pp);
3103 /* If limits are huge, must be large integral type. */
3104 if (n2bits != 0 || n3bits != 0)
3106 char got_signed = 0;
3107 char got_unsigned = 0;
3108 /* Number of bits in the type. */
3111 /* Range from 0 to <large number> is an unsigned large integral type. */
3112 if ((n2bits == 0 && n2 == 0) && n3bits != 0)
3117 /* Range from <large number> to <large number>-1 is a large signed
3119 else if (n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
3125 /* Check for "long long". */
3126 if (got_signed && nbits == TARGET_LONG_LONG_BIT)
3127 return (lookup_fundamental_type (objfile, FT_LONG_LONG));
3128 if (got_unsigned && nbits == TARGET_LONG_LONG_BIT)
3129 return (lookup_fundamental_type (objfile, FT_UNSIGNED_LONG_LONG));
3131 if (got_signed || got_unsigned)
3133 result_type = (struct type *)
3134 obstack_alloc (&objfile -> type_obstack,
3135 sizeof (struct type));
3136 bzero (result_type, sizeof (struct type));
3137 TYPE_OBJFILE (result_type) = objfile;
3138 TYPE_LENGTH (result_type) = nbits / TARGET_CHAR_BIT;
3139 TYPE_CODE (result_type) = TYPE_CODE_INT;
3141 TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
3145 return error_type (pp);
3148 /* A type defined as a subrange of itself, with bounds both 0, is void. */
3149 if (self_subrange && n2 == 0 && n3 == 0)
3150 return (lookup_fundamental_type (objfile, FT_VOID));
3152 /* If n3 is zero and n2 is not, we want a floating type,
3153 and n2 is the width in bytes.
3155 Fortran programs appear to use this for complex types also,
3156 and they give no way to distinguish between double and single-complex!
3157 We don't have complex types, so we would lose on all fortran files!
3158 So return type `double' for all of those. It won't work right
3159 for the complex values, but at least it makes the file loadable.
3161 FIXME, we may be able to distinguish these by their names. FIXME. */
3163 if (n3 == 0 && n2 > 0)
3165 if (n2 == sizeof (float))
3166 return (lookup_fundamental_type (objfile, FT_FLOAT));
3167 return (lookup_fundamental_type (objfile, FT_DBL_PREC_FLOAT));
3170 /* If the upper bound is -1, it must really be an unsigned int. */
3172 else if (n2 == 0 && n3 == -1)
3174 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
3175 long' is to look at its name! */
3177 long_kludge_name && ((long_kludge_name[0] == 'u' /* unsigned */ &&
3178 long_kludge_name[9] == 'l' /* long */)
3179 || (long_kludge_name[0] == 'l' /* long unsigned */)))
3180 return (lookup_fundamental_type (objfile, FT_UNSIGNED_LONG));
3182 return (lookup_fundamental_type (objfile, FT_UNSIGNED_INTEGER));
3185 /* Special case: char is defined (Who knows why) as a subrange of
3186 itself with range 0-127. */
3187 else if (self_subrange && n2 == 0 && n3 == 127)
3188 return (lookup_fundamental_type (objfile, FT_CHAR));
3190 /* Assumptions made here: Subrange of self is equivalent to subrange
3191 of int. FIXME: Host and target type-sizes assumed the same. */
3192 /* FIXME: This is the *only* place in GDB that depends on comparing
3193 some type to a builtin type with ==. Fix it! */
3195 && (self_subrange ||
3196 *dbx_lookup_type (rangenums) == lookup_fundamental_type (objfile, FT_INTEGER)))
3198 /* an unsigned type */
3200 if (n3 == - sizeof (long long))
3201 return (lookup_fundamental_type (objfile, FT_UNSIGNED_LONG_LONG));
3203 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
3204 long' is to look at its name! */
3205 if (n3 == (unsigned long)~0L &&
3206 long_kludge_name && ((long_kludge_name[0] == 'u' /* unsigned */ &&
3207 long_kludge_name[9] == 'l' /* long */)
3208 || (long_kludge_name[0] == 'l' /* long unsigned */)))
3209 return (lookup_fundamental_type (objfile, FT_UNSIGNED_LONG));
3210 if (n3 == (unsigned int)~0L)
3211 return (lookup_fundamental_type (objfile, FT_UNSIGNED_INTEGER));
3212 if (n3 == (unsigned short)~0L)
3213 return (lookup_fundamental_type (objfile, FT_UNSIGNED_SHORT));
3214 if (n3 == (unsigned char)~0L)
3215 return (lookup_fundamental_type (objfile, FT_UNSIGNED_CHAR));
3218 else if (n3 == 0 && n2 == -sizeof (long long))
3219 return (lookup_fundamental_type (objfile, FT_LONG_LONG));
3221 else if (n2 == -n3 -1)
3224 /* FIXME -- the only way to distinguish `int' from `long' is to look
3226 if ((n3 ==(long)(((unsigned long)1 << (8 * sizeof (long) - 1)) - 1)) &&
3227 long_kludge_name && long_kludge_name[0] == 'l' /* long */)
3228 return (lookup_fundamental_type (objfile, FT_LONG));
3229 if (n3 == (long)(((unsigned long)1 << (8 * sizeof (int) - 1)) - 1))
3230 return (lookup_fundamental_type (objfile, FT_INTEGER));
3231 if (n3 == ( 1 << (8 * sizeof (short) - 1)) - 1)
3232 return (lookup_fundamental_type (objfile, FT_SHORT));
3233 if (n3 == ( 1 << (8 * sizeof (char) - 1)) - 1)
3234 return (lookup_fundamental_type (objfile, FT_CHAR));
3237 /* We have a real range type on our hands. Allocate space and
3238 return a real pointer. */
3240 /* At this point I don't have the faintest idea how to deal with
3241 a self_subrange type; I'm going to assume that this is used
3242 as an idiom, and that all of them are special cases. So . . . */
3244 return error_type (pp);
3246 result_type = (struct type *)
3247 obstack_alloc (&objfile -> type_obstack, sizeof (struct type));
3248 bzero (result_type, sizeof (struct type));
3249 TYPE_OBJFILE (result_type) = objfile;
3251 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
3253 TYPE_TARGET_TYPE (result_type) = *dbx_lookup_type(rangenums);
3254 if (TYPE_TARGET_TYPE (result_type) == 0) {
3255 complain (&range_type_base_complaint, (char *) rangenums[1]);
3256 TYPE_TARGET_TYPE (result_type) = lookup_fundamental_type (objfile, FT_INTEGER);
3259 TYPE_NFIELDS (result_type) = 2;
3260 TYPE_FIELDS (result_type) =
3261 (struct field *) obstack_alloc (&objfile -> type_obstack,
3262 2 * sizeof (struct field));
3263 bzero (TYPE_FIELDS (result_type), 2 * sizeof (struct field));
3264 TYPE_FIELD_BITPOS (result_type, 0) = n2;
3265 TYPE_FIELD_BITPOS (result_type, 1) = n3;
3267 TYPE_LENGTH (result_type) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type));
3272 /* Read a number from the string pointed to by *PP.
3273 The value of *PP is advanced over the number.
3274 If END is nonzero, the character that ends the
3275 number must match END, or an error happens;
3276 and that character is skipped if it does match.
3277 If END is zero, *PP is left pointing to that character. */
3280 read_number (pp, end)
3284 register char *p = *pp;
3285 register long n = 0;
3289 /* Handle an optional leading minus sign. */
3297 /* Read the digits, as far as they go. */
3299 while ((c = *p++) >= '0' && c <= '9')
3307 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c, symnum);
3316 /* Read in an argument list. This is a list of types, separated by commas
3317 and terminated with END. Return the list of types read in, or (struct type
3318 **)-1 if there is an error. */
3319 static struct type **
3320 read_args (pp, end, objfile)
3323 struct objfile *objfile;
3325 /* FIXME! Remove this arbitrary limit! */
3326 struct type *types[1024], **rval; /* allow for fns of 1023 parameters */
3332 /* Invalid argument list: no ','. */
3333 return (struct type **)-1;
3336 /* Check for and handle cretinous dbx symbol name continuation! */
3338 *pp = next_symbol_text ();
3340 types[n++] = read_type (pp, objfile);
3342 *pp += 1; /* get past `end' (the ':' character) */
3346 rval = (struct type **) xmalloc (2 * sizeof (struct type *));
3348 else if (TYPE_CODE (types[n-1]) != TYPE_CODE_VOID)
3350 rval = (struct type **) xmalloc ((n + 1) * sizeof (struct type *));
3351 bzero (rval + n, sizeof (struct type *));
3355 rval = (struct type **) xmalloc (n * sizeof (struct type *));
3357 memcpy (rval, types, n * sizeof (struct type *));
3361 /* Add a common block's start address to the offset of each symbol
3362 declared to be in it (by being between a BCOMM/ECOMM pair that uses
3363 the common block name). */
3366 fix_common_block (sym, valu)
3370 struct pending *next = (struct pending *) SYMBOL_NAMESPACE (sym);
3371 for ( ; next; next = next->next)
3374 for (j = next->nsyms - 1; j >= 0; j--)
3375 SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
3379 /* Initializer for this module */
3381 _initialize_buildsym ()
3383 undef_types_allocated = 20;
3384 undef_types_length = 0;
3385 undef_types = (struct type **) xmalloc (undef_types_allocated *
3386 sizeof (struct type *));