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. */
32 #include "breakpoint.h"
33 #include "gdbcore.h" /* for bfd stuff for symfile.h */
34 #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};
155 register char *p
= name
;
156 register int total
= p
[0];
169 /* Ensure result is positive. */
170 if (total
< 0) total
+= (1000 << 6);
171 return total
% HASHSIZE
;
175 /* Look up a dbx type-number pair. Return the address of the slot
176 where the type for that number-pair is stored.
177 The number-pair is in TYPENUMS.
179 This can be used for finding the type associated with that pair
180 or for associating a new type with the pair. */
183 dbx_lookup_type (typenums
)
186 register int filenum
= typenums
[0], index
= typenums
[1];
189 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
190 error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
191 filenum
, index
, symnum
);
195 /* Type is defined outside of header files.
196 Find it in this object file's type vector. */
197 if (index
>= type_vector_length
)
199 old_len
= type_vector_length
;
201 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
202 type_vector
= (struct type
**)
203 malloc (type_vector_length
* sizeof (struct type
*));
205 while (index
>= type_vector_length
)
206 type_vector_length
*= 2;
207 type_vector
= (struct type
**)
208 xrealloc ((char *) type_vector
,
209 (type_vector_length
* sizeof (struct type
*)));
210 bzero (&type_vector
[old_len
],
211 (type_vector_length
- old_len
) * sizeof (struct type
*));
213 return &type_vector
[index
];
217 register int real_filenum
= this_object_header_files
[filenum
];
218 register struct header_file
*f
;
221 if (real_filenum
>= n_header_files
)
224 f
= &header_files
[real_filenum
];
226 f_orig_length
= f
->length
;
227 if (index
>= f_orig_length
)
229 while (index
>= f
->length
)
231 f
->vector
= (struct type
**)
232 xrealloc ((char *) f
->vector
, f
->length
* sizeof (struct type
*));
233 bzero (&f
->vector
[f_orig_length
],
234 (f
->length
- f_orig_length
) * sizeof (struct type
*));
236 return &f
->vector
[index
];
240 /* Make sure there is a type allocated for type numbers TYPENUMS
241 and return the type object.
242 This can create an empty (zeroed) type object.
243 TYPENUMS may be (-1, -1) to return a new type object that is not
244 put into the type vector, and so may not be referred to by number. */
247 dbx_alloc_type (typenums
, objfile
)
249 struct objfile
*objfile
;
251 register struct type
**type_addr
;
252 register struct type
*type
;
254 if (typenums
[0] != -1)
256 type_addr
= dbx_lookup_type (typenums
);
265 /* If we are referring to a type not known at all yet,
266 allocate an empty type for it.
267 We will fill it in later if we find out how. */
270 type
= alloc_type (objfile
);
278 /* maintain the lists of symbols and blocks */
280 /* Add a symbol to one of the lists of symbols. */
282 add_symbol_to_list (symbol
, listhead
)
283 struct symbol
*symbol
;
284 struct pending
**listhead
;
286 /* We keep PENDINGSIZE symbols in each link of the list.
287 If we don't have a link with room in it, add a new link. */
288 if (*listhead
== 0 || (*listhead
)->nsyms
== PENDINGSIZE
)
290 register struct pending
*link
;
293 link
= free_pendings
;
294 free_pendings
= link
->next
;
297 link
= (struct pending
*) xmalloc (sizeof (struct pending
));
299 link
->next
= *listhead
;
304 (*listhead
)->symbol
[(*listhead
)->nsyms
++] = symbol
;
307 /* Find a symbol on a pending list. */
309 find_symbol_in_list (list
, name
, length
)
310 struct pending
*list
;
317 for (j
= list
->nsyms
; --j
>= 0; ) {
318 char *pp
= SYMBOL_NAME (list
->symbol
[j
]);
319 if (*pp
== *name
&& strncmp (pp
, name
, length
) == 0 && pp
[length
] == '\0')
320 return list
->symbol
[j
];
327 /* At end of reading syms, or in case of quit,
328 really free as many `struct pending's as we can easily find. */
332 really_free_pendings (foo
)
335 struct pending
*next
, *next1
;
337 struct pending_block
*bnext
, *bnext1
;
340 for (next
= free_pendings
; next
; next
= next1
)
347 #if 0 /* Now we make the links in the symbol_obstack, so don't free them. */
348 for (bnext
= pending_blocks
; bnext
; bnext
= bnext1
)
350 bnext1
= bnext
->next
;
356 for (next
= file_symbols
; next
; next
= next1
)
363 for (next
= global_symbols
; next
; next
= next1
)
371 /* Take one of the lists of symbols and make a block from it.
372 Keep the order the symbols have in the list (reversed from the input file).
373 Put the block on the list of pending blocks. */
376 finish_block (symbol
, listhead
, old_blocks
, start
, end
, objfile
)
377 struct symbol
*symbol
;
378 struct pending
**listhead
;
379 struct pending_block
*old_blocks
;
380 CORE_ADDR start
, end
;
381 struct objfile
*objfile
;
383 register struct pending
*next
, *next1
;
384 register struct block
*block
;
385 register struct pending_block
*pblock
;
386 struct pending_block
*opblock
;
389 /* Count the length of the list of symbols. */
391 for (next
= *listhead
, i
= 0;
393 i
+= next
->nsyms
, next
= next
->next
)
396 block
= (struct block
*) obstack_alloc (&objfile
-> symbol_obstack
,
397 (sizeof (struct block
) + ((i
- 1) * sizeof (struct symbol
*))));
399 /* Copy the symbols into the block. */
401 BLOCK_NSYMS (block
) = i
;
402 for (next
= *listhead
; next
; next
= next
->next
)
405 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
406 BLOCK_SYM (block
, --i
) = next
->symbol
[j
];
409 BLOCK_START (block
) = start
;
410 BLOCK_END (block
) = end
;
411 BLOCK_SUPERBLOCK (block
) = 0; /* Filled in when containing block is made */
412 BLOCK_GCC_COMPILED (block
) = processing_gcc_compilation
;
414 /* Put the block in as the value of the symbol that names it. */
418 SYMBOL_BLOCK_VALUE (symbol
) = block
;
419 BLOCK_FUNCTION (block
) = symbol
;
422 BLOCK_FUNCTION (block
) = 0;
424 /* Now "free" the links of the list, and empty the list. */
426 for (next
= *listhead
; next
; next
= next1
)
429 next
->next
= free_pendings
;
430 free_pendings
= next
;
434 /* Install this block as the superblock
435 of all blocks made since the start of this scope
436 that don't have superblocks yet. */
439 for (pblock
= pending_blocks
; pblock
!= old_blocks
; pblock
= pblock
->next
)
441 if (BLOCK_SUPERBLOCK (pblock
->block
) == 0) {
443 /* Check to be sure the blocks are nested as we receive them.
444 If the compiler/assembler/linker work, this just burns a small
446 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
)
447 || BLOCK_END (pblock
->block
) > BLOCK_END (block
)) {
448 complain(&innerblock_complaint
, symbol
? SYMBOL_NAME (symbol
):
450 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
451 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
454 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
459 /* Record this block on the list of all blocks in the file.
460 Put it after opblock, or at the beginning if opblock is 0.
461 This puts the block in the list after all its subblocks. */
463 /* Allocate in the symbol_obstack to save time.
464 It wastes a little space. */
465 pblock
= (struct pending_block
*)
466 obstack_alloc (&objfile
-> symbol_obstack
,
467 sizeof (struct pending_block
));
468 pblock
->block
= block
;
471 pblock
->next
= opblock
->next
;
472 opblock
->next
= pblock
;
476 pblock
->next
= pending_blocks
;
477 pending_blocks
= pblock
;
481 static struct blockvector
*
482 make_blockvector (objfile
)
483 struct objfile
*objfile
;
485 register struct pending_block
*next
;
486 register struct blockvector
*blockvector
;
489 /* Count the length of the list of blocks. */
491 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++);
493 blockvector
= (struct blockvector
*)
494 obstack_alloc (&objfile
-> symbol_obstack
,
495 (sizeof (struct blockvector
)
496 + (i
- 1) * sizeof (struct block
*)));
498 /* Copy the blocks into the blockvector.
499 This is done in reverse order, which happens to put
500 the blocks into the proper order (ascending starting address).
501 finish_block has hair to insert each block into the list
502 after its subblocks in order to make sure this is true. */
504 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
505 for (next
= pending_blocks
; next
; next
= next
->next
) {
506 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
509 #if 0 /* Now we make the links in the obstack, so don't free them. */
510 /* Now free the links of the list, and empty the list. */
512 for (next
= pending_blocks
; next
; next
= next1
)
520 #if 1 /* FIXME, shut this off after a while to speed up symbol reading. */
521 /* Some compilers output blocks in the wrong order, but we depend
522 on their being in the right order so we can binary search.
523 Check the order and moan about it. FIXME. */
524 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
525 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++) {
526 if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
-1))
527 > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
))) {
528 complain (&blockvector_complaint
,
529 (char *) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
)));
537 /* Start recording information about source code that came from an included
538 (or otherwise merged-in) source file with a different name. */
541 start_subfile (name
, dirname
)
545 register struct subfile
*subfile
;
547 /* See if this subfile is already known as a subfile of the
548 current main source file. */
550 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
552 if (!strcmp (subfile
->name
, name
))
554 current_subfile
= subfile
;
559 /* This subfile is not known. Add an entry for it.
560 Make an entry for this subfile in the list of all subfiles
561 of the current main source file. */
563 subfile
= (struct subfile
*) xmalloc (sizeof (struct subfile
));
564 subfile
->next
= subfiles
;
566 current_subfile
= subfile
;
568 /* Save its name and compilation directory name */
569 subfile
->name
= strdup (name
);
571 subfile
->dirname
= NULL
;
573 subfile
->dirname
= strdup (dirname
);
575 /* Initialize line-number recording for this subfile. */
576 subfile
->line_vector
= 0;
579 /* Handle the N_BINCL and N_EINCL symbol types
580 that act like N_SOL for switching source files
581 (different subfiles, as we call them) within one object file,
582 but using a stack rather than in an arbitrary order. */
587 register struct subfile_stack
*tem
588 = (struct subfile_stack
*) xmalloc (sizeof (struct subfile_stack
));
590 tem
->next
= subfile_stack
;
592 if (current_subfile
== 0 || current_subfile
->name
== 0)
594 tem
->name
= current_subfile
->name
;
595 tem
->prev_index
= header_file_prev_index
;
602 register struct subfile_stack
*link
= subfile_stack
;
608 subfile_stack
= link
->next
;
609 header_file_prev_index
= link
->prev_index
;
615 /* Manage the vector of line numbers for each subfile. */
618 record_line (subfile
, line
, pc
)
619 register struct subfile
*subfile
;
623 struct linetable_entry
*e
;
624 /* Ignore the dummy line number in libg.o */
629 /* Make sure line vector exists and is big enough. */
630 if (!subfile
->line_vector
) {
631 subfile
->line_vector_length
= INITIAL_LINE_VECTOR_LENGTH
;
632 subfile
->line_vector
= (struct linetable
*)
633 xmalloc (sizeof (struct linetable
)
634 + subfile
->line_vector_length
* sizeof (struct linetable_entry
));
635 subfile
->line_vector
->nitems
= 0;
638 if (subfile
->line_vector
->nitems
+ 1 >= subfile
->line_vector_length
)
640 subfile
->line_vector_length
*= 2;
641 subfile
->line_vector
= (struct linetable
*)
642 xrealloc ((char *) subfile
->line_vector
, (sizeof (struct linetable
)
643 + subfile
->line_vector_length
* sizeof (struct linetable_entry
)));
646 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
++;
647 e
->line
= line
; e
->pc
= pc
;
651 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
654 compare_line_numbers (ln1p
, ln2p
)
658 return (((struct linetable_entry
*) ln1p
) -> line
-
659 ((struct linetable_entry
*) ln2p
) -> line
);
663 /* Start a new symtab for a new source file.
664 This is called when a dbx symbol of type N_SO is seen;
665 it indicates the start of data for one original source file. */
668 start_symtab (name
, dirname
, start_addr
)
671 CORE_ADDR start_addr
;
674 last_source_file
= name
;
675 last_source_start_addr
= start_addr
;
678 global_stabs
= 0; /* AIX COFF */
681 /* Context stack is initially empty. Allocate first one with room for
682 10 levels; reuse it forever afterward. */
683 if (context_stack
== 0) {
684 context_stack_size
= INITIAL_CONTEXT_STACK_SIZE
;
685 context_stack
= (struct context_stack
*)
686 xmalloc (context_stack_size
* sizeof (struct context_stack
));
688 context_stack_depth
= 0;
690 /* Leave FILENUM of 0 free for builtin types and this file's types. */
691 n_this_object_header_files
= 1;
692 header_file_prev_index
= -1;
694 type_vector_length
= 0;
695 type_vector
= (struct type
**) 0;
697 /* Initialize the list of sub source files with one entry
698 for this file (the top-level source file). */
702 start_subfile (name
, dirname
);
705 /* for all the stabs in a given stab vector, build appropriate types
706 and fix their symbols in given symbol vector. */
709 patch_block_stabs (symbols
, stabs
, objfile
)
710 struct pending
*symbols
;
711 struct pending_stabs
*stabs
;
712 struct objfile
*objfile
;
719 /* for all the stab entries, find their corresponding symbols and
720 patch their types! */
722 for (ii
= 0; ii
< stabs
->count
; ++ii
)
724 char *name
= stabs
->stab
[ii
];
725 char *pp
= (char*) strchr (name
, ':');
726 struct symbol
*sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
729 printf ("ERROR! stab symbol not found!\n"); /* FIXME */
734 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
737 lookup_function_type (read_type (&pp
, objfile
));
741 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
748 /* Finish the symbol definitions for one main source file,
749 close off all the lexical contexts for that file
750 (creating struct block's for them), then make the struct symtab
751 for that file and put it in the list of all such.
753 END_ADDR is the address of the end of the file's text. */
756 end_symtab (end_addr
, sort_pending
, sort_linevec
, objfile
)
760 struct objfile
*objfile
;
762 register struct symtab
*symtab
;
763 register struct blockvector
*blockvector
;
764 register struct subfile
*subfile
;
765 struct subfile
*nextsub
;
767 /* Finish the lexical context of the last function in the file;
768 pop the context stack. */
770 if (context_stack_depth
> 0)
772 register struct context_stack
*cstk
;
773 context_stack_depth
--;
774 cstk
= &context_stack
[context_stack_depth
];
775 /* Make a block for the local symbols within. */
776 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
777 cstk
->start_addr
, end_addr
, objfile
);
779 /* Debug: if context stack still has something in it, we are in
781 if (context_stack_depth
> 0)
785 /* It is unfortunate that in aixcoff, pending blocks might not be ordered
786 in this stage. Especially, blocks for static functions will show up at
787 the end. We need to sort them, so tools like `find_pc_function' and
788 `find_pc_block' can work reliably. */
789 if (sort_pending
&& pending_blocks
) {
790 /* FIXME! Remove this horrid bubble sort and use qsort!!! */
793 struct pending_block
*pb
, *pbnext
;
795 pb
= pending_blocks
, pbnext
= pb
->next
;
800 /* swap blocks if unordered! */
802 if (BLOCK_START(pb
->block
) < BLOCK_START(pbnext
->block
)) {
803 struct block
*tmp
= pb
->block
;
804 pb
->block
= pbnext
->block
;
809 pbnext
= pbnext
->next
;
814 /* Cleanup any undefined types that have been left hanging around
815 (this needs to be done before the finish_blocks so that
816 file_symbols is still good). */
817 cleanup_undefined_types ();
820 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
825 if (pending_blocks
== 0
827 && global_symbols
== 0) {
828 /* Ignore symtabs that have no functions with real debugging info */
831 /* Define the STATIC_BLOCK and GLOBAL_BLOCK, and build the blockvector. */
832 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
, objfile
);
833 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
, objfile
);
834 blockvector
= make_blockvector (objfile
);
837 #ifdef PROCESS_LINENUMBER_HOOK
838 PROCESS_LINENUMBER_HOOK (); /* Needed for aixcoff. */
841 /* Now create the symtab objects proper, one for each subfile. */
842 /* (The main file is the last one on the chain.) */
844 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
847 /* If we have blocks of symbols, make a symtab.
848 Otherwise, just ignore this file and any line number info in it. */
851 if (subfile
->line_vector
) {
852 /* First, shrink the linetable to make more memory. */
853 linetablesize
= sizeof (struct linetable
) +
854 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
855 subfile
->line_vector
= (struct linetable
*)
856 xrealloc ((char *) subfile
->line_vector
, linetablesize
);
859 qsort (subfile
->line_vector
->item
, subfile
->line_vector
->nitems
,
860 sizeof (struct linetable_entry
), compare_line_numbers
);
863 /* Now, allocate a symbol table. */
864 symtab
= allocate_symtab (subfile
->name
, objfile
);
866 /* Fill in its components. */
867 symtab
->blockvector
= blockvector
;
868 if (subfile
->line_vector
)
870 /* Reallocate the line table on the symbol obstack */
871 symtab
->linetable
= (struct linetable
*)
872 obstack_alloc (&objfile
-> symbol_obstack
, linetablesize
);
873 memcpy (symtab
->linetable
, subfile
->line_vector
, linetablesize
);
877 symtab
->linetable
= NULL
;
879 symtab
->dirname
= subfile
->dirname
;
880 symtab
->free_code
= free_linetable
;
881 symtab
->free_ptr
= 0;
883 #if 0 /* defined(IBM6000) */
884 /* In case we need to duplicate symbol tables (to represent include
885 files), and in case our system needs relocation, we want to
886 relocate the main symbol table node only (for the main file,
887 not for the include files). */
889 symtab
->nonreloc
= TRUE
;
892 if (subfile
->line_vector
)
893 free (subfile
->line_vector
);
895 nextsub
= subfile
->next
;
899 #if 0 /* defined(IBM6000) */
900 /* all include symbol tables are non-relocatable, except the main source
903 symtab_list
->nonreloc
= FALSE
;
907 free ((char *) type_vector
);
909 type_vector_length
= 0;
911 last_source_file
= 0;
913 previous_stab_code
= 0;
919 /* Push a context block. Args are an identifying nesting level (checkable
920 when you pop it), and the starting PC address of this context. */
922 struct context_stack
*
923 push_context (desc
, valu
)
927 register struct context_stack
*new;
929 if (context_stack_depth
== context_stack_size
)
931 context_stack_size
*= 2;
932 context_stack
= (struct context_stack
*)
933 xrealloc ((char *) context_stack
,
934 (context_stack_size
* sizeof (struct context_stack
)));
937 new = &context_stack
[context_stack_depth
++];
939 new->locals
= local_symbols
;
940 new->old_blocks
= pending_blocks
;
941 new->start_addr
= valu
;
949 /* Initialize anything that needs initializing when starting to read
950 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
962 /* Initialize anything that needs initializing when a completely new
963 symbol file is specified (not just adding some symbols from another
964 file, e.g. a shared library). */
969 /* Empty the hash table of global syms looking for values. */
970 bzero (global_sym_chain
, sizeof global_sym_chain
);
975 /* Scan through all of the global symbols defined in the object file,
976 assigning values to the debugging symbols that need to be assigned
977 to. Get these symbols from the minimal symbol table. */
980 scan_file_globals (objfile
)
981 struct objfile
*objfile
;
984 struct minimal_symbol
*msymbol
;
985 struct symbol
*sym
, *prev
;
987 for (msymbol
= objfile
-> msymbols
; msymbol
-> name
!= NULL
; msymbol
++)
991 prev
= (struct symbol
*) 0;
993 /* Get the hash index and check all the symbols
994 under that hash index. */
996 hash
= hashname (msymbol
-> name
);
998 for (sym
= global_sym_chain
[hash
]; sym
;)
1000 if (*(msymbol
-> name
) == SYMBOL_NAME (sym
)[0]
1001 && !strcmp(msymbol
-> name
+ 1, SYMBOL_NAME (sym
) + 1))
1003 /* Splice this symbol out of the hash chain and
1004 assign the value we have to it. */
1006 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1008 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1010 /* Check to see whether we need to fix up a common block. */
1011 /* Note: this code might be executed several times for
1012 the same symbol if there are multiple references. */
1013 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1014 fix_common_block (sym
, msymbol
-> address
);
1016 SYMBOL_VALUE_ADDRESS (sym
) = msymbol
-> address
;
1019 sym
= SYMBOL_VALUE_CHAIN (prev
);
1021 sym
= global_sym_chain
[hash
];
1026 sym
= SYMBOL_VALUE_CHAIN (sym
);
1033 /* Read a number by which a type is referred to in dbx data,
1034 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
1035 Just a single number N is equivalent to (0,N).
1036 Return the two numbers by storing them in the vector TYPENUMS.
1037 TYPENUMS will then be used as an argument to dbx_lookup_type. */
1040 read_type_number (pp
, typenums
)
1042 register int *typenums
;
1047 typenums
[0] = read_number (pp
, ',');
1048 typenums
[1] = read_number (pp
, ')');
1053 typenums
[1] = read_number (pp
, 0);
1057 /* To handle GNU C++ typename abbreviation, we need to be able to
1058 fill in a type's name as soon as space for that type is allocated.
1059 `type_synonym_name' is the name of the type being allocated.
1060 It is cleared as soon as it is used (lest all allocated types
1062 static char *type_synonym_name
;
1066 define_symbol (valu
, string
, desc
, type
, objfile
)
1071 struct objfile
*objfile
;
1073 register struct symbol
*sym
;
1074 char *p
= (char *) strchr (string
, ':');
1078 struct type
*temptype
;
1080 /* Ignore syms with empty names. */
1084 /* Ignore old-style symbols from cc -go */
1088 sym
= (struct symbol
*)obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1090 if (processing_gcc_compilation
) {
1091 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
1092 number of bytes occupied by a type or object, which we ignore. */
1093 SYMBOL_LINE(sym
) = desc
;
1095 SYMBOL_LINE(sym
) = 0; /* unknown */
1098 if (string
[0] == CPLUS_MARKER
)
1100 /* Special GNU C++ names. */
1104 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
1105 &objfile
-> symbol_obstack
);
1107 case 'v': /* $vtbl_ptr_type */
1108 /* Was: SYMBOL_NAME (sym) = "vptr"; */
1111 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
1112 &objfile
-> symbol_obstack
);
1116 /* This was an anonymous type that was never fixed up. */
1127 = (char *) obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
1128 /* Open-coded bcopy--saves function call time. */
1130 register char *p1
= string
;
1131 register char *p2
= SYMBOL_NAME (sym
);
1138 /* Determine the type of name being defined. */
1139 /* The Acorn RISC machine's compiler can put out locals that don't
1140 start with "234=" or "(3,4)=", so assume anything other than the
1141 deftypes we know how to handle is a local. */
1142 /* (Peter Watkins @ Computervision)
1143 Handle Sun-style local fortran array types 'ar...' .
1144 (gnu@cygnus.com) -- this strchr() handles them properly?
1145 (tiemann@cygnus.com) -- 'C' is for catch. */
1146 if (!strchr ("cfFGpPrStTvVXC", *p
))
1151 /* c is a special case, not followed by a type-number.
1152 SYMBOL:c=iVALUE for an integer constant symbol.
1153 SYMBOL:c=rVALUE for a floating constant symbol.
1154 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1155 e.g. "b:c=e6,0" for "const b = blob1"
1156 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1160 error ("Invalid symbol data at symtab pos %d.", symnum
);
1165 double d
= atof (p
);
1168 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1171 obstack_alloc (&objfile
-> type_obstack
,
1173 memcpy (dbl_valu
, &d
, sizeof (double));
1174 SWAP_TARGET_AND_HOST (dbl_valu
, sizeof (double));
1175 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
1176 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
1181 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1183 SYMBOL_VALUE (sym
) = atoi (p
);
1184 SYMBOL_CLASS (sym
) = LOC_CONST
;
1188 /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1189 e.g. "b:c=e6,0" for "const b = blob1"
1190 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1194 read_type_number (&p
, typenums
);
1196 error ("Invalid symbol data: no comma in enum const symbol");
1198 SYMBOL_TYPE (sym
) = *dbx_lookup_type (typenums
);
1199 SYMBOL_VALUE (sym
) = atoi (p
);
1200 SYMBOL_CLASS (sym
) = LOC_CONST
;
1204 error ("Invalid symbol data at symtab pos %d.", symnum
);
1206 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1207 add_symbol_to_list (sym
, &file_symbols
);
1211 /* Now usually comes a number that says which data type,
1212 and possibly more stuff to define the type
1213 (all of which is handled by read_type) */
1215 if (deftype
== 'p' && *p
== 'F')
1216 /* pF is a two-letter code that means a function parameter in Fortran.
1217 The type-number specifies the type of the return value.
1218 Translate it into a pointer-to-function type. */
1222 = lookup_pointer_type (lookup_function_type (read_type (&p
, objfile
)));
1226 struct type
*type_read
;
1227 synonym
= *p
== 't';
1232 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
1233 strlen (SYMBOL_NAME (sym
)),
1234 &objfile
-> symbol_obstack
);
1237 /* Here we save the name of the symbol for read_range_type, which
1238 ends up reading in the basic types. In stabs, unfortunately there
1239 is no distinction between "int" and "long" types except their
1240 names. Until we work out a saner type policy (eliminating most
1241 builtin types and using the names specified in the files), we
1242 save away the name so that far away from here in read_range_type,
1243 we can examine it to decide between "int" and "long". FIXME. */
1244 long_kludge_name
= SYMBOL_NAME (sym
);
1245 type_read
= read_type (&p
, objfile
);
1247 if ((deftype
== 'F' || deftype
== 'f')
1248 && TYPE_CODE (type_read
) != TYPE_CODE_FUNC
)
1251 /* This code doesn't work -- it needs to realloc and can't. */
1252 struct type
*new = (struct type
*)
1253 obstack_alloc (&objfile
-> type_obstack
,
1254 sizeof (struct type
));
1256 /* Generate a template for the type of this function. The
1257 types of the arguments will be added as we read the symbol
1259 *new = *lookup_function_type (type_read
);
1260 SYMBOL_TYPE(sym
) = new;
1261 TYPE_OBJFILE (new) = objfile
;
1262 in_function_type
= new;
1264 SYMBOL_TYPE (sym
) = lookup_function_type (type_read
);
1268 SYMBOL_TYPE (sym
) = type_read
;
1274 /* The name of a caught exception. */
1275 SYMBOL_CLASS (sym
) = LOC_LABEL
;
1276 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1277 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1278 add_symbol_to_list (sym
, &local_symbols
);
1282 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1283 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1284 add_symbol_to_list (sym
, &file_symbols
);
1288 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1289 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1290 add_symbol_to_list (sym
, &global_symbols
);
1294 /* For a class G (global) symbol, it appears that the
1295 value is not correct. It is necessary to search for the
1296 corresponding linker definition to find the value.
1297 These definitions appear at the end of the namelist. */
1298 i
= hashname (SYMBOL_NAME (sym
));
1299 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1300 global_sym_chain
[i
] = sym
;
1301 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1302 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1303 add_symbol_to_list (sym
, &global_symbols
);
1306 /* This case is faked by a conditional above,
1307 when there is no code letter in the dbx data.
1308 Dbx data never actually contains 'l'. */
1310 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1311 SYMBOL_VALUE (sym
) = valu
;
1312 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1313 add_symbol_to_list (sym
, &local_symbols
);
1317 /* Normally this is a parameter, a LOC_ARG. On the i960, it
1318 can also be a LOC_LOCAL_ARG depending on symbol type. */
1319 #ifndef DBX_PARM_SYMBOL_CLASS
1320 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
1322 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
1323 SYMBOL_VALUE (sym
) = valu
;
1324 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1326 /* This doesn't work yet. */
1327 add_param_to_type (&in_function_type
, sym
);
1329 add_symbol_to_list (sym
, &local_symbols
);
1331 /* If it's gcc-compiled, if it says `short', believe it. */
1332 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
1335 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
1336 /* This macro is defined on machines (e.g. sparc) where
1337 we should believe the type of a PCC 'short' argument,
1338 but shouldn't believe the address (the address is
1339 the address of the corresponding int). Note that
1340 this is only different from the BELIEVE_PCC_PROMOTION
1341 case on big-endian machines.
1343 My guess is that this correction, as opposed to changing
1344 the parameter to an 'int' (as done below, for PCC
1345 on most machines), is the right thing to do
1346 on all machines, but I don't want to risk breaking
1347 something that already works. On most PCC machines,
1348 the sparc problem doesn't come up because the calling
1349 function has to zero the top bytes (not knowing whether
1350 the called function wants an int or a short), so there
1351 is no practical difference between an int and a short
1352 (except perhaps what happens when the GDB user types
1353 "print short_arg = 0x10000;").
1355 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
1356 actually produces the correct address (we don't need to fix it
1357 up). I made this code adapt so that it will offset the symbol
1358 if it was pointing at an int-aligned location and not
1359 otherwise. This way you can use the same gdb for 4.0.x and
1362 If the parameter is shorter than an int, and is integral
1363 (e.g. char, short, or unsigned equivalent), and is claimed to
1364 be passed on an integer boundary, don't believe it! Offset the
1365 parameter's address to the tail-end of that integer. */
1367 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
1368 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1369 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1370 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1372 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
1373 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1377 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
1379 /* If PCC says a parameter is a short or a char,
1380 it is really an int. */
1381 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
1382 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1383 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1385 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1386 ? lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
)
1391 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
1394 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1395 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1396 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1397 add_symbol_to_list (sym
, &local_symbols
);
1401 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1402 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1403 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1404 add_symbol_to_list (sym
, &local_symbols
);
1408 /* Static symbol at top level of file */
1409 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1410 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1411 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1412 add_symbol_to_list (sym
, &file_symbols
);
1416 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1417 SYMBOL_VALUE (sym
) = valu
;
1418 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1419 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1420 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1421 obsavestring (SYMBOL_NAME (sym
),
1422 strlen (SYMBOL_NAME (sym
)),
1423 &objfile
-> symbol_obstack
);
1424 /* C++ vagaries: we may have a type which is derived from
1425 a base type which did not have its name defined when the
1426 derived class was output. We fill in the derived class's
1427 base part member's name here in that case. */
1428 else if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1429 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1430 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1433 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1434 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1435 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1436 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1439 add_symbol_to_list (sym
, &file_symbols
);
1443 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1444 SYMBOL_VALUE (sym
) = valu
;
1445 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1446 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1447 TYPE_NAME (SYMBOL_TYPE (sym
))
1448 = obconcat (&objfile
-> type_obstack
, "",
1449 (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_ENUM
1451 : (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1452 ? "struct " : "union ")),
1454 add_symbol_to_list (sym
, &file_symbols
);
1458 register struct symbol
*typedef_sym
= (struct symbol
*)
1459 obstack_alloc (&objfile
-> type_obstack
,
1460 sizeof (struct symbol
));
1461 SYMBOL_NAME (typedef_sym
) = SYMBOL_NAME (sym
);
1462 SYMBOL_TYPE (typedef_sym
) = SYMBOL_TYPE (sym
);
1464 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1465 SYMBOL_VALUE (typedef_sym
) = valu
;
1466 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
1467 add_symbol_to_list (typedef_sym
, &file_symbols
);
1472 /* Static symbol of local scope */
1473 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1474 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1475 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1476 add_symbol_to_list (sym
, &local_symbols
);
1480 /* Reference parameter */
1481 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
1482 SYMBOL_VALUE (sym
) = valu
;
1483 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1484 add_symbol_to_list (sym
, &local_symbols
);
1488 /* This is used by Sun FORTRAN for "function result value".
1489 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1490 that Pascal uses it too, but when I tried it Pascal used
1491 "x:3" (local symbol) instead. */
1492 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1493 SYMBOL_VALUE (sym
) = valu
;
1494 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1495 add_symbol_to_list (sym
, &local_symbols
);
1499 error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype
, symnum
);
1504 /* What about types defined as forward references inside of a small lexical
1506 /* Add a type to the list of undefined types to be checked through
1507 once this file has been read in. */
1509 add_undefined_type (type
)
1512 if (undef_types_length
== undef_types_allocated
)
1514 undef_types_allocated
*= 2;
1515 undef_types
= (struct type
**)
1516 xrealloc ((char *) undef_types
,
1517 undef_types_allocated
* sizeof (struct type
*));
1519 undef_types
[undef_types_length
++] = type
;
1522 /* Go through each undefined type, see if it's still undefined, and fix it
1523 up if possible. We have two kinds of undefined types:
1525 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
1526 Fix: update array length using the element bounds
1527 and the target type's length.
1528 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
1529 yet defined at the time a pointer to it was made.
1530 Fix: Do a full lookup on the struct/union tag. */
1532 cleanup_undefined_types ()
1536 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++) {
1537 switch (TYPE_CODE (*type
)) {
1539 case TYPE_CODE_STRUCT
:
1540 case TYPE_CODE_UNION
:
1541 case TYPE_CODE_ENUM
:
1543 /* Reasonable test to see if it's been defined since. */
1544 if (TYPE_NFIELDS (*type
) == 0)
1546 struct pending
*ppt
;
1548 /* Name of the type, without "struct" or "union" */
1549 char *typename
= TYPE_NAME (*type
);
1551 if (!strncmp (typename
, "struct ", 7))
1553 if (!strncmp (typename
, "union ", 6))
1555 if (!strncmp (typename
, "enum ", 5))
1558 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1559 for (i
= 0; i
< ppt
->nsyms
; i
++)
1561 struct symbol
*sym
= ppt
->symbol
[i
];
1563 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1564 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1565 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
1567 && !strcmp (SYMBOL_NAME (sym
), typename
))
1568 memcpy (*type
, SYMBOL_TYPE (sym
), sizeof (struct type
));
1572 /* It has been defined; don't mark it as a stub. */
1573 TYPE_FLAGS (*type
) &= ~TYPE_FLAG_STUB
;
1577 case TYPE_CODE_ARRAY
:
1579 struct type
*range_type
;
1582 if (TYPE_LENGTH (*type
) != 0) /* Better be unknown */
1584 if (TYPE_NFIELDS (*type
) != 1)
1586 range_type
= TYPE_FIELD_TYPE (*type
, 0);
1587 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
1590 /* Now recompute the length of the array type, based on its
1591 number of elements and the target type's length. */
1592 lower
= TYPE_FIELD_BITPOS (range_type
, 0);
1593 upper
= TYPE_FIELD_BITPOS (range_type
, 1);
1594 TYPE_LENGTH (*type
) = (upper
- lower
+ 1)
1595 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type
));
1601 error ("GDB internal error. cleanup_undefined_types with bad\
1602 type %d.", TYPE_CODE (*type
));
1606 undef_types_length
= 0;
1609 /* Skip rest of this symbol and return an error type.
1611 General notes on error recovery: error_type always skips to the
1612 end of the symbol (modulo cretinous dbx symbol name continuation).
1613 Thus code like this:
1615 if (*(*pp)++ != ';')
1616 return error_type (pp);
1618 is wrong because if *pp starts out pointing at '\0' (typically as the
1619 result of an earlier error), it will be incremented to point to the
1620 start of the next symbol, which might produce strange results, at least
1621 if you run off the end of the string table. Instead use
1624 return error_type (pp);
1630 foo = error_type (pp);
1634 And in case it isn't obvious, the point of all this hair is so the compiler
1635 can define new types and new syntaxes, and old versions of the
1636 debugger will be able to read the new symbol tables. */
1642 complain (&error_type_complaint
, 0);
1645 /* Skip to end of symbol. */
1646 while (**pp
!= '\0')
1649 /* Check for and handle cretinous dbx symbol name continuation! */
1650 if ((*pp
)[-1] == '\\')
1651 *pp
= next_symbol_text ();
1655 return builtin_type_error
;
1658 /* Read a dbx type reference or definition;
1659 return the type that is meant.
1660 This can be just a number, in which case it references
1661 a type already defined and placed in type_vector.
1662 Or the number can be followed by an =, in which case
1663 it means to define a new type according to the text that
1667 read_type (pp
, objfile
)
1669 struct objfile
*objfile
;
1671 register struct type
*type
= 0;
1676 /* Read type number if present. The type number may be omitted.
1677 for instance in a two-dimensional array declared with type
1678 "ar1;1;10;ar1;1;10;4". */
1679 if ((**pp
>= '0' && **pp
<= '9')
1682 read_type_number (pp
, typenums
);
1684 /* Type is not being defined here. Either it already exists,
1685 or this is a forward reference to it. dbx_alloc_type handles
1688 return dbx_alloc_type (typenums
, objfile
);
1690 /* Type is being defined here. */
1691 #if 0 /* Callers aren't prepared for a NULL result! FIXME -- metin! */
1695 /* if such a type already exists, this is an unnecessary duplication
1696 of the stab string, which is common in (RS/6000) xlc generated
1697 objects. In that case, simply return NULL and let the caller take
1700 tt
= *dbx_lookup_type (typenums
);
1701 if (tt
&& tt
->length
&& tt
->code
)
1710 /* 'typenums=' not present, type is anonymous. Read and return
1711 the definition, but don't put it in the type vector. */
1712 typenums
[0] = typenums
[1] = -1;
1720 enum type_code code
;
1722 /* Used to index through file_symbols. */
1723 struct pending
*ppt
;
1726 /* Name including "struct", etc. */
1729 /* Name without "struct", etc. */
1730 char *type_name_only
;
1736 /* Set the type code according to the following letter. */
1740 code
= TYPE_CODE_STRUCT
;
1744 code
= TYPE_CODE_UNION
;
1748 code
= TYPE_CODE_ENUM
;
1752 return error_type (pp
);
1755 to
= type_name
= (char *)
1756 obstack_alloc (&objfile
-> type_obstack
,
1758 ((char *) strchr (*pp
, ':') - (*pp
)) + 1));
1760 /* Copy the prefix. */
1762 while (*to
++ = *from
++)
1766 type_name_only
= to
;
1768 /* Copy the name. */
1770 while ((*to
++ = *from
++) != ':')
1774 /* Set the pointer ahead of the name which we just read. */
1778 /* The following hack is clearly wrong, because it doesn't
1779 check whether we are in a baseclass. I tried to reproduce
1780 the case that it is trying to fix, but I couldn't get
1781 g++ to put out a cross reference to a basetype. Perhaps
1782 it doesn't do it anymore. */
1783 /* Note: for C++, the cross reference may be to a base type which
1784 has not yet been seen. In this case, we skip to the comma,
1785 which will mark the end of the base class name. (The ':'
1786 at the end of the base class name will be skipped as well.)
1787 But sometimes (ie. when the cross ref is the last thing on
1788 the line) there will be no ','. */
1789 from
= (char *) strchr (*pp
, ',');
1795 /* Now check to see whether the type has already been declared. */
1796 /* This is necessary at least in the case where the
1797 program says something like
1799 The compiler puts out a cross-reference; we better find
1800 set the length of the structure correctly so we can
1801 set the length of the array. */
1802 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1803 for (i
= 0; i
< ppt
->nsyms
; i
++)
1805 struct symbol
*sym
= ppt
->symbol
[i
];
1807 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1808 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1809 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
1810 && !strcmp (SYMBOL_NAME (sym
), type_name_only
))
1812 obstack_free (&objfile
-> type_obstack
, type_name
);
1813 type
= SYMBOL_TYPE (sym
);
1818 /* Didn't find the type to which this refers, so we must
1819 be dealing with a forward reference. Allocate a type
1820 structure for it, and keep track of it so we can
1821 fill in the rest of the fields when we get the full
1823 type
= dbx_alloc_type (typenums
, objfile
);
1824 TYPE_CODE (type
) = code
;
1825 TYPE_NAME (type
) = type_name
;
1826 INIT_CPLUS_SPECIFIC(type
);
1827 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1829 add_undefined_type (type
);
1833 case '-': /* RS/6000 built-in type */
1835 type
= builtin_type (pp
); /* (in xcoffread.c) */
1850 read_type_number (pp
, xtypenums
);
1851 type
= *dbx_lookup_type (xtypenums
);
1856 type
= lookup_fundamental_type (objfile
, FT_VOID
);
1857 if (typenums
[0] != -1)
1858 *dbx_lookup_type (typenums
) = type
;
1862 type1
= read_type (pp
, objfile
);
1863 /* FIXME -- we should be doing smash_to_XXX types here. */
1865 /* postponed type decoration should be allowed. */
1866 if (typenums
[1] > 0 && typenums
[1] < type_vector_length
&&
1867 (type
= type_vector
[typenums
[1]])) {
1868 smash_to_pointer_type (type
, type1
);
1872 type
= lookup_pointer_type (type1
);
1873 if (typenums
[0] != -1)
1874 *dbx_lookup_type (typenums
) = type
;
1879 struct type
*domain
= read_type (pp
, objfile
);
1880 struct type
*memtype
;
1883 /* Invalid member type data format. */
1884 return error_type (pp
);
1887 memtype
= read_type (pp
, objfile
);
1888 type
= dbx_alloc_type (typenums
, objfile
);
1889 smash_to_member_type (type
, domain
, memtype
);
1894 if ((*pp
)[0] == '#')
1896 /* We'll get the parameter types from the name. */
1897 struct type
*return_type
;
1900 return_type
= read_type (pp
, objfile
);
1901 if (*(*pp
)++ != ';')
1902 complain (&invalid_member_complaint
, (char *) symnum
);
1903 type
= allocate_stub_method (return_type
);
1904 if (typenums
[0] != -1)
1905 *dbx_lookup_type (typenums
) = type
;
1909 struct type
*domain
= read_type (pp
, objfile
);
1910 struct type
*return_type
;
1913 if (*(*pp
)++ != ',')
1914 error ("invalid member type data format, at symtab pos %d.",
1917 return_type
= read_type (pp
, objfile
);
1918 args
= read_args (pp
, ';', objfile
);
1919 type
= dbx_alloc_type (typenums
, objfile
);
1920 smash_to_method_type (type
, domain
, return_type
, args
);
1925 type1
= read_type (pp
, objfile
);
1926 type
= lookup_reference_type (type1
);
1927 if (typenums
[0] != -1)
1928 *dbx_lookup_type (typenums
) = type
;
1932 type1
= read_type (pp
, objfile
);
1933 type
= lookup_function_type (type1
);
1934 if (typenums
[0] != -1)
1935 *dbx_lookup_type (typenums
) = type
;
1939 type
= read_range_type (pp
, typenums
, objfile
);
1940 if (typenums
[0] != -1)
1941 *dbx_lookup_type (typenums
) = type
;
1945 type
= dbx_alloc_type (typenums
, objfile
);
1946 type
= read_enum_type (pp
, type
, objfile
);
1947 *dbx_lookup_type (typenums
) = type
;
1951 type
= dbx_alloc_type (typenums
, objfile
);
1952 if (!TYPE_NAME (type
))
1953 TYPE_NAME (type
) = type_synonym_name
;
1954 type_synonym_name
= 0;
1955 type
= read_struct_type (pp
, type
, objfile
);
1959 type
= dbx_alloc_type (typenums
, objfile
);
1960 if (!TYPE_NAME (type
))
1961 TYPE_NAME (type
) = type_synonym_name
;
1962 type_synonym_name
= 0;
1963 type
= read_struct_type (pp
, type
, objfile
);
1964 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1969 return error_type (pp
);
1972 type
= dbx_alloc_type (typenums
, objfile
);
1973 type
= read_array_type (pp
, type
, objfile
);
1977 --*pp
; /* Go back to the symbol in error */
1978 /* Particularly important if it was \0! */
1979 return error_type (pp
);
1986 /* If this is an overriding temporary alteration for a header file's
1987 contents, and this type number is unknown in the global definition,
1988 put this type into the global definition at this type number. */
1989 if (header_file_prev_index
>= 0)
1991 register struct type
**tp
1992 = explicit_lookup_type (header_file_prev_index
, typenums
[1]);
2000 /* This page contains subroutines of read_type. */
2002 /* Read the description of a structure (or union type)
2003 and return an object describing the type. */
2005 static struct type
*
2006 read_struct_type (pp
, type
, objfile
)
2008 register struct type
*type
;
2009 struct objfile
*objfile
;
2011 /* Total number of methods defined in this class.
2012 If the class defines two `f' methods, and one `g' method,
2013 then this will have the value 3. */
2014 int total_length
= 0;
2018 struct nextfield
*next
;
2019 int visibility
; /* 0=public, 1=protected, 2=public */
2025 struct next_fnfield
*next
;
2026 struct fn_field fn_field
;
2029 struct next_fnfieldlist
2031 struct next_fnfieldlist
*next
;
2032 struct fn_fieldlist fn_fieldlist
;
2035 register struct nextfield
*list
= 0;
2036 struct nextfield
*new;
2039 int non_public_fields
= 0;
2042 register struct next_fnfieldlist
*mainlist
= 0;
2045 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2046 INIT_CPLUS_SPECIFIC(type
);
2048 /* First comes the total size in bytes. */
2050 TYPE_LENGTH (type
) = read_number (pp
, 0);
2052 /* C++: Now, if the class is a derived class, then the next character
2053 will be a '!', followed by the number of base classes derived from.
2054 Each element in the list contains visibility information,
2055 the offset of this base class in the derived structure,
2056 and then the base type. */
2059 int i
, n_baseclasses
, offset
;
2060 struct type
*baseclass
;
2063 /* Nonzero if it is a virtual baseclass, i.e.,
2067 struct C : public B, public virtual A {};
2069 B is a baseclass of C; A is a virtual baseclass for C. This is a C++
2070 2.0 language feature. */
2075 ALLOCATE_CPLUS_STRUCT_TYPE(type
);
2077 n_baseclasses
= read_number (pp
, ',');
2078 TYPE_FIELD_VIRTUAL_BITS (type
) =
2079 (B_TYPE
*) obstack_alloc (&objfile
-> type_obstack
,
2080 B_BYTES (n_baseclasses
));
2081 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), n_baseclasses
);
2083 for (i
= 0; i
< n_baseclasses
; i
++)
2086 *pp
= next_symbol_text ();
2097 /* Bad visibility format. */
2098 return error_type (pp
);
2106 non_public_fields
++;
2112 /* Bad visibility format. */
2113 return error_type (pp
);
2116 SET_TYPE_FIELD_VIRTUAL (type
, i
);
2119 /* Offset of the portion of the object corresponding to
2120 this baseclass. Always zero in the absence of
2121 multiple inheritance. */
2122 offset
= read_number (pp
, ',');
2123 baseclass
= read_type (pp
, objfile
);
2124 *pp
+= 1; /* skip trailing ';' */
2126 /* Make this baseclass visible for structure-printing purposes. */
2127 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2130 list
->visibility
= via_public
;
2131 list
->field
.type
= baseclass
;
2132 list
->field
.name
= type_name_no_tag (baseclass
);
2133 list
->field
.bitpos
= offset
;
2134 list
->field
.bitsize
= 0; /* this should be an unpacked field! */
2137 TYPE_N_BASECLASSES (type
) = n_baseclasses
;
2140 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
2141 At the end, we see a semicolon instead of a field.
2143 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2146 The `?' is a placeholder for one of '/2' (public visibility),
2147 '/1' (protected visibility), '/0' (private visibility), or nothing
2148 (C style symbol table, public visibility). */
2150 /* We better set p right now, in case there are no fields at all... */
2155 /* Check for and handle cretinous dbx symbol name continuation! */
2156 if (**pp
== '\\') *pp
= next_symbol_text ();
2158 /* Get space to record the next field's data. */
2159 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2163 /* Get the field name. */
2165 if (*p
== CPLUS_MARKER
)
2167 /* Special GNU C++ name. */
2172 struct type
*context
;
2183 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2184 prefix
= "INVALID_C++_ABBREV";
2188 context
= read_type (pp
, objfile
);
2189 name
= type_name_no_tag (context
);
2192 complain (&invalid_cpp_type_complaint
, (char *) symnum
);
2193 TYPE_NAME (context
) = name
;
2195 list
->field
.name
= obconcat (&objfile
-> type_obstack
,
2199 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2200 list
->field
.type
= read_type (pp
, objfile
);
2201 (*pp
)++; /* Skip the comma. */
2202 list
->field
.bitpos
= read_number (pp
, ';');
2203 /* This field is unpacked. */
2204 list
->field
.bitsize
= 0;
2205 list
->visibility
= 0; /* private */
2206 non_public_fields
++;
2208 /* GNU C++ anonymous type. */
2212 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2218 while (*p
!= ':') p
++;
2219 list
->field
.name
= obsavestring (*pp
, p
- *pp
,
2220 &objfile
-> type_obstack
);
2222 /* C++: Check to see if we have hit the methods yet. */
2228 /* This means we have a visibility for a field coming. */
2234 list
->visibility
= 0; /* private */
2235 non_public_fields
++;
2240 list
->visibility
= 1; /* protected */
2241 non_public_fields
++;
2246 list
->visibility
= 2; /* public */
2251 else /* normal dbx-style format. */
2252 list
->visibility
= 2; /* public */
2254 list
->field
.type
= read_type (pp
, objfile
);
2257 /* Static class member. */
2258 list
->field
.bitpos
= (long)-1;
2260 while (*p
!= ';') p
++;
2261 list
->field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
2266 else if (**pp
!= ',')
2267 /* Bad structure-type format. */
2268 return error_type (pp
);
2270 (*pp
)++; /* Skip the comma. */
2271 list
->field
.bitpos
= read_number (pp
, ',');
2272 list
->field
.bitsize
= read_number (pp
, ';');
2275 /* FIXME-tiemann: Can't the compiler put out something which
2276 lets us distinguish these? (or maybe just not put out anything
2277 for the field). What is the story here? What does the compiler
2278 really do? Also, patch gdb.texinfo for this case; I document
2279 it as a possible problem there. Search for "DBX-style". */
2281 /* This is wrong because this is identical to the symbols
2282 produced for GCC 0-size arrays. For example:
2287 The code which dumped core in such circumstances should be
2288 fixed not to dump core. */
2290 /* g++ -g0 can put out bitpos & bitsize zero for a static
2291 field. This does not give us any way of getting its
2292 class, so we can't know its name. But we can just
2293 ignore the field so we don't dump core and other nasty
2295 if (list
->field
.bitpos
== 0
2296 && list
->field
.bitsize
== 0)
2298 complain (&dbx_class_complaint
, 0);
2299 /* Ignore this field. */
2305 /* Detect an unpacked field and mark it as such.
2306 dbx gives a bit size for all fields.
2307 Note that forward refs cannot be packed,
2308 and treat enums as if they had the width of ints. */
2309 if (TYPE_CODE (list
->field
.type
) != TYPE_CODE_INT
2310 && TYPE_CODE (list
->field
.type
) != TYPE_CODE_ENUM
)
2311 list
->field
.bitsize
= 0;
2312 if ((list
->field
.bitsize
== 8 * TYPE_LENGTH (list
->field
.type
)
2313 || (TYPE_CODE (list
->field
.type
) == TYPE_CODE_ENUM
2314 && (list
->field
.bitsize
2315 == 8 * TYPE_LENGTH (lookup_fundamental_type (objfile
, FT_INTEGER
)))
2319 list
->field
.bitpos
% 8 == 0)
2320 list
->field
.bitsize
= 0;
2326 /* chill the list of fields: the last entry (at the head)
2327 is a partially constructed entry which we now scrub. */
2330 /* Now create the vector of fields, and record how big it is.
2331 We need this info to record proper virtual function table information
2332 for this class's virtual functions. */
2334 TYPE_NFIELDS (type
) = nfields
;
2335 TYPE_FIELDS (type
) = (struct field
*)
2336 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct field
) * nfields
);
2338 if (non_public_fields
)
2340 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2342 TYPE_FIELD_PRIVATE_BITS (type
) =
2343 (B_TYPE
*) obstack_alloc (&objfile
-> type_obstack
,
2345 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2347 TYPE_FIELD_PROTECTED_BITS (type
) =
2348 (B_TYPE
*) obstack_alloc (&objfile
-> type_obstack
,
2350 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2353 /* Copy the saved-up fields into the field vector. */
2355 for (n
= nfields
; list
; list
= list
->next
)
2358 TYPE_FIELD (type
, n
) = list
->field
;
2359 if (list
->visibility
== 0)
2360 SET_TYPE_FIELD_PRIVATE (type
, n
);
2361 else if (list
->visibility
== 1)
2362 SET_TYPE_FIELD_PROTECTED (type
, n
);
2365 /* Now come the method fields, as NAME::methods
2366 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
2367 At the end, we see a semicolon instead of a field.
2369 For the case of overloaded operators, the format is
2370 op$::*.methods, where $ is the CPLUS_MARKER (usually '$'),
2371 `*' holds the place for an operator name (such as `+=')
2372 and `.' marks the end of the operator name. */
2375 /* Now, read in the methods. To simplify matters, we
2376 "unread" the name that has been read, so that we can
2377 start from the top. */
2379 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2380 /* For each list of method lists... */
2384 struct next_fnfield
*sublist
= 0;
2385 struct type
*look_ahead_type
= NULL
;
2387 struct next_fnfieldlist
*new_mainlist
=
2388 (struct next_fnfieldlist
*)alloca (sizeof (struct next_fnfieldlist
));
2393 /* read in the name. */
2394 while (*p
!= ':') p
++;
2395 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
2397 /* This is a completely wierd case. In order to stuff in the
2398 names that might contain colons (the usual name delimiter),
2399 Mike Tiemann defined a different name format which is
2400 signalled if the identifier is "op$". In that case, the
2401 format is "op$::XXXX." where XXXX is the name. This is
2402 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2403 /* This lets the user type "break operator+".
2404 We could just put in "+" as the name, but that wouldn't
2406 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
2407 char *o
= opname
+ 3;
2409 /* Skip past '::'. */
2411 if (**pp
== '\\') *pp
= next_symbol_text ();
2415 main_fn_name
= savestring (opname
, o
- opname
);
2421 main_fn_name
= savestring (*pp
, p
- *pp
);
2422 /* Skip past '::'. */
2425 new_mainlist
->fn_fieldlist
.name
= main_fn_name
;
2429 struct next_fnfield
*new_sublist
=
2430 (struct next_fnfield
*)alloca (sizeof (struct next_fnfield
));
2432 /* Check for and handle cretinous dbx symbol name continuation! */
2433 if (look_ahead_type
== NULL
) /* Normal case. */
2435 if (**pp
== '\\') *pp
= next_symbol_text ();
2437 new_sublist
->fn_field
.type
= read_type (pp
, objfile
);
2439 /* Invalid symtab info for method. */
2440 return error_type (pp
);
2443 { /* g++ version 1 kludge */
2444 new_sublist
->fn_field
.type
= look_ahead_type
;
2445 look_ahead_type
= NULL
;
2450 while (*p
!= ';') p
++;
2452 /* If this is just a stub, then we don't have the
2454 if (TYPE_FLAGS (new_sublist
->fn_field
.type
) & TYPE_FLAG_STUB
)
2455 new_sublist
->fn_field
.is_stub
= 1;
2456 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
2459 /* Set this method's visibility fields. */
2460 switch (*(*pp
)++ - '0')
2463 new_sublist
->fn_field
.is_private
= 1;
2466 new_sublist
->fn_field
.is_protected
= 1;
2470 if (**pp
== '\\') *pp
= next_symbol_text ();
2473 case 'A': /* Normal functions. */
2474 new_sublist
->fn_field
.is_const
= 0;
2475 new_sublist
->fn_field
.is_volatile
= 0;
2478 case 'B': /* `const' member functions. */
2479 new_sublist
->fn_field
.is_const
= 1;
2480 new_sublist
->fn_field
.is_volatile
= 0;
2483 case 'C': /* `volatile' member function. */
2484 new_sublist
->fn_field
.is_const
= 0;
2485 new_sublist
->fn_field
.is_volatile
= 1;
2488 case 'D': /* `const volatile' member function. */
2489 new_sublist
->fn_field
.is_const
= 1;
2490 new_sublist
->fn_field
.is_volatile
= 1;
2493 case '*': /* File compiled with g++ version 1 -- no info */
2498 complain (&const_vol_complaint
, (char *) (long) **pp
);
2505 /* virtual member function, followed by index. */
2506 /* The sign bit is set to distinguish pointers-to-methods
2507 from virtual function indicies. Since the array is
2508 in words, the quantity must be shifted left by 1
2509 on 16 bit machine, and by 2 on 32 bit machine, forcing
2510 the sign bit out, and usable as a valid index into
2511 the array. Remove the sign bit here. */
2512 new_sublist
->fn_field
.voffset
=
2513 (0x7fffffff & read_number (pp
, ';')) + 2;
2515 if (**pp
== '\\') *pp
= next_symbol_text ();
2517 if (**pp
== ';' || **pp
== '\0')
2518 /* Must be g++ version 1. */
2519 new_sublist
->fn_field
.fcontext
= 0;
2522 /* Figure out from whence this virtual function came.
2523 It may belong to virtual function table of
2524 one of its baseclasses. */
2525 look_ahead_type
= read_type (pp
, objfile
);
2527 { /* g++ version 1 overloaded methods. */ }
2530 new_sublist
->fn_field
.fcontext
= look_ahead_type
;
2532 return error_type (pp
);
2535 look_ahead_type
= NULL
;
2541 /* static member function. */
2542 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
2543 if (strncmp (new_sublist
->fn_field
.physname
,
2544 main_fn_name
, strlen (main_fn_name
)))
2545 new_sublist
->fn_field
.is_stub
= 1;
2550 complain (&member_fn_complaint
, (char *) (long) (*pp
)[-1]);
2551 /* Fall through into normal member function. */
2554 /* normal member function. */
2555 new_sublist
->fn_field
.voffset
= 0;
2556 new_sublist
->fn_field
.fcontext
= 0;
2560 new_sublist
->next
= sublist
;
2561 sublist
= new_sublist
;
2563 if (**pp
== '\\') *pp
= next_symbol_text ();
2565 while (**pp
!= ';' && **pp
!= '\0');
2569 new_mainlist
->fn_fieldlist
.fn_fields
=
2570 (struct fn_field
*) obstack_alloc (&objfile
-> type_obstack
,
2571 sizeof (struct fn_field
) * length
);
2572 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
2573 new_mainlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
2575 new_mainlist
->fn_fieldlist
.length
= length
;
2576 new_mainlist
->next
= mainlist
;
2577 mainlist
= new_mainlist
;
2579 total_length
+= length
;
2581 while (**pp
!= ';');
2589 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2590 obstack_alloc (&objfile
-> type_obstack
,
2591 sizeof (struct fn_fieldlist
) * nfn_fields
);
2592 TYPE_NFN_FIELDS (type
) = nfn_fields
;
2593 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2598 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
2599 TYPE_NFN_FIELDS_TOTAL (type
) +=
2600 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, i
));
2603 for (n
= nfn_fields
; mainlist
; mainlist
= mainlist
->next
) {
2604 --n
; /* Circumvent Sun3 compiler bug */
2605 TYPE_FN_FIELDLISTS (type
)[n
] = mainlist
->fn_fieldlist
;
2612 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
2614 /* Obsolete flags that used to indicate the presence
2615 of constructors and/or destructors. */
2619 /* Read either a '%' or the final ';'. */
2620 if (*(*pp
)++ == '%')
2622 /* We'd like to be able to derive the vtable pointer field
2623 from the type information, but when it's inherited, that's
2624 hard. A reason it's hard is because we may read in the
2625 info about a derived class before we read in info about
2626 the base class that provides the vtable pointer field.
2627 Once the base info has been read, we could fill in the info
2628 for the derived classes, but for the fact that by then,
2629 we don't remember who needs what. */
2631 int predicted_fieldno
= -1;
2633 /* Now we must record the virtual function table pointer's
2634 field information. */
2642 /* In version 2, we derive the vfield ourselves. */
2643 for (n
= 0; n
< nfields
; n
++)
2645 if (! strncmp (TYPE_FIELD_NAME (type
, n
), vptr_name
,
2646 sizeof (vptr_name
) -1))
2648 predicted_fieldno
= n
;
2652 if (predicted_fieldno
< 0)
2653 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
2654 if (! TYPE_FIELD_VIRTUAL (type
, n
)
2655 && TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
)) >= 0)
2657 predicted_fieldno
= TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
));
2663 t
= read_type (pp
, objfile
);
2665 while (*p
!= '\0' && *p
!= ';')
2668 /* Premature end of symbol. */
2669 return error_type (pp
);
2671 TYPE_VPTR_BASETYPE (type
) = t
;
2674 if (TYPE_FIELD_NAME (t
, TYPE_N_BASECLASSES (t
)) == 0)
2676 /* FIXME-tiemann: what's this? */
2678 TYPE_VPTR_FIELDNO (type
) = i
= TYPE_N_BASECLASSES (t
);
2683 else for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); --i
)
2684 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
2685 sizeof (vptr_name
) -1))
2687 TYPE_VPTR_FIELDNO (type
) = i
;
2691 /* Virtual function table field not found. */
2692 return error_type (pp
);
2695 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2698 if (TYPE_VPTR_FIELDNO (type
) != predicted_fieldno
)
2699 error ("TYPE_VPTR_FIELDNO miscalculated");
2709 /* Read a definition of an array type,
2710 and create and return a suitable type object.
2711 Also creates a range type which represents the bounds of that
2713 static struct type
*
2714 read_array_type (pp
, type
, objfile
)
2716 register struct type
*type
;
2717 struct objfile
*objfile
;
2719 struct type
*index_type
, *element_type
, *range_type
;
2723 /* Format of an array type:
2724 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2727 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2728 for these, produce a type like float[][]. */
2730 index_type
= read_type (pp
, objfile
);
2732 /* Improper format of array type decl. */
2733 return error_type (pp
);
2736 if (!(**pp
>= '0' && **pp
<= '9'))
2741 lower
= read_number (pp
, ';');
2743 if (!(**pp
>= '0' && **pp
<= '9'))
2748 upper
= read_number (pp
, ';');
2750 element_type
= read_type (pp
, objfile
);
2759 /* Create range type. */
2760 range_type
= (struct type
*)
2761 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
2762 bzero (range_type
, sizeof (struct type
));
2763 TYPE_OBJFILE (range_type
) = objfile
;
2764 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
2765 TYPE_TARGET_TYPE (range_type
) = index_type
;
2767 /* This should never be needed. */
2768 TYPE_LENGTH (range_type
) = sizeof (int);
2770 TYPE_NFIELDS (range_type
) = 2;
2771 TYPE_FIELDS (range_type
) =
2772 (struct field
*) obstack_alloc (&objfile
-> type_obstack
,
2773 2 * sizeof (struct field
));
2774 TYPE_FIELD_BITPOS (range_type
, 0) = lower
;
2775 TYPE_FIELD_BITPOS (range_type
, 1) = upper
;
2778 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
2779 TYPE_TARGET_TYPE (type
) = element_type
;
2780 TYPE_LENGTH (type
) = (upper
- lower
+ 1) * TYPE_LENGTH (element_type
);
2781 TYPE_NFIELDS (type
) = 1;
2782 TYPE_FIELDS (type
) =
2783 (struct field
*) obstack_alloc (&objfile
-> type_obstack
,
2784 sizeof (struct field
));
2785 TYPE_FIELD_TYPE (type
, 0) = range_type
;
2787 /* If we have an array whose element type is not yet known, but whose
2788 bounds *are* known, record it to be adjusted at the end of the file. */
2789 if (TYPE_LENGTH (element_type
) == 0 && !adjustable
)
2790 add_undefined_type (type
);
2796 /* Read a definition of an enumeration type,
2797 and create and return a suitable type object.
2798 Also defines the symbols that represent the values of the type. */
2800 static struct type
*
2801 read_enum_type (pp
, type
, objfile
)
2803 register struct type
*type
;
2804 struct objfile
*objfile
;
2809 register struct symbol
*sym
;
2811 struct pending
**symlist
;
2812 struct pending
*osyms
, *syms
;
2815 if (within_function
)
2816 symlist
= &local_symbols
;
2818 symlist
= &file_symbols
;
2820 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2822 /* Read the value-names and their values.
2823 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2824 A semicolon or comma instead of a NAME means the end. */
2825 while (**pp
&& **pp
!= ';' && **pp
!= ',')
2827 /* Check for and handle cretinous dbx symbol name continuation! */
2828 if (**pp
== '\\') *pp
= next_symbol_text ();
2831 while (*p
!= ':') p
++;
2832 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
2834 n
= read_number (pp
, ',');
2836 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2837 bzero (sym
, sizeof (struct symbol
));
2838 SYMBOL_NAME (sym
) = name
;
2839 SYMBOL_CLASS (sym
) = LOC_CONST
;
2840 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2841 SYMBOL_VALUE (sym
) = n
;
2842 add_symbol_to_list (sym
, symlist
);
2847 (*pp
)++; /* Skip the semicolon. */
2849 /* Now fill in the fields of the type-structure. */
2851 TYPE_LENGTH (type
) = sizeof (int);
2852 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2853 TYPE_NFIELDS (type
) = nsyms
;
2854 TYPE_FIELDS (type
) = (struct field
*)
2855 obstack_alloc (&objfile
-> type_obstack
,
2856 sizeof (struct field
) * nsyms
);
2858 /* Find the symbols for the values and put them into the type.
2859 The symbols can be found in the symlist that we put them on
2860 to cause them to be defined. osyms contains the old value
2861 of that symlist; everything up to there was defined by us. */
2862 /* Note that we preserve the order of the enum constants, so
2863 that in something like "enum {FOO, LAST_THING=FOO}" we print
2864 FOO, not LAST_THING. */
2866 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2871 for (; j
< syms
->nsyms
; j
++,n
++)
2873 struct symbol
*xsym
= syms
->symbol
[j
];
2874 SYMBOL_TYPE (xsym
) = type
;
2875 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2876 TYPE_FIELD_VALUE (type
, n
) = 0;
2877 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2878 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2885 /* This screws up perfectly good C programs with enums. FIXME. */
2886 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2887 if(TYPE_NFIELDS(type
) == 2 &&
2888 ((!strcmp(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2889 !strcmp(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2890 (!strcmp(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2891 !strcmp(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2892 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2898 /* Read a number from the string pointed to by *PP.
2899 The value of *PP is advanced over the number.
2900 If END is nonzero, the character that ends the
2901 number must match END, or an error happens;
2902 and that character is skipped if it does match.
2903 If END is zero, *PP is left pointing to that character.
2905 If the number fits in a long, set *VALUE and set *BITS to 0.
2906 If not, set *BITS to be the number of bits in the number.
2908 If encounter garbage, set *BITS to -1. */
2911 read_huge_number (pp
, end
, valu
, bits
)
2932 /* Leading zero means octal. GCC uses this to output values larger
2933 than an int (because that would be hard in decimal). */
2940 upper_limit
= LONG_MAX
/ radix
;
2941 while ((c
= *p
++) >= '0' && c
<= ('0' + radix
))
2943 if (n
<= upper_limit
)
2946 n
+= c
- '0'; /* FIXME this overflows anyway */
2951 /* This depends on large values being output in octal, which is
2958 /* Ignore leading zeroes. */
2962 else if (c
== '2' || c
== '3')
2988 /* Large decimal constants are an error (because it is hard to
2989 count how many bits are in them). */
2995 /* -0x7f is the same as 0x80. So deal with it by adding one to
2996 the number of bits. */
3011 #define MAX_OF_C_TYPE(t) ((1 << (sizeof (t)*8 - 1)) - 1)
3012 #define MIN_OF_C_TYPE(t) (-(1 << (sizeof (t)*8 - 1)))
3014 static struct type
*
3015 read_range_type (pp
, typenums
, objfile
)
3018 struct objfile
*objfile
;
3024 struct type
*result_type
;
3026 /* First comes a type we are a subrange of.
3027 In C it is usually 0, 1 or the type being defined. */
3028 read_type_number (pp
, rangenums
);
3029 self_subrange
= (rangenums
[0] == typenums
[0] &&
3030 rangenums
[1] == typenums
[1]);
3032 /* A semicolon should now follow; skip it. */
3036 /* The remaining two operands are usually lower and upper bounds
3037 of the range. But in some special cases they mean something else. */
3038 read_huge_number (pp
, ';', &n2
, &n2bits
);
3039 read_huge_number (pp
, ';', &n3
, &n3bits
);
3041 if (n2bits
== -1 || n3bits
== -1)
3042 return error_type (pp
);
3044 /* If limits are huge, must be large integral type. */
3045 if (n2bits
!= 0 || n3bits
!= 0)
3047 char got_signed
= 0;
3048 char got_unsigned
= 0;
3049 /* Number of bits in the type. */
3052 /* Range from 0 to <large number> is an unsigned large integral type. */
3053 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
3058 /* Range from <large number> to <large number>-1 is a large signed
3060 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
3066 /* Check for "long long". */
3067 if (got_signed
&& nbits
== TARGET_LONG_LONG_BIT
)
3068 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
3069 if (got_unsigned
&& nbits
== TARGET_LONG_LONG_BIT
)
3070 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
3072 if (got_signed
|| got_unsigned
)
3074 result_type
= (struct type
*)
3075 obstack_alloc (&objfile
-> type_obstack
,
3076 sizeof (struct type
));
3077 bzero (result_type
, sizeof (struct type
));
3078 TYPE_OBJFILE (result_type
) = objfile
;
3079 TYPE_LENGTH (result_type
) = nbits
/ TARGET_CHAR_BIT
;
3080 TYPE_CODE (result_type
) = TYPE_CODE_INT
;
3082 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
3086 return error_type (pp
);
3089 /* A type defined as a subrange of itself, with bounds both 0, is void. */
3090 if (self_subrange
&& n2
== 0 && n3
== 0)
3091 return (lookup_fundamental_type (objfile
, FT_VOID
));
3093 /* If n3 is zero and n2 is not, we want a floating type,
3094 and n2 is the width in bytes.
3096 Fortran programs appear to use this for complex types also,
3097 and they give no way to distinguish between double and single-complex!
3098 We don't have complex types, so we would lose on all fortran files!
3099 So return type `double' for all of those. It won't work right
3100 for the complex values, but at least it makes the file loadable.
3102 FIXME, we may be able to distinguish these by their names. FIXME. */
3104 if (n3
== 0 && n2
> 0)
3106 if (n2
== sizeof (float))
3107 return (lookup_fundamental_type (objfile
, FT_FLOAT
));
3108 return (lookup_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
));
3111 /* If the upper bound is -1, it must really be an unsigned int. */
3113 else if (n2
== 0 && n3
== -1)
3115 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
3116 long' is to look at its name! */
3118 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
3119 long_kludge_name
[9] == 'l' /* long */)
3120 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
3121 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
3123 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
3126 /* Special case: char is defined (Who knows why) as a subrange of
3127 itself with range 0-127. */
3128 else if (self_subrange
&& n2
== 0 && n3
== 127)
3129 return (lookup_fundamental_type (objfile
, FT_CHAR
));
3131 /* Assumptions made here: Subrange of self is equivalent to subrange
3132 of int. FIXME: Host and target type-sizes assumed the same. */
3133 /* FIXME: This is the *only* place in GDB that depends on comparing
3134 some type to a builtin type with ==. Fix it! */
3136 && (self_subrange
||
3137 *dbx_lookup_type (rangenums
) == lookup_fundamental_type (objfile
, FT_INTEGER
)))
3139 /* an unsigned type */
3141 if (n3
== - sizeof (long long))
3142 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
3144 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
3145 long' is to look at its name! */
3146 if (n3
== (unsigned long)~0L &&
3147 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
3148 long_kludge_name
[9] == 'l' /* long */)
3149 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
3150 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
3151 if (n3
== (unsigned int)~0L)
3152 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
3153 if (n3
== (unsigned short)~0L)
3154 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_SHORT
));
3155 if (n3
== (unsigned char)~0L)
3156 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_CHAR
));
3159 else if (n3
== 0 && n2
== -sizeof (long long))
3160 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
3162 else if (n2
== -n3
-1)
3165 /* FIXME -- the only way to distinguish `int' from `long' is to look
3167 if ((n3
== (1 << (8 * sizeof (long) - 1)) - 1) &&
3168 long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
3169 return (lookup_fundamental_type (objfile
, FT_LONG
));
3170 if (n3
== (1 << (8 * sizeof (int) - 1)) - 1)
3171 return (lookup_fundamental_type (objfile
, FT_INTEGER
));
3172 if (n3
== (1 << (8 * sizeof (short) - 1)) - 1)
3173 return (lookup_fundamental_type (objfile
, FT_SHORT
));
3174 if (n3
== (1 << (8 * sizeof (char) - 1)) - 1)
3175 return (lookup_fundamental_type (objfile
, FT_CHAR
));
3178 /* We have a real range type on our hands. Allocate space and
3179 return a real pointer. */
3181 /* At this point I don't have the faintest idea how to deal with
3182 a self_subrange type; I'm going to assume that this is used
3183 as an idiom, and that all of them are special cases. So . . . */
3185 return error_type (pp
);
3187 result_type
= (struct type
*)
3188 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
3189 bzero (result_type
, sizeof (struct type
));
3190 TYPE_OBJFILE (result_type
) = objfile
;
3192 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
3194 TYPE_TARGET_TYPE (result_type
) = *dbx_lookup_type(rangenums
);
3195 if (TYPE_TARGET_TYPE (result_type
) == 0) {
3196 complain (&range_type_base_complaint
, (char *) rangenums
[1]);
3197 TYPE_TARGET_TYPE (result_type
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
3200 TYPE_NFIELDS (result_type
) = 2;
3201 TYPE_FIELDS (result_type
) =
3202 (struct field
*) obstack_alloc (&objfile
-> type_obstack
,
3203 2 * sizeof (struct field
));
3204 bzero (TYPE_FIELDS (result_type
), 2 * sizeof (struct field
));
3205 TYPE_FIELD_BITPOS (result_type
, 0) = n2
;
3206 TYPE_FIELD_BITPOS (result_type
, 1) = n3
;
3208 TYPE_LENGTH (result_type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type
));
3213 /* Read a number from the string pointed to by *PP.
3214 The value of *PP is advanced over the number.
3215 If END is nonzero, the character that ends the
3216 number must match END, or an error happens;
3217 and that character is skipped if it does match.
3218 If END is zero, *PP is left pointing to that character. */
3221 read_number (pp
, end
)
3225 register char *p
= *pp
;
3226 register long n
= 0;
3230 /* Handle an optional leading minus sign. */
3238 /* Read the digits, as far as they go. */
3240 while ((c
= *p
++) >= '0' && c
<= '9')
3248 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c
, symnum
);
3257 /* Read in an argument list. This is a list of types, separated by commas
3258 and terminated with END. Return the list of types read in, or (struct type
3259 **)-1 if there is an error. */
3260 static struct type
**
3261 read_args (pp
, end
, objfile
)
3264 struct objfile
*objfile
;
3266 /* FIXME! Remove this arbitrary limit! */
3267 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
3273 /* Invalid argument list: no ','. */
3274 return (struct type
**)-1;
3277 /* Check for and handle cretinous dbx symbol name continuation! */
3279 *pp
= next_symbol_text ();
3281 types
[n
++] = read_type (pp
, objfile
);
3283 *pp
+= 1; /* get past `end' (the ':' character) */
3287 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
3289 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
3291 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
3292 bzero (rval
+ n
, sizeof (struct type
*));
3296 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
3298 memcpy (rval
, types
, n
* sizeof (struct type
*));
3302 /* Add a common block's start address to the offset of each symbol
3303 declared to be in it (by being between a BCOMM/ECOMM pair that uses
3304 the common block name). */
3307 fix_common_block (sym
, valu
)
3311 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
3312 for ( ; next
; next
= next
->next
)
3315 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
3316 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
3320 /* Initializer for this module */
3322 _initialize_buildsym ()
3324 undef_types_allocated
= 20;
3325 undef_types_length
= 0;
3326 undef_types
= (struct type
**) xmalloc (undef_types_allocated
*
3327 sizeof (struct type
*));