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 */
679 file_stabs
= 0; /* AIX COFF */
682 /* Context stack is initially empty. Allocate first one with room for
683 10 levels; reuse it forever afterward. */
684 if (context_stack
== 0) {
685 context_stack_size
= INITIAL_CONTEXT_STACK_SIZE
;
686 context_stack
= (struct context_stack
*)
687 xmalloc (context_stack_size
* sizeof (struct context_stack
));
689 context_stack_depth
= 0;
691 /* Leave FILENUM of 0 free for builtin types and this file's types. */
692 n_this_object_header_files
= 1;
693 header_file_prev_index
= -1;
695 type_vector_length
= 0;
696 type_vector
= (struct type
**) 0;
698 /* Initialize the list of sub source files with one entry
699 for this file (the top-level source file). */
703 start_subfile (name
, dirname
);
706 /* for all the stabs in a given stab vector, build appropriate types
707 and fix their symbols in given symbol vector. */
710 patch_block_stabs (symbols
, stabs
, objfile
)
711 struct pending
*symbols
;
712 struct pending_stabs
*stabs
;
713 struct objfile
*objfile
;
720 /* for all the stab entries, find their corresponding symbols and
721 patch their types! */
723 for (ii
= 0; ii
< stabs
->count
; ++ii
)
725 char *name
= stabs
->stab
[ii
];
726 char *pp
= (char*) strchr (name
, ':');
727 struct symbol
*sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
730 printf ("ERROR! stab symbol not found!\n"); /* FIXME */
735 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
738 lookup_function_type (read_type (&pp
, objfile
));
742 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
749 /* Finish the symbol definitions for one main source file,
750 close off all the lexical contexts for that file
751 (creating struct block's for them), then make the struct symtab
752 for that file and put it in the list of all such.
754 END_ADDR is the address of the end of the file's text. */
757 end_symtab (end_addr
, sort_pending
, sort_linevec
, objfile
)
761 struct objfile
*objfile
;
763 register struct symtab
*symtab
;
764 register struct blockvector
*blockvector
;
765 register struct subfile
*subfile
;
766 struct subfile
*nextsub
;
768 /* Finish the lexical context of the last function in the file;
769 pop the context stack. */
771 if (context_stack_depth
> 0)
773 register struct context_stack
*cstk
;
774 context_stack_depth
--;
775 cstk
= &context_stack
[context_stack_depth
];
776 /* Make a block for the local symbols within. */
777 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
778 cstk
->start_addr
, end_addr
, objfile
);
780 /* Debug: if context stack still has something in it, we are in
782 if (context_stack_depth
> 0)
786 /* It is unfortunate that in aixcoff, pending blocks might not be ordered
787 in this stage. Especially, blocks for static functions will show up at
788 the end. We need to sort them, so tools like `find_pc_function' and
789 `find_pc_block' can work reliably. */
790 if (sort_pending
&& pending_blocks
) {
791 /* FIXME! Remove this horrid bubble sort and use qsort!!! */
794 struct pending_block
*pb
, *pbnext
;
796 pb
= pending_blocks
, pbnext
= pb
->next
;
801 /* swap blocks if unordered! */
803 if (BLOCK_START(pb
->block
) < BLOCK_START(pbnext
->block
)) {
804 struct block
*tmp
= pb
->block
;
805 pb
->block
= pbnext
->block
;
810 pbnext
= pbnext
->next
;
815 /* Cleanup any undefined types that have been left hanging around
816 (this needs to be done before the finish_blocks so that
817 file_symbols is still good). */
818 cleanup_undefined_types ();
820 /* Hooks for xcoffread.c */
822 patch_block_stabs (file_symbols
, file_stabs
, objfile
);
828 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
833 if (pending_blocks
== 0
835 && global_symbols
== 0) {
836 /* Ignore symtabs that have no functions with real debugging info */
839 /* Define the STATIC_BLOCK and GLOBAL_BLOCK, and build the blockvector. */
840 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
, objfile
);
841 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
, objfile
);
842 blockvector
= make_blockvector (objfile
);
845 /* Now create the symtab objects proper, one for each subfile. */
846 /* (The main file is the last one on the chain.) */
848 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
851 /* If we have blocks of symbols, make a symtab.
852 Otherwise, just ignore this file and any line number info in it. */
855 if (subfile
->line_vector
) {
856 /* First, shrink the linetable to make more memory. */
857 linetablesize
= sizeof (struct linetable
) +
858 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
859 subfile
->line_vector
= (struct linetable
*)
860 xrealloc ((char *) subfile
->line_vector
, linetablesize
);
863 qsort (subfile
->line_vector
->item
, subfile
->line_vector
->nitems
,
864 sizeof (struct linetable_entry
), compare_line_numbers
);
867 /* Now, allocate a symbol table. */
868 symtab
= allocate_symtab (subfile
->name
, objfile
);
870 /* Fill in its components. */
871 symtab
->blockvector
= blockvector
;
872 if (subfile
->line_vector
)
874 /* Reallocate the line table on the symbol obstack */
875 symtab
->linetable
= (struct linetable
*)
876 obstack_alloc (&objfile
-> symbol_obstack
, linetablesize
);
877 memcpy (symtab
->linetable
, subfile
->line_vector
, linetablesize
);
881 symtab
->linetable
= NULL
;
883 symtab
->dirname
= subfile
->dirname
;
884 symtab
->free_code
= free_linetable
;
885 symtab
->free_ptr
= 0;
887 if (subfile
->line_vector
)
888 free (subfile
->line_vector
);
890 nextsub
= subfile
->next
;
895 free ((char *) type_vector
);
897 type_vector_length
= 0;
899 last_source_file
= 0;
901 previous_stab_code
= 0;
907 /* Push a context block. Args are an identifying nesting level (checkable
908 when you pop it), and the starting PC address of this context. */
910 struct context_stack
*
911 push_context (desc
, valu
)
915 register struct context_stack
*new;
917 if (context_stack_depth
== context_stack_size
)
919 context_stack_size
*= 2;
920 context_stack
= (struct context_stack
*)
921 xrealloc ((char *) context_stack
,
922 (context_stack_size
* sizeof (struct context_stack
)));
925 new = &context_stack
[context_stack_depth
++];
927 new->locals
= local_symbols
;
928 new->old_blocks
= pending_blocks
;
929 new->start_addr
= valu
;
937 /* Initialize anything that needs initializing when starting to read
938 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
950 /* Initialize anything that needs initializing when a completely new
951 symbol file is specified (not just adding some symbols from another
952 file, e.g. a shared library). */
957 /* Empty the hash table of global syms looking for values. */
958 bzero (global_sym_chain
, sizeof global_sym_chain
);
963 /* Scan through all of the global symbols defined in the object file,
964 assigning values to the debugging symbols that need to be assigned
965 to. Get these symbols from the minimal symbol table. */
968 scan_file_globals (objfile
)
969 struct objfile
*objfile
;
972 struct minimal_symbol
*msymbol
;
973 struct symbol
*sym
, *prev
;
975 for (msymbol
= objfile
-> msymbols
; msymbol
-> name
!= NULL
; msymbol
++)
979 prev
= (struct symbol
*) 0;
981 /* Get the hash index and check all the symbols
982 under that hash index. */
984 hash
= hashname (msymbol
-> name
);
986 for (sym
= global_sym_chain
[hash
]; sym
;)
988 if (*(msymbol
-> name
) == SYMBOL_NAME (sym
)[0]
989 && !strcmp(msymbol
-> name
+ 1, SYMBOL_NAME (sym
) + 1))
991 /* Splice this symbol out of the hash chain and
992 assign the value we have to it. */
994 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
996 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
998 /* Check to see whether we need to fix up a common block. */
999 /* Note: this code might be executed several times for
1000 the same symbol if there are multiple references. */
1001 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1002 fix_common_block (sym
, msymbol
-> address
);
1004 SYMBOL_VALUE_ADDRESS (sym
) = msymbol
-> address
;
1007 sym
= SYMBOL_VALUE_CHAIN (prev
);
1009 sym
= global_sym_chain
[hash
];
1014 sym
= SYMBOL_VALUE_CHAIN (sym
);
1021 /* Read a number by which a type is referred to in dbx data,
1022 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
1023 Just a single number N is equivalent to (0,N).
1024 Return the two numbers by storing them in the vector TYPENUMS.
1025 TYPENUMS will then be used as an argument to dbx_lookup_type. */
1028 read_type_number (pp
, typenums
)
1030 register int *typenums
;
1035 typenums
[0] = read_number (pp
, ',');
1036 typenums
[1] = read_number (pp
, ')');
1041 typenums
[1] = read_number (pp
, 0);
1045 /* To handle GNU C++ typename abbreviation, we need to be able to
1046 fill in a type's name as soon as space for that type is allocated.
1047 `type_synonym_name' is the name of the type being allocated.
1048 It is cleared as soon as it is used (lest all allocated types
1050 static char *type_synonym_name
;
1054 define_symbol (valu
, string
, desc
, type
, objfile
)
1059 struct objfile
*objfile
;
1061 register struct symbol
*sym
;
1062 char *p
= (char *) strchr (string
, ':');
1066 struct type
*temptype
;
1068 /* Ignore syms with empty names. */
1072 /* Ignore old-style symbols from cc -go */
1076 sym
= (struct symbol
*)obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1078 if (processing_gcc_compilation
) {
1079 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
1080 number of bytes occupied by a type or object, which we ignore. */
1081 SYMBOL_LINE(sym
) = desc
;
1083 SYMBOL_LINE(sym
) = 0; /* unknown */
1086 if (string
[0] == CPLUS_MARKER
)
1088 /* Special GNU C++ names. */
1092 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
1093 &objfile
-> symbol_obstack
);
1095 case 'v': /* $vtbl_ptr_type */
1096 /* Was: SYMBOL_NAME (sym) = "vptr"; */
1099 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
1100 &objfile
-> symbol_obstack
);
1104 /* This was an anonymous type that was never fixed up. */
1115 = (char *) obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
1116 /* Open-coded bcopy--saves function call time. */
1118 register char *p1
= string
;
1119 register char *p2
= SYMBOL_NAME (sym
);
1126 /* Determine the type of name being defined. */
1127 /* The Acorn RISC machine's compiler can put out locals that don't
1128 start with "234=" or "(3,4)=", so assume anything other than the
1129 deftypes we know how to handle is a local. */
1130 /* (Peter Watkins @ Computervision)
1131 Handle Sun-style local fortran array types 'ar...' .
1132 (gnu@cygnus.com) -- this strchr() handles them properly?
1133 (tiemann@cygnus.com) -- 'C' is for catch. */
1134 if (!strchr ("cfFGpPrStTvVXC", *p
))
1139 /* c is a special case, not followed by a type-number.
1140 SYMBOL:c=iVALUE for an integer constant symbol.
1141 SYMBOL:c=rVALUE for a floating constant symbol.
1142 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1143 e.g. "b:c=e6,0" for "const b = blob1"
1144 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1148 error ("Invalid symbol data at symtab pos %d.", symnum
);
1153 double d
= atof (p
);
1156 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1159 obstack_alloc (&objfile
-> type_obstack
,
1161 memcpy (dbl_valu
, &d
, sizeof (double));
1162 SWAP_TARGET_AND_HOST (dbl_valu
, sizeof (double));
1163 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
1164 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
1169 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1171 SYMBOL_VALUE (sym
) = atoi (p
);
1172 SYMBOL_CLASS (sym
) = LOC_CONST
;
1176 /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1177 e.g. "b:c=e6,0" for "const b = blob1"
1178 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1182 read_type_number (&p
, typenums
);
1184 error ("Invalid symbol data: no comma in enum const symbol");
1186 SYMBOL_TYPE (sym
) = *dbx_lookup_type (typenums
);
1187 SYMBOL_VALUE (sym
) = atoi (p
);
1188 SYMBOL_CLASS (sym
) = LOC_CONST
;
1192 error ("Invalid symbol data at symtab pos %d.", symnum
);
1194 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1195 add_symbol_to_list (sym
, &file_symbols
);
1199 /* Now usually comes a number that says which data type,
1200 and possibly more stuff to define the type
1201 (all of which is handled by read_type) */
1203 if (deftype
== 'p' && *p
== 'F')
1204 /* pF is a two-letter code that means a function parameter in Fortran.
1205 The type-number specifies the type of the return value.
1206 Translate it into a pointer-to-function type. */
1210 = lookup_pointer_type (lookup_function_type (read_type (&p
, objfile
)));
1214 struct type
*type_read
;
1215 synonym
= *p
== 't';
1220 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
1221 strlen (SYMBOL_NAME (sym
)),
1222 &objfile
-> symbol_obstack
);
1225 /* Here we save the name of the symbol for read_range_type, which
1226 ends up reading in the basic types. In stabs, unfortunately there
1227 is no distinction between "int" and "long" types except their
1228 names. Until we work out a saner type policy (eliminating most
1229 builtin types and using the names specified in the files), we
1230 save away the name so that far away from here in read_range_type,
1231 we can examine it to decide between "int" and "long". FIXME. */
1232 long_kludge_name
= SYMBOL_NAME (sym
);
1233 type_read
= read_type (&p
, objfile
);
1235 if ((deftype
== 'F' || deftype
== 'f')
1236 && TYPE_CODE (type_read
) != TYPE_CODE_FUNC
)
1239 /* This code doesn't work -- it needs to realloc and can't. */
1240 struct type
*new = (struct type
*)
1241 obstack_alloc (&objfile
-> type_obstack
,
1242 sizeof (struct type
));
1244 /* Generate a template for the type of this function. The
1245 types of the arguments will be added as we read the symbol
1247 *new = *lookup_function_type (type_read
);
1248 SYMBOL_TYPE(sym
) = new;
1249 TYPE_OBJFILE (new) = objfile
;
1250 in_function_type
= new;
1252 SYMBOL_TYPE (sym
) = lookup_function_type (type_read
);
1256 SYMBOL_TYPE (sym
) = type_read
;
1262 /* The name of a caught exception. */
1263 SYMBOL_CLASS (sym
) = LOC_LABEL
;
1264 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1265 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1266 add_symbol_to_list (sym
, &local_symbols
);
1270 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1271 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1272 add_symbol_to_list (sym
, &file_symbols
);
1276 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1277 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1278 add_symbol_to_list (sym
, &global_symbols
);
1282 /* For a class G (global) symbol, it appears that the
1283 value is not correct. It is necessary to search for the
1284 corresponding linker definition to find the value.
1285 These definitions appear at the end of the namelist. */
1286 i
= hashname (SYMBOL_NAME (sym
));
1287 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1288 global_sym_chain
[i
] = sym
;
1289 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1290 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1291 add_symbol_to_list (sym
, &global_symbols
);
1294 /* This case is faked by a conditional above,
1295 when there is no code letter in the dbx data.
1296 Dbx data never actually contains 'l'. */
1298 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1299 SYMBOL_VALUE (sym
) = valu
;
1300 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1301 add_symbol_to_list (sym
, &local_symbols
);
1305 /* Normally this is a parameter, a LOC_ARG. On the i960, it
1306 can also be a LOC_LOCAL_ARG depending on symbol type. */
1307 #ifndef DBX_PARM_SYMBOL_CLASS
1308 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
1310 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
1311 SYMBOL_VALUE (sym
) = valu
;
1312 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1314 /* This doesn't work yet. */
1315 add_param_to_type (&in_function_type
, sym
);
1317 add_symbol_to_list (sym
, &local_symbols
);
1319 /* If it's gcc-compiled, if it says `short', believe it. */
1320 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
1323 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
1324 /* This macro is defined on machines (e.g. sparc) where
1325 we should believe the type of a PCC 'short' argument,
1326 but shouldn't believe the address (the address is
1327 the address of the corresponding int). Note that
1328 this is only different from the BELIEVE_PCC_PROMOTION
1329 case on big-endian machines.
1331 My guess is that this correction, as opposed to changing
1332 the parameter to an 'int' (as done below, for PCC
1333 on most machines), is the right thing to do
1334 on all machines, but I don't want to risk breaking
1335 something that already works. On most PCC machines,
1336 the sparc problem doesn't come up because the calling
1337 function has to zero the top bytes (not knowing whether
1338 the called function wants an int or a short), so there
1339 is no practical difference between an int and a short
1340 (except perhaps what happens when the GDB user types
1341 "print short_arg = 0x10000;").
1343 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
1344 actually produces the correct address (we don't need to fix it
1345 up). I made this code adapt so that it will offset the symbol
1346 if it was pointing at an int-aligned location and not
1347 otherwise. This way you can use the same gdb for 4.0.x and
1350 If the parameter is shorter than an int, and is integral
1351 (e.g. char, short, or unsigned equivalent), and is claimed to
1352 be passed on an integer boundary, don't believe it! Offset the
1353 parameter's address to the tail-end of that integer. */
1355 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
1356 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1357 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1358 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1360 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
1361 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1365 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
1367 /* If PCC says a parameter is a short or a char,
1368 it is really an int. */
1369 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
1370 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1371 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1373 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1374 ? lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
)
1379 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
1382 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1383 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1384 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1385 add_symbol_to_list (sym
, &local_symbols
);
1389 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1390 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1391 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1392 add_symbol_to_list (sym
, &local_symbols
);
1396 /* Static symbol at top level of file */
1397 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1398 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1399 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1400 add_symbol_to_list (sym
, &file_symbols
);
1404 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1405 SYMBOL_VALUE (sym
) = valu
;
1406 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1407 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1408 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1409 obsavestring (SYMBOL_NAME (sym
),
1410 strlen (SYMBOL_NAME (sym
)),
1411 &objfile
-> symbol_obstack
);
1412 /* C++ vagaries: we may have a type which is derived from
1413 a base type which did not have its name defined when the
1414 derived class was output. We fill in the derived class's
1415 base part member's name here in that case. */
1416 else if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1417 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1418 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1421 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1422 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1423 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1424 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1427 add_symbol_to_list (sym
, &file_symbols
);
1431 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1432 SYMBOL_VALUE (sym
) = valu
;
1433 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1434 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1435 TYPE_NAME (SYMBOL_TYPE (sym
))
1436 = obconcat (&objfile
-> type_obstack
, "",
1437 (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_ENUM
1439 : (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1440 ? "struct " : "union ")),
1442 add_symbol_to_list (sym
, &file_symbols
);
1446 register struct symbol
*typedef_sym
= (struct symbol
*)
1447 obstack_alloc (&objfile
-> type_obstack
,
1448 sizeof (struct symbol
));
1449 SYMBOL_NAME (typedef_sym
) = SYMBOL_NAME (sym
);
1450 SYMBOL_TYPE (typedef_sym
) = SYMBOL_TYPE (sym
);
1452 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1453 SYMBOL_VALUE (typedef_sym
) = valu
;
1454 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
1455 add_symbol_to_list (typedef_sym
, &file_symbols
);
1460 /* Static symbol of local scope */
1461 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1462 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1463 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1464 add_symbol_to_list (sym
, &local_symbols
);
1468 /* Reference parameter */
1469 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
1470 SYMBOL_VALUE (sym
) = valu
;
1471 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1472 add_symbol_to_list (sym
, &local_symbols
);
1476 /* This is used by Sun FORTRAN for "function result value".
1477 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1478 that Pascal uses it too, but when I tried it Pascal used
1479 "x:3" (local symbol) instead. */
1480 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1481 SYMBOL_VALUE (sym
) = valu
;
1482 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1483 add_symbol_to_list (sym
, &local_symbols
);
1487 error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype
, symnum
);
1492 /* What about types defined as forward references inside of a small lexical
1494 /* Add a type to the list of undefined types to be checked through
1495 once this file has been read in. */
1497 add_undefined_type (type
)
1500 if (undef_types_length
== undef_types_allocated
)
1502 undef_types_allocated
*= 2;
1503 undef_types
= (struct type
**)
1504 xrealloc ((char *) undef_types
,
1505 undef_types_allocated
* sizeof (struct type
*));
1507 undef_types
[undef_types_length
++] = type
;
1510 /* Go through each undefined type, see if it's still undefined, and fix it
1511 up if possible. We have two kinds of undefined types:
1513 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
1514 Fix: update array length using the element bounds
1515 and the target type's length.
1516 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
1517 yet defined at the time a pointer to it was made.
1518 Fix: Do a full lookup on the struct/union tag. */
1520 cleanup_undefined_types ()
1524 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++) {
1525 switch (TYPE_CODE (*type
)) {
1527 case TYPE_CODE_STRUCT
:
1528 case TYPE_CODE_UNION
:
1529 case TYPE_CODE_ENUM
:
1531 /* Reasonable test to see if it's been defined since. */
1532 if (TYPE_NFIELDS (*type
) == 0)
1534 struct pending
*ppt
;
1536 /* Name of the type, without "struct" or "union" */
1537 char *typename
= TYPE_NAME (*type
);
1539 if (!strncmp (typename
, "struct ", 7))
1541 if (!strncmp (typename
, "union ", 6))
1543 if (!strncmp (typename
, "enum ", 5))
1546 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1547 for (i
= 0; i
< ppt
->nsyms
; i
++)
1549 struct symbol
*sym
= ppt
->symbol
[i
];
1551 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1552 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1553 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
1555 && !strcmp (SYMBOL_NAME (sym
), typename
))
1556 memcpy (*type
, SYMBOL_TYPE (sym
), sizeof (struct type
));
1560 /* It has been defined; don't mark it as a stub. */
1561 TYPE_FLAGS (*type
) &= ~TYPE_FLAG_STUB
;
1565 case TYPE_CODE_ARRAY
:
1567 struct type
*range_type
;
1570 if (TYPE_LENGTH (*type
) != 0) /* Better be unknown */
1572 if (TYPE_NFIELDS (*type
) != 1)
1574 range_type
= TYPE_FIELD_TYPE (*type
, 0);
1575 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
1578 /* Now recompute the length of the array type, based on its
1579 number of elements and the target type's length. */
1580 lower
= TYPE_FIELD_BITPOS (range_type
, 0);
1581 upper
= TYPE_FIELD_BITPOS (range_type
, 1);
1582 TYPE_LENGTH (*type
) = (upper
- lower
+ 1)
1583 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type
));
1589 error ("GDB internal error. cleanup_undefined_types with bad\
1590 type %d.", TYPE_CODE (*type
));
1594 undef_types_length
= 0;
1597 /* Skip rest of this symbol and return an error type.
1599 General notes on error recovery: error_type always skips to the
1600 end of the symbol (modulo cretinous dbx symbol name continuation).
1601 Thus code like this:
1603 if (*(*pp)++ != ';')
1604 return error_type (pp);
1606 is wrong because if *pp starts out pointing at '\0' (typically as the
1607 result of an earlier error), it will be incremented to point to the
1608 start of the next symbol, which might produce strange results, at least
1609 if you run off the end of the string table. Instead use
1612 return error_type (pp);
1618 foo = error_type (pp);
1622 And in case it isn't obvious, the point of all this hair is so the compiler
1623 can define new types and new syntaxes, and old versions of the
1624 debugger will be able to read the new symbol tables. */
1630 complain (&error_type_complaint
, 0);
1633 /* Skip to end of symbol. */
1634 while (**pp
!= '\0')
1637 /* Check for and handle cretinous dbx symbol name continuation! */
1638 if ((*pp
)[-1] == '\\')
1639 *pp
= next_symbol_text ();
1643 return builtin_type_error
;
1646 /* Read a dbx type reference or definition;
1647 return the type that is meant.
1648 This can be just a number, in which case it references
1649 a type already defined and placed in type_vector.
1650 Or the number can be followed by an =, in which case
1651 it means to define a new type according to the text that
1655 read_type (pp
, objfile
)
1657 struct objfile
*objfile
;
1659 register struct type
*type
= 0;
1664 /* Read type number if present. The type number may be omitted.
1665 for instance in a two-dimensional array declared with type
1666 "ar1;1;10;ar1;1;10;4". */
1667 if ((**pp
>= '0' && **pp
<= '9')
1670 read_type_number (pp
, typenums
);
1672 /* Type is not being defined here. Either it already exists,
1673 or this is a forward reference to it. dbx_alloc_type handles
1676 return dbx_alloc_type (typenums
, objfile
);
1678 /* Type is being defined here. */
1679 #if 0 /* Callers aren't prepared for a NULL result! FIXME -- metin! */
1683 /* if such a type already exists, this is an unnecessary duplication
1684 of the stab string, which is common in (RS/6000) xlc generated
1685 objects. In that case, simply return NULL and let the caller take
1688 tt
= *dbx_lookup_type (typenums
);
1689 if (tt
&& tt
->length
&& tt
->code
)
1698 /* 'typenums=' not present, type is anonymous. Read and return
1699 the definition, but don't put it in the type vector. */
1700 typenums
[0] = typenums
[1] = -1;
1708 enum type_code code
;
1710 /* Used to index through file_symbols. */
1711 struct pending
*ppt
;
1714 /* Name including "struct", etc. */
1717 /* Name without "struct", etc. */
1718 char *type_name_only
;
1724 /* Set the type code according to the following letter. */
1728 code
= TYPE_CODE_STRUCT
;
1732 code
= TYPE_CODE_UNION
;
1736 code
= TYPE_CODE_ENUM
;
1740 return error_type (pp
);
1743 to
= type_name
= (char *)
1744 obstack_alloc (&objfile
-> type_obstack
,
1746 ((char *) strchr (*pp
, ':') - (*pp
)) + 1));
1748 /* Copy the prefix. */
1750 while (*to
++ = *from
++)
1754 type_name_only
= to
;
1756 /* Copy the name. */
1758 while ((*to
++ = *from
++) != ':')
1762 /* Set the pointer ahead of the name which we just read. */
1766 /* The following hack is clearly wrong, because it doesn't
1767 check whether we are in a baseclass. I tried to reproduce
1768 the case that it is trying to fix, but I couldn't get
1769 g++ to put out a cross reference to a basetype. Perhaps
1770 it doesn't do it anymore. */
1771 /* Note: for C++, the cross reference may be to a base type which
1772 has not yet been seen. In this case, we skip to the comma,
1773 which will mark the end of the base class name. (The ':'
1774 at the end of the base class name will be skipped as well.)
1775 But sometimes (ie. when the cross ref is the last thing on
1776 the line) there will be no ','. */
1777 from
= (char *) strchr (*pp
, ',');
1783 /* Now check to see whether the type has already been declared. */
1784 /* This is necessary at least in the case where the
1785 program says something like
1787 The compiler puts out a cross-reference; we better find
1788 set the length of the structure correctly so we can
1789 set the length of the array. */
1790 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1791 for (i
= 0; i
< ppt
->nsyms
; i
++)
1793 struct symbol
*sym
= ppt
->symbol
[i
];
1795 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1796 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1797 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
1798 && !strcmp (SYMBOL_NAME (sym
), type_name_only
))
1800 obstack_free (&objfile
-> type_obstack
, type_name
);
1801 type
= SYMBOL_TYPE (sym
);
1806 /* Didn't find the type to which this refers, so we must
1807 be dealing with a forward reference. Allocate a type
1808 structure for it, and keep track of it so we can
1809 fill in the rest of the fields when we get the full
1811 type
= dbx_alloc_type (typenums
, objfile
);
1812 TYPE_CODE (type
) = code
;
1813 TYPE_NAME (type
) = type_name
;
1814 INIT_CPLUS_SPECIFIC(type
);
1815 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1817 add_undefined_type (type
);
1821 case '-': /* RS/6000 built-in type */
1823 type
= builtin_type (pp
); /* (in xcoffread.c) */
1838 read_type_number (pp
, xtypenums
);
1839 type
= *dbx_lookup_type (xtypenums
);
1844 type
= lookup_fundamental_type (objfile
, FT_VOID
);
1845 if (typenums
[0] != -1)
1846 *dbx_lookup_type (typenums
) = type
;
1850 type1
= read_type (pp
, objfile
);
1851 /* FIXME -- we should be doing smash_to_XXX types here. */
1853 /* postponed type decoration should be allowed. */
1854 if (typenums
[1] > 0 && typenums
[1] < type_vector_length
&&
1855 (type
= type_vector
[typenums
[1]])) {
1856 smash_to_pointer_type (type
, type1
);
1860 type
= lookup_pointer_type (type1
);
1861 if (typenums
[0] != -1)
1862 *dbx_lookup_type (typenums
) = type
;
1867 struct type
*domain
= read_type (pp
, objfile
);
1868 struct type
*memtype
;
1871 /* Invalid member type data format. */
1872 return error_type (pp
);
1875 memtype
= read_type (pp
, objfile
);
1876 type
= dbx_alloc_type (typenums
, objfile
);
1877 smash_to_member_type (type
, domain
, memtype
);
1882 if ((*pp
)[0] == '#')
1884 /* We'll get the parameter types from the name. */
1885 struct type
*return_type
;
1888 return_type
= read_type (pp
, objfile
);
1889 if (*(*pp
)++ != ';')
1890 complain (&invalid_member_complaint
, (char *) symnum
);
1891 type
= allocate_stub_method (return_type
);
1892 if (typenums
[0] != -1)
1893 *dbx_lookup_type (typenums
) = type
;
1897 struct type
*domain
= read_type (pp
, objfile
);
1898 struct type
*return_type
;
1901 if (*(*pp
)++ != ',')
1902 error ("invalid member type data format, at symtab pos %d.",
1905 return_type
= read_type (pp
, objfile
);
1906 args
= read_args (pp
, ';', objfile
);
1907 type
= dbx_alloc_type (typenums
, objfile
);
1908 smash_to_method_type (type
, domain
, return_type
, args
);
1913 type1
= read_type (pp
, objfile
);
1914 type
= lookup_reference_type (type1
);
1915 if (typenums
[0] != -1)
1916 *dbx_lookup_type (typenums
) = type
;
1920 type1
= read_type (pp
, objfile
);
1921 type
= lookup_function_type (type1
);
1922 if (typenums
[0] != -1)
1923 *dbx_lookup_type (typenums
) = type
;
1927 type
= read_range_type (pp
, typenums
, objfile
);
1928 if (typenums
[0] != -1)
1929 *dbx_lookup_type (typenums
) = type
;
1933 type
= dbx_alloc_type (typenums
, objfile
);
1934 type
= read_enum_type (pp
, type
, objfile
);
1935 *dbx_lookup_type (typenums
) = type
;
1939 type
= dbx_alloc_type (typenums
, objfile
);
1940 TYPE_NAME (type
) = type_synonym_name
;
1941 type_synonym_name
= 0;
1942 type
= read_struct_type (pp
, type
, objfile
);
1946 type
= dbx_alloc_type (typenums
, objfile
);
1947 TYPE_NAME (type
) = type_synonym_name
;
1948 type_synonym_name
= 0;
1949 type
= read_struct_type (pp
, type
, objfile
);
1950 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1955 return error_type (pp
);
1958 type
= dbx_alloc_type (typenums
, objfile
);
1959 type
= read_array_type (pp
, type
, objfile
);
1963 --*pp
; /* Go back to the symbol in error */
1964 /* Particularly important if it was \0! */
1965 return error_type (pp
);
1972 /* If this is an overriding temporary alteration for a header file's
1973 contents, and this type number is unknown in the global definition,
1974 put this type into the global definition at this type number. */
1975 if (header_file_prev_index
>= 0)
1977 register struct type
**tp
1978 = explicit_lookup_type (header_file_prev_index
, typenums
[1]);
1986 /* This page contains subroutines of read_type. */
1988 /* Read the description of a structure (or union type)
1989 and return an object describing the type. */
1991 static struct type
*
1992 read_struct_type (pp
, type
, objfile
)
1994 register struct type
*type
;
1995 struct objfile
*objfile
;
1997 /* Total number of methods defined in this class.
1998 If the class defines two `f' methods, and one `g' method,
1999 then this will have the value 3. */
2000 int total_length
= 0;
2004 struct nextfield
*next
;
2005 int visibility
; /* 0=public, 1=protected, 2=public */
2011 struct next_fnfield
*next
;
2012 struct fn_field fn_field
;
2015 struct next_fnfieldlist
2017 struct next_fnfieldlist
*next
;
2018 struct fn_fieldlist fn_fieldlist
;
2021 register struct nextfield
*list
= 0;
2022 struct nextfield
*new;
2025 int non_public_fields
= 0;
2028 register struct next_fnfieldlist
*mainlist
= 0;
2031 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2032 INIT_CPLUS_SPECIFIC(type
);
2034 /* First comes the total size in bytes. */
2036 TYPE_LENGTH (type
) = read_number (pp
, 0);
2038 /* C++: Now, if the class is a derived class, then the next character
2039 will be a '!', followed by the number of base classes derived from.
2040 Each element in the list contains visibility information,
2041 the offset of this base class in the derived structure,
2042 and then the base type. */
2045 int i
, n_baseclasses
, offset
;
2046 struct type
*baseclass
;
2049 /* Nonzero if it is a virtual baseclass, i.e.,
2053 struct C : public B, public virtual A {};
2055 B is a baseclass of C; A is a virtual baseclass for C. This is a C++
2056 2.0 language feature. */
2061 ALLOCATE_CPLUS_STRUCT_TYPE(type
);
2063 n_baseclasses
= read_number (pp
, ',');
2064 TYPE_FIELD_VIRTUAL_BITS (type
) =
2065 (B_TYPE
*) obstack_alloc (&objfile
-> type_obstack
,
2066 B_BYTES (n_baseclasses
));
2067 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), n_baseclasses
);
2069 for (i
= 0; i
< n_baseclasses
; i
++)
2072 *pp
= next_symbol_text ();
2083 /* Bad visibility format. */
2084 return error_type (pp
);
2092 non_public_fields
++;
2098 /* Bad visibility format. */
2099 return error_type (pp
);
2102 SET_TYPE_FIELD_VIRTUAL (type
, i
);
2105 /* Offset of the portion of the object corresponding to
2106 this baseclass. Always zero in the absence of
2107 multiple inheritance. */
2108 offset
= read_number (pp
, ',');
2109 baseclass
= read_type (pp
, objfile
);
2110 *pp
+= 1; /* skip trailing ';' */
2112 /* Make this baseclass visible for structure-printing purposes. */
2113 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2116 list
->visibility
= via_public
;
2117 list
->field
.type
= baseclass
;
2118 list
->field
.name
= type_name_no_tag (baseclass
);
2119 list
->field
.bitpos
= offset
;
2120 list
->field
.bitsize
= 0; /* this should be an unpacked field! */
2123 TYPE_N_BASECLASSES (type
) = n_baseclasses
;
2126 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
2127 At the end, we see a semicolon instead of a field.
2129 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2132 The `?' is a placeholder for one of '/2' (public visibility),
2133 '/1' (protected visibility), '/0' (private visibility), or nothing
2134 (C style symbol table, public visibility). */
2136 /* We better set p right now, in case there are no fields at all... */
2141 /* Check for and handle cretinous dbx symbol name continuation! */
2142 if (**pp
== '\\') *pp
= next_symbol_text ();
2144 /* Get space to record the next field's data. */
2145 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2149 /* Get the field name. */
2151 if (*p
== CPLUS_MARKER
)
2153 /* Special GNU C++ name. */
2158 struct type
*context
;
2169 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2170 prefix
= "INVALID_C++_ABBREV";
2174 context
= read_type (pp
, objfile
);
2175 name
= type_name_no_tag (context
);
2178 complain (&invalid_cpp_type_complaint
, (char *) symnum
);
2179 TYPE_NAME (context
) = name
;
2181 list
->field
.name
= obconcat (&objfile
-> type_obstack
,
2185 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2186 list
->field
.type
= read_type (pp
, objfile
);
2187 (*pp
)++; /* Skip the comma. */
2188 list
->field
.bitpos
= read_number (pp
, ';');
2189 /* This field is unpacked. */
2190 list
->field
.bitsize
= 0;
2191 list
->visibility
= 0; /* private */
2192 non_public_fields
++;
2194 /* GNU C++ anonymous type. */
2198 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2204 while (*p
!= ':') p
++;
2205 list
->field
.name
= obsavestring (*pp
, p
- *pp
,
2206 &objfile
-> type_obstack
);
2208 /* C++: Check to see if we have hit the methods yet. */
2214 /* This means we have a visibility for a field coming. */
2220 list
->visibility
= 0; /* private */
2221 non_public_fields
++;
2226 list
->visibility
= 1; /* protected */
2227 non_public_fields
++;
2232 list
->visibility
= 2; /* public */
2237 else /* normal dbx-style format. */
2238 list
->visibility
= 2; /* public */
2240 list
->field
.type
= read_type (pp
, objfile
);
2243 /* Static class member. */
2244 list
->field
.bitpos
= (long)-1;
2246 while (*p
!= ';') p
++;
2247 list
->field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
2252 else if (**pp
!= ',')
2253 /* Bad structure-type format. */
2254 return error_type (pp
);
2256 (*pp
)++; /* Skip the comma. */
2257 list
->field
.bitpos
= read_number (pp
, ',');
2258 list
->field
.bitsize
= read_number (pp
, ';');
2261 /* FIXME-tiemann: Can't the compiler put out something which
2262 lets us distinguish these? (or maybe just not put out anything
2263 for the field). What is the story here? What does the compiler
2264 really do? Also, patch gdb.texinfo for this case; I document
2265 it as a possible problem there. Search for "DBX-style". */
2267 /* This is wrong because this is identical to the symbols
2268 produced for GCC 0-size arrays. For example:
2273 The code which dumped core in such circumstances should be
2274 fixed not to dump core. */
2276 /* g++ -g0 can put out bitpos & bitsize zero for a static
2277 field. This does not give us any way of getting its
2278 class, so we can't know its name. But we can just
2279 ignore the field so we don't dump core and other nasty
2281 if (list
->field
.bitpos
== 0
2282 && list
->field
.bitsize
== 0)
2284 complain (&dbx_class_complaint
, 0);
2285 /* Ignore this field. */
2291 /* Detect an unpacked field and mark it as such.
2292 dbx gives a bit size for all fields.
2293 Note that forward refs cannot be packed,
2294 and treat enums as if they had the width of ints. */
2295 if (TYPE_CODE (list
->field
.type
) != TYPE_CODE_INT
2296 && TYPE_CODE (list
->field
.type
) != TYPE_CODE_ENUM
)
2297 list
->field
.bitsize
= 0;
2298 if ((list
->field
.bitsize
== 8 * TYPE_LENGTH (list
->field
.type
)
2299 || (TYPE_CODE (list
->field
.type
) == TYPE_CODE_ENUM
2300 && (list
->field
.bitsize
2301 == 8 * TYPE_LENGTH (lookup_fundamental_type (objfile
, FT_INTEGER
)))
2305 list
->field
.bitpos
% 8 == 0)
2306 list
->field
.bitsize
= 0;
2312 /* chill the list of fields: the last entry (at the head)
2313 is a partially constructed entry which we now scrub. */
2316 /* Now create the vector of fields, and record how big it is.
2317 We need this info to record proper virtual function table information
2318 for this class's virtual functions. */
2320 TYPE_NFIELDS (type
) = nfields
;
2321 TYPE_FIELDS (type
) = (struct field
*)
2322 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct field
) * nfields
);
2324 if (non_public_fields
)
2326 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2328 TYPE_FIELD_PRIVATE_BITS (type
) =
2329 (B_TYPE
*) obstack_alloc (&objfile
-> type_obstack
,
2331 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2333 TYPE_FIELD_PROTECTED_BITS (type
) =
2334 (B_TYPE
*) obstack_alloc (&objfile
-> type_obstack
,
2336 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2339 /* Copy the saved-up fields into the field vector. */
2341 for (n
= nfields
; list
; list
= list
->next
)
2344 TYPE_FIELD (type
, n
) = list
->field
;
2345 if (list
->visibility
== 0)
2346 SET_TYPE_FIELD_PRIVATE (type
, n
);
2347 else if (list
->visibility
== 1)
2348 SET_TYPE_FIELD_PROTECTED (type
, n
);
2351 /* Now come the method fields, as NAME::methods
2352 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
2353 At the end, we see a semicolon instead of a field.
2355 For the case of overloaded operators, the format is
2356 op$::*.methods, where $ is the CPLUS_MARKER (usually '$'),
2357 `*' holds the place for an operator name (such as `+=')
2358 and `.' marks the end of the operator name. */
2361 /* Now, read in the methods. To simplify matters, we
2362 "unread" the name that has been read, so that we can
2363 start from the top. */
2365 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2366 /* For each list of method lists... */
2370 struct next_fnfield
*sublist
= 0;
2371 struct type
*look_ahead_type
= NULL
;
2373 struct next_fnfieldlist
*new_mainlist
=
2374 (struct next_fnfieldlist
*)alloca (sizeof (struct next_fnfieldlist
));
2379 /* read in the name. */
2380 while (*p
!= ':') p
++;
2381 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
2383 /* This is a completely wierd case. In order to stuff in the
2384 names that might contain colons (the usual name delimiter),
2385 Mike Tiemann defined a different name format which is
2386 signalled if the identifier is "op$". In that case, the
2387 format is "op$::XXXX." where XXXX is the name. This is
2388 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2389 /* This lets the user type "break operator+".
2390 We could just put in "+" as the name, but that wouldn't
2392 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
2393 char *o
= opname
+ 3;
2395 /* Skip past '::'. */
2397 if (**pp
== '\\') *pp
= next_symbol_text ();
2401 main_fn_name
= savestring (opname
, o
- opname
);
2407 main_fn_name
= savestring (*pp
, p
- *pp
);
2408 /* Skip past '::'. */
2411 new_mainlist
->fn_fieldlist
.name
= main_fn_name
;
2415 struct next_fnfield
*new_sublist
=
2416 (struct next_fnfield
*)alloca (sizeof (struct next_fnfield
));
2418 /* Check for and handle cretinous dbx symbol name continuation! */
2419 if (look_ahead_type
== NULL
) /* Normal case. */
2421 if (**pp
== '\\') *pp
= next_symbol_text ();
2423 new_sublist
->fn_field
.type
= read_type (pp
, objfile
);
2425 /* Invalid symtab info for method. */
2426 return error_type (pp
);
2429 { /* g++ version 1 kludge */
2430 new_sublist
->fn_field
.type
= look_ahead_type
;
2431 look_ahead_type
= NULL
;
2436 while (*p
!= ';') p
++;
2438 /* If this is just a stub, then we don't have the
2440 if (TYPE_FLAGS (new_sublist
->fn_field
.type
) & TYPE_FLAG_STUB
)
2441 new_sublist
->fn_field
.is_stub
= 1;
2442 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
2445 /* Set this method's visibility fields. */
2446 switch (*(*pp
)++ - '0')
2449 new_sublist
->fn_field
.is_private
= 1;
2452 new_sublist
->fn_field
.is_protected
= 1;
2456 if (**pp
== '\\') *pp
= next_symbol_text ();
2459 case 'A': /* Normal functions. */
2460 new_sublist
->fn_field
.is_const
= 0;
2461 new_sublist
->fn_field
.is_volatile
= 0;
2464 case 'B': /* `const' member functions. */
2465 new_sublist
->fn_field
.is_const
= 1;
2466 new_sublist
->fn_field
.is_volatile
= 0;
2469 case 'C': /* `volatile' member function. */
2470 new_sublist
->fn_field
.is_const
= 0;
2471 new_sublist
->fn_field
.is_volatile
= 1;
2474 case 'D': /* `const volatile' member function. */
2475 new_sublist
->fn_field
.is_const
= 1;
2476 new_sublist
->fn_field
.is_volatile
= 1;
2479 case '*': /* File compiled with g++ version 1 -- no info */
2484 complain (&const_vol_complaint
, (char *) (long) **pp
);
2491 /* virtual member function, followed by index. */
2492 /* The sign bit is set to distinguish pointers-to-methods
2493 from virtual function indicies. Since the array is
2494 in words, the quantity must be shifted left by 1
2495 on 16 bit machine, and by 2 on 32 bit machine, forcing
2496 the sign bit out, and usable as a valid index into
2497 the array. Remove the sign bit here. */
2498 new_sublist
->fn_field
.voffset
=
2499 (0x7fffffff & read_number (pp
, ';')) + 2;
2501 if (**pp
== '\\') *pp
= next_symbol_text ();
2503 if (**pp
== ';' || **pp
== '\0')
2504 /* Must be g++ version 1. */
2505 new_sublist
->fn_field
.fcontext
= 0;
2508 /* Figure out from whence this virtual function came.
2509 It may belong to virtual function table of
2510 one of its baseclasses. */
2511 look_ahead_type
= read_type (pp
, objfile
);
2513 { /* g++ version 1 overloaded methods. */ }
2516 new_sublist
->fn_field
.fcontext
= look_ahead_type
;
2518 return error_type (pp
);
2521 look_ahead_type
= NULL
;
2527 /* static member function. */
2528 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
2529 if (strncmp (new_sublist
->fn_field
.physname
,
2530 main_fn_name
, strlen (main_fn_name
)))
2531 new_sublist
->fn_field
.is_stub
= 1;
2536 complain (&member_fn_complaint
, (char *) (long) (*pp
)[-1]);
2537 /* Fall through into normal member function. */
2540 /* normal member function. */
2541 new_sublist
->fn_field
.voffset
= 0;
2542 new_sublist
->fn_field
.fcontext
= 0;
2546 new_sublist
->next
= sublist
;
2547 sublist
= new_sublist
;
2549 if (**pp
== '\\') *pp
= next_symbol_text ();
2551 while (**pp
!= ';' && **pp
!= '\0');
2555 new_mainlist
->fn_fieldlist
.fn_fields
=
2556 (struct fn_field
*) obstack_alloc (&objfile
-> type_obstack
,
2557 sizeof (struct fn_field
) * length
);
2558 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
2559 new_mainlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
2561 new_mainlist
->fn_fieldlist
.length
= length
;
2562 new_mainlist
->next
= mainlist
;
2563 mainlist
= new_mainlist
;
2565 total_length
+= length
;
2567 while (**pp
!= ';');
2575 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2576 obstack_alloc (&objfile
-> type_obstack
,
2577 sizeof (struct fn_fieldlist
) * nfn_fields
);
2578 TYPE_NFN_FIELDS (type
) = nfn_fields
;
2579 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2584 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
2585 TYPE_NFN_FIELDS_TOTAL (type
) +=
2586 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, i
));
2589 for (n
= nfn_fields
; mainlist
; mainlist
= mainlist
->next
) {
2590 --n
; /* Circumvent Sun3 compiler bug */
2591 TYPE_FN_FIELDLISTS (type
)[n
] = mainlist
->fn_fieldlist
;
2598 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
2600 /* Obsolete flags that used to indicate the presence
2601 of constructors and/or destructors. */
2605 /* Read either a '%' or the final ';'. */
2606 if (*(*pp
)++ == '%')
2608 /* We'd like to be able to derive the vtable pointer field
2609 from the type information, but when it's inherited, that's
2610 hard. A reason it's hard is because we may read in the
2611 info about a derived class before we read in info about
2612 the base class that provides the vtable pointer field.
2613 Once the base info has been read, we could fill in the info
2614 for the derived classes, but for the fact that by then,
2615 we don't remember who needs what. */
2617 int predicted_fieldno
= -1;
2619 /* Now we must record the virtual function table pointer's
2620 field information. */
2628 /* In version 2, we derive the vfield ourselves. */
2629 for (n
= 0; n
< nfields
; n
++)
2631 if (! strncmp (TYPE_FIELD_NAME (type
, n
), vptr_name
,
2632 sizeof (vptr_name
) -1))
2634 predicted_fieldno
= n
;
2638 if (predicted_fieldno
< 0)
2639 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
2640 if (! TYPE_FIELD_VIRTUAL (type
, n
)
2641 && TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
)) >= 0)
2643 predicted_fieldno
= TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
));
2649 t
= read_type (pp
, objfile
);
2651 while (*p
!= '\0' && *p
!= ';')
2654 /* Premature end of symbol. */
2655 return error_type (pp
);
2657 TYPE_VPTR_BASETYPE (type
) = t
;
2660 if (TYPE_FIELD_NAME (t
, TYPE_N_BASECLASSES (t
)) == 0)
2662 /* FIXME-tiemann: what's this? */
2664 TYPE_VPTR_FIELDNO (type
) = i
= TYPE_N_BASECLASSES (t
);
2669 else for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); --i
)
2670 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
2671 sizeof (vptr_name
) -1))
2673 TYPE_VPTR_FIELDNO (type
) = i
;
2677 /* Virtual function table field not found. */
2678 return error_type (pp
);
2681 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2684 if (TYPE_VPTR_FIELDNO (type
) != predicted_fieldno
)
2685 error ("TYPE_VPTR_FIELDNO miscalculated");
2695 /* Read a definition of an array type,
2696 and create and return a suitable type object.
2697 Also creates a range type which represents the bounds of that
2699 static struct type
*
2700 read_array_type (pp
, type
, objfile
)
2702 register struct type
*type
;
2703 struct objfile
*objfile
;
2705 struct type
*index_type
, *element_type
, *range_type
;
2709 /* Format of an array type:
2710 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2713 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2714 for these, produce a type like float[][]. */
2716 index_type
= read_type (pp
, objfile
);
2718 /* Improper format of array type decl. */
2719 return error_type (pp
);
2722 if (!(**pp
>= '0' && **pp
<= '9'))
2727 lower
= read_number (pp
, ';');
2729 if (!(**pp
>= '0' && **pp
<= '9'))
2734 upper
= read_number (pp
, ';');
2736 element_type
= read_type (pp
, objfile
);
2745 /* Create range type. */
2746 range_type
= (struct type
*)
2747 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
2748 bzero (range_type
, sizeof (struct type
));
2749 TYPE_OBJFILE (range_type
) = objfile
;
2750 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
2751 TYPE_TARGET_TYPE (range_type
) = index_type
;
2753 /* This should never be needed. */
2754 TYPE_LENGTH (range_type
) = sizeof (int);
2756 TYPE_NFIELDS (range_type
) = 2;
2757 TYPE_FIELDS (range_type
) =
2758 (struct field
*) obstack_alloc (&objfile
-> type_obstack
,
2759 2 * sizeof (struct field
));
2760 TYPE_FIELD_BITPOS (range_type
, 0) = lower
;
2761 TYPE_FIELD_BITPOS (range_type
, 1) = upper
;
2764 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
2765 TYPE_TARGET_TYPE (type
) = element_type
;
2766 TYPE_LENGTH (type
) = (upper
- lower
+ 1) * TYPE_LENGTH (element_type
);
2767 TYPE_NFIELDS (type
) = 1;
2768 TYPE_FIELDS (type
) =
2769 (struct field
*) obstack_alloc (&objfile
-> type_obstack
,
2770 sizeof (struct field
));
2771 TYPE_FIELD_TYPE (type
, 0) = range_type
;
2773 /* If we have an array whose element type is not yet known, but whose
2774 bounds *are* known, record it to be adjusted at the end of the file. */
2775 if (TYPE_LENGTH (element_type
) == 0 && !adjustable
)
2776 add_undefined_type (type
);
2782 /* Read a definition of an enumeration type,
2783 and create and return a suitable type object.
2784 Also defines the symbols that represent the values of the type. */
2786 static struct type
*
2787 read_enum_type (pp
, type
, objfile
)
2789 register struct type
*type
;
2790 struct objfile
*objfile
;
2795 register struct symbol
*sym
;
2797 struct pending
**symlist
;
2798 struct pending
*osyms
, *syms
;
2801 if (within_function
)
2802 symlist
= &local_symbols
;
2804 symlist
= &file_symbols
;
2806 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2808 /* Read the value-names and their values.
2809 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2810 A semicolon or comma instead of a NAME means the end. */
2811 while (**pp
&& **pp
!= ';' && **pp
!= ',')
2813 /* Check for and handle cretinous dbx symbol name continuation! */
2814 if (**pp
== '\\') *pp
= next_symbol_text ();
2817 while (*p
!= ':') p
++;
2818 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
2820 n
= read_number (pp
, ',');
2822 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2823 bzero (sym
, sizeof (struct symbol
));
2824 SYMBOL_NAME (sym
) = name
;
2825 SYMBOL_CLASS (sym
) = LOC_CONST
;
2826 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2827 SYMBOL_VALUE (sym
) = n
;
2828 add_symbol_to_list (sym
, symlist
);
2833 (*pp
)++; /* Skip the semicolon. */
2835 /* Now fill in the fields of the type-structure. */
2837 TYPE_LENGTH (type
) = sizeof (int);
2838 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2839 TYPE_NFIELDS (type
) = nsyms
;
2840 TYPE_FIELDS (type
) = (struct field
*)
2841 obstack_alloc (&objfile
-> type_obstack
,
2842 sizeof (struct field
) * nsyms
);
2844 /* Find the symbols for the values and put them into the type.
2845 The symbols can be found in the symlist that we put them on
2846 to cause them to be defined. osyms contains the old value
2847 of that symlist; everything up to there was defined by us. */
2848 /* Note that we preserve the order of the enum constants, so
2849 that in something like "enum {FOO, LAST_THING=FOO}" we print
2850 FOO, not LAST_THING. */
2852 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2857 for (; j
< syms
->nsyms
; j
++,n
++)
2859 struct symbol
*xsym
= syms
->symbol
[j
];
2860 SYMBOL_TYPE (xsym
) = type
;
2861 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2862 TYPE_FIELD_VALUE (type
, n
) = 0;
2863 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2864 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2871 /* This screws up perfectly good C programs with enums. FIXME. */
2872 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2873 if(TYPE_NFIELDS(type
) == 2 &&
2874 ((!strcmp(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2875 !strcmp(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2876 (!strcmp(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2877 !strcmp(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2878 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2884 /* Read a number from the string pointed to by *PP.
2885 The value of *PP is advanced over the number.
2886 If END is nonzero, the character that ends the
2887 number must match END, or an error happens;
2888 and that character is skipped if it does match.
2889 If END is zero, *PP is left pointing to that character.
2891 If the number fits in a long, set *VALUE and set *BITS to 0.
2892 If not, set *BITS to be the number of bits in the number.
2894 If encounter garbage, set *BITS to -1. */
2897 read_huge_number (pp
, end
, valu
, bits
)
2918 /* Leading zero means octal. GCC uses this to output values larger
2919 than an int (because that would be hard in decimal). */
2926 upper_limit
= LONG_MAX
/ radix
;
2927 while ((c
= *p
++) >= '0' && c
<= ('0' + radix
))
2929 if (n
<= upper_limit
)
2932 n
+= c
- '0'; /* FIXME this overflows anyway */
2937 /* This depends on large values being output in octal, which is
2944 /* Ignore leading zeroes. */
2948 else if (c
== '2' || c
== '3')
2974 /* Large decimal constants are an error (because it is hard to
2975 count how many bits are in them). */
2981 /* -0x7f is the same as 0x80. So deal with it by adding one to
2982 the number of bits. */
2997 #define MAX_OF_C_TYPE(t) ((1 << (sizeof (t)*8 - 1)) - 1)
2998 #define MIN_OF_C_TYPE(t) (-(1 << (sizeof (t)*8 - 1)))
3000 static struct type
*
3001 read_range_type (pp
, typenums
, objfile
)
3004 struct objfile
*objfile
;
3010 struct type
*result_type
;
3012 /* First comes a type we are a subrange of.
3013 In C it is usually 0, 1 or the type being defined. */
3014 read_type_number (pp
, rangenums
);
3015 self_subrange
= (rangenums
[0] == typenums
[0] &&
3016 rangenums
[1] == typenums
[1]);
3018 /* A semicolon should now follow; skip it. */
3022 /* The remaining two operands are usually lower and upper bounds
3023 of the range. But in some special cases they mean something else. */
3024 read_huge_number (pp
, ';', &n2
, &n2bits
);
3025 read_huge_number (pp
, ';', &n3
, &n3bits
);
3027 if (n2bits
== -1 || n3bits
== -1)
3028 return error_type (pp
);
3030 /* If limits are huge, must be large integral type. */
3031 if (n2bits
!= 0 || n3bits
!= 0)
3033 char got_signed
= 0;
3034 char got_unsigned
= 0;
3035 /* Number of bits in the type. */
3038 /* Range from 0 to <large number> is an unsigned large integral type. */
3039 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
3044 /* Range from <large number> to <large number>-1 is a large signed
3046 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
3052 /* Check for "long long". */
3053 if (got_signed
&& nbits
== TARGET_LONG_LONG_BIT
)
3054 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
3055 if (got_unsigned
&& nbits
== TARGET_LONG_LONG_BIT
)
3056 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
3058 if (got_signed
|| got_unsigned
)
3060 result_type
= (struct type
*)
3061 obstack_alloc (&objfile
-> type_obstack
,
3062 sizeof (struct type
));
3063 bzero (result_type
, sizeof (struct type
));
3064 TYPE_OBJFILE (result_type
) = objfile
;
3065 TYPE_LENGTH (result_type
) = nbits
/ TARGET_CHAR_BIT
;
3066 TYPE_CODE (result_type
) = TYPE_CODE_INT
;
3068 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
3072 return error_type (pp
);
3075 /* A type defined as a subrange of itself, with bounds both 0, is void. */
3076 if (self_subrange
&& n2
== 0 && n3
== 0)
3077 return (lookup_fundamental_type (objfile
, FT_VOID
));
3079 /* If n3 is zero and n2 is not, we want a floating type,
3080 and n2 is the width in bytes.
3082 Fortran programs appear to use this for complex types also,
3083 and they give no way to distinguish between double and single-complex!
3084 We don't have complex types, so we would lose on all fortran files!
3085 So return type `double' for all of those. It won't work right
3086 for the complex values, but at least it makes the file loadable.
3088 FIXME, we may be able to distinguish these by their names. FIXME. */
3090 if (n3
== 0 && n2
> 0)
3092 if (n2
== sizeof (float))
3093 return (lookup_fundamental_type (objfile
, FT_FLOAT
));
3094 return (lookup_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
));
3097 /* If the upper bound is -1, it must really be an unsigned int. */
3099 else if (n2
== 0 && n3
== -1)
3101 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
3102 long' is to look at its name! */
3104 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
3105 long_kludge_name
[9] == 'l' /* long */)
3106 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
3107 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
3109 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
3112 /* Special case: char is defined (Who knows why) as a subrange of
3113 itself with range 0-127. */
3114 else if (self_subrange
&& n2
== 0 && n3
== 127)
3115 return (lookup_fundamental_type (objfile
, FT_CHAR
));
3117 /* Assumptions made here: Subrange of self is equivalent to subrange
3118 of int. FIXME: Host and target type-sizes assumed the same. */
3119 /* FIXME: This is the *only* place in GDB that depends on comparing
3120 some type to a builtin type with ==. Fix it! */
3122 && (self_subrange
||
3123 *dbx_lookup_type (rangenums
) == lookup_fundamental_type (objfile
, FT_INTEGER
)))
3125 /* an unsigned type */
3127 if (n3
== - sizeof (long long))
3128 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
3130 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
3131 long' is to look at its name! */
3132 if (n3
== (unsigned long)~0L &&
3133 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
3134 long_kludge_name
[9] == 'l' /* long */)
3135 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
3136 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
3137 if (n3
== (unsigned int)~0L)
3138 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
3139 if (n3
== (unsigned short)~0L)
3140 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_SHORT
));
3141 if (n3
== (unsigned char)~0L)
3142 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_CHAR
));
3145 else if (n3
== 0 && n2
== -sizeof (long long))
3146 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
3148 else if (n2
== -n3
-1)
3151 /* FIXME -- the only way to distinguish `int' from `long' is to look
3153 if ((n3
== (1 << (8 * sizeof (long) - 1)) - 1) &&
3154 long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
3155 return (lookup_fundamental_type (objfile
, FT_LONG
));
3156 if (n3
== (1 << (8 * sizeof (int) - 1)) - 1)
3157 return (lookup_fundamental_type (objfile
, FT_INTEGER
));
3158 if (n3
== (1 << (8 * sizeof (short) - 1)) - 1)
3159 return (lookup_fundamental_type (objfile
, FT_SHORT
));
3160 if (n3
== (1 << (8 * sizeof (char) - 1)) - 1)
3161 return (lookup_fundamental_type (objfile
, FT_CHAR
));
3164 /* We have a real range type on our hands. Allocate space and
3165 return a real pointer. */
3167 /* At this point I don't have the faintest idea how to deal with
3168 a self_subrange type; I'm going to assume that this is used
3169 as an idiom, and that all of them are special cases. So . . . */
3171 return error_type (pp
);
3173 result_type
= (struct type
*)
3174 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
3175 bzero (result_type
, sizeof (struct type
));
3176 TYPE_OBJFILE (result_type
) = objfile
;
3178 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
3180 TYPE_TARGET_TYPE (result_type
) = *dbx_lookup_type(rangenums
);
3181 if (TYPE_TARGET_TYPE (result_type
) == 0) {
3182 complain (&range_type_base_complaint
, (char *) rangenums
[1]);
3183 TYPE_TARGET_TYPE (result_type
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
3186 TYPE_NFIELDS (result_type
) = 2;
3187 TYPE_FIELDS (result_type
) =
3188 (struct field
*) obstack_alloc (&objfile
-> type_obstack
,
3189 2 * sizeof (struct field
));
3190 bzero (TYPE_FIELDS (result_type
), 2 * sizeof (struct field
));
3191 TYPE_FIELD_BITPOS (result_type
, 0) = n2
;
3192 TYPE_FIELD_BITPOS (result_type
, 1) = n3
;
3194 TYPE_LENGTH (result_type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type
));
3199 /* Read a number from the string pointed to by *PP.
3200 The value of *PP is advanced over the number.
3201 If END is nonzero, the character that ends the
3202 number must match END, or an error happens;
3203 and that character is skipped if it does match.
3204 If END is zero, *PP is left pointing to that character. */
3207 read_number (pp
, end
)
3211 register char *p
= *pp
;
3212 register long n
= 0;
3216 /* Handle an optional leading minus sign. */
3224 /* Read the digits, as far as they go. */
3226 while ((c
= *p
++) >= '0' && c
<= '9')
3234 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c
, symnum
);
3243 /* Read in an argument list. This is a list of types, separated by commas
3244 and terminated with END. Return the list of types read in, or (struct type
3245 **)-1 if there is an error. */
3246 static struct type
**
3247 read_args (pp
, end
, objfile
)
3250 struct objfile
*objfile
;
3252 /* FIXME! Remove this arbitrary limit! */
3253 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
3259 /* Invalid argument list: no ','. */
3260 return (struct type
**)-1;
3263 /* Check for and handle cretinous dbx symbol name continuation! */
3265 *pp
= next_symbol_text ();
3267 types
[n
++] = read_type (pp
, objfile
);
3269 *pp
+= 1; /* get past `end' (the ':' character) */
3273 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
3275 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
3277 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
3278 bzero (rval
+ n
, sizeof (struct type
*));
3282 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
3284 memcpy (rval
, types
, n
* sizeof (struct type
*));
3288 /* Add a common block's start address to the offset of each symbol
3289 declared to be in it (by being between a BCOMM/ECOMM pair that uses
3290 the common block name). */
3293 fix_common_block (sym
, valu
)
3297 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
3298 for ( ; next
; next
= next
->next
)
3301 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
3302 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
3306 /* Initializer for this module */
3308 _initialize_buildsym ()
3310 undef_types_allocated
= 20;
3311 undef_types_length
= 0;
3312 undef_types
= (struct type
**) xmalloc (undef_types_allocated
*
3313 sizeof (struct type
*));