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 #ifdef PROCESS_LINENUMBER_HOOK
846 PROCESS_LINENUMBER_HOOK (); /* Needed for aixcoff. */
849 /* Now create the symtab objects proper, one for each subfile. */
850 /* (The main file is the last one on the chain.) */
852 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
855 /* If we have blocks of symbols, make a symtab.
856 Otherwise, just ignore this file and any line number info in it. */
859 if (subfile
->line_vector
) {
860 /* First, shrink the linetable to make more memory. */
861 linetablesize
= sizeof (struct linetable
) +
862 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
863 subfile
->line_vector
= (struct linetable
*)
864 xrealloc ((char *) subfile
->line_vector
, linetablesize
);
867 qsort (subfile
->line_vector
->item
, subfile
->line_vector
->nitems
,
868 sizeof (struct linetable_entry
), compare_line_numbers
);
871 /* Now, allocate a symbol table. */
872 symtab
= allocate_symtab (subfile
->name
, objfile
);
874 /* Fill in its components. */
875 symtab
->blockvector
= blockvector
;
876 if (subfile
->line_vector
)
878 /* Reallocate the line table on the symbol obstack */
879 symtab
->linetable
= (struct linetable
*)
880 obstack_alloc (&objfile
-> symbol_obstack
, linetablesize
);
881 memcpy (symtab
->linetable
, subfile
->line_vector
, linetablesize
);
885 symtab
->linetable
= NULL
;
887 symtab
->dirname
= subfile
->dirname
;
888 symtab
->free_code
= free_linetable
;
889 symtab
->free_ptr
= 0;
891 if (subfile
->line_vector
)
892 free (subfile
->line_vector
);
894 nextsub
= subfile
->next
;
899 free ((char *) type_vector
);
901 type_vector_length
= 0;
903 last_source_file
= 0;
905 previous_stab_code
= 0;
911 /* Push a context block. Args are an identifying nesting level (checkable
912 when you pop it), and the starting PC address of this context. */
914 struct context_stack
*
915 push_context (desc
, valu
)
919 register struct context_stack
*new;
921 if (context_stack_depth
== context_stack_size
)
923 context_stack_size
*= 2;
924 context_stack
= (struct context_stack
*)
925 xrealloc ((char *) context_stack
,
926 (context_stack_size
* sizeof (struct context_stack
)));
929 new = &context_stack
[context_stack_depth
++];
931 new->locals
= local_symbols
;
932 new->old_blocks
= pending_blocks
;
933 new->start_addr
= valu
;
941 /* Initialize anything that needs initializing when starting to read
942 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
954 /* Initialize anything that needs initializing when a completely new
955 symbol file is specified (not just adding some symbols from another
956 file, e.g. a shared library). */
961 /* Empty the hash table of global syms looking for values. */
962 bzero (global_sym_chain
, sizeof global_sym_chain
);
967 /* Scan through all of the global symbols defined in the object file,
968 assigning values to the debugging symbols that need to be assigned
969 to. Get these symbols from the minimal symbol table. */
972 scan_file_globals (objfile
)
973 struct objfile
*objfile
;
976 struct minimal_symbol
*msymbol
;
977 struct symbol
*sym
, *prev
;
979 for (msymbol
= objfile
-> msymbols
; msymbol
-> name
!= NULL
; msymbol
++)
983 prev
= (struct symbol
*) 0;
985 /* Get the hash index and check all the symbols
986 under that hash index. */
988 hash
= hashname (msymbol
-> name
);
990 for (sym
= global_sym_chain
[hash
]; sym
;)
992 if (*(msymbol
-> name
) == SYMBOL_NAME (sym
)[0]
993 && !strcmp(msymbol
-> name
+ 1, SYMBOL_NAME (sym
) + 1))
995 /* Splice this symbol out of the hash chain and
996 assign the value we have to it. */
998 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
1000 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
1002 /* Check to see whether we need to fix up a common block. */
1003 /* Note: this code might be executed several times for
1004 the same symbol if there are multiple references. */
1005 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1006 fix_common_block (sym
, msymbol
-> address
);
1008 SYMBOL_VALUE_ADDRESS (sym
) = msymbol
-> address
;
1011 sym
= SYMBOL_VALUE_CHAIN (prev
);
1013 sym
= global_sym_chain
[hash
];
1018 sym
= SYMBOL_VALUE_CHAIN (sym
);
1025 /* Read a number by which a type is referred to in dbx data,
1026 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
1027 Just a single number N is equivalent to (0,N).
1028 Return the two numbers by storing them in the vector TYPENUMS.
1029 TYPENUMS will then be used as an argument to dbx_lookup_type. */
1032 read_type_number (pp
, typenums
)
1034 register int *typenums
;
1039 typenums
[0] = read_number (pp
, ',');
1040 typenums
[1] = read_number (pp
, ')');
1045 typenums
[1] = read_number (pp
, 0);
1049 /* To handle GNU C++ typename abbreviation, we need to be able to
1050 fill in a type's name as soon as space for that type is allocated.
1051 `type_synonym_name' is the name of the type being allocated.
1052 It is cleared as soon as it is used (lest all allocated types
1054 static char *type_synonym_name
;
1058 define_symbol (valu
, string
, desc
, type
, objfile
)
1063 struct objfile
*objfile
;
1065 register struct symbol
*sym
;
1066 char *p
= (char *) strchr (string
, ':');
1070 struct type
*temptype
;
1072 /* Ignore syms with empty names. */
1076 /* Ignore old-style symbols from cc -go */
1080 sym
= (struct symbol
*)obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1082 if (processing_gcc_compilation
) {
1083 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
1084 number of bytes occupied by a type or object, which we ignore. */
1085 SYMBOL_LINE(sym
) = desc
;
1087 SYMBOL_LINE(sym
) = 0; /* unknown */
1090 if (string
[0] == CPLUS_MARKER
)
1092 /* Special GNU C++ names. */
1096 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
1097 &objfile
-> symbol_obstack
);
1099 case 'v': /* $vtbl_ptr_type */
1100 /* Was: SYMBOL_NAME (sym) = "vptr"; */
1103 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
1104 &objfile
-> symbol_obstack
);
1108 /* This was an anonymous type that was never fixed up. */
1119 = (char *) obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
1120 /* Open-coded bcopy--saves function call time. */
1122 register char *p1
= string
;
1123 register char *p2
= SYMBOL_NAME (sym
);
1130 /* Determine the type of name being defined. */
1131 /* The Acorn RISC machine's compiler can put out locals that don't
1132 start with "234=" or "(3,4)=", so assume anything other than the
1133 deftypes we know how to handle is a local. */
1134 /* (Peter Watkins @ Computervision)
1135 Handle Sun-style local fortran array types 'ar...' .
1136 (gnu@cygnus.com) -- this strchr() handles them properly?
1137 (tiemann@cygnus.com) -- 'C' is for catch. */
1138 if (!strchr ("cfFGpPrStTvVXC", *p
))
1143 /* c is a special case, not followed by a type-number.
1144 SYMBOL:c=iVALUE for an integer constant symbol.
1145 SYMBOL:c=rVALUE for a floating constant symbol.
1146 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1147 e.g. "b:c=e6,0" for "const b = blob1"
1148 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1152 error ("Invalid symbol data at symtab pos %d.", symnum
);
1157 double d
= atof (p
);
1160 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1163 obstack_alloc (&objfile
-> type_obstack
,
1165 memcpy (dbl_valu
, &d
, sizeof (double));
1166 SWAP_TARGET_AND_HOST (dbl_valu
, sizeof (double));
1167 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
1168 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
1173 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1175 SYMBOL_VALUE (sym
) = atoi (p
);
1176 SYMBOL_CLASS (sym
) = LOC_CONST
;
1180 /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1181 e.g. "b:c=e6,0" for "const b = blob1"
1182 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1186 read_type_number (&p
, typenums
);
1188 error ("Invalid symbol data: no comma in enum const symbol");
1190 SYMBOL_TYPE (sym
) = *dbx_lookup_type (typenums
);
1191 SYMBOL_VALUE (sym
) = atoi (p
);
1192 SYMBOL_CLASS (sym
) = LOC_CONST
;
1196 error ("Invalid symbol data at symtab pos %d.", symnum
);
1198 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1199 add_symbol_to_list (sym
, &file_symbols
);
1203 /* Now usually comes a number that says which data type,
1204 and possibly more stuff to define the type
1205 (all of which is handled by read_type) */
1207 if (deftype
== 'p' && *p
== 'F')
1208 /* pF is a two-letter code that means a function parameter in Fortran.
1209 The type-number specifies the type of the return value.
1210 Translate it into a pointer-to-function type. */
1214 = lookup_pointer_type (lookup_function_type (read_type (&p
, objfile
)));
1218 struct type
*type_read
;
1219 synonym
= *p
== 't';
1224 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
1225 strlen (SYMBOL_NAME (sym
)),
1226 &objfile
-> symbol_obstack
);
1229 /* Here we save the name of the symbol for read_range_type, which
1230 ends up reading in the basic types. In stabs, unfortunately there
1231 is no distinction between "int" and "long" types except their
1232 names. Until we work out a saner type policy (eliminating most
1233 builtin types and using the names specified in the files), we
1234 save away the name so that far away from here in read_range_type,
1235 we can examine it to decide between "int" and "long". FIXME. */
1236 long_kludge_name
= SYMBOL_NAME (sym
);
1237 type_read
= read_type (&p
, objfile
);
1239 if ((deftype
== 'F' || deftype
== 'f')
1240 && TYPE_CODE (type_read
) != TYPE_CODE_FUNC
)
1243 /* This code doesn't work -- it needs to realloc and can't. */
1244 struct type
*new = (struct type
*)
1245 obstack_alloc (&objfile
-> type_obstack
,
1246 sizeof (struct type
));
1248 /* Generate a template for the type of this function. The
1249 types of the arguments will be added as we read the symbol
1251 *new = *lookup_function_type (type_read
);
1252 SYMBOL_TYPE(sym
) = new;
1253 TYPE_OBJFILE (new) = objfile
;
1254 in_function_type
= new;
1256 SYMBOL_TYPE (sym
) = lookup_function_type (type_read
);
1260 SYMBOL_TYPE (sym
) = type_read
;
1266 /* The name of a caught exception. */
1267 SYMBOL_CLASS (sym
) = LOC_LABEL
;
1268 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1269 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1270 add_symbol_to_list (sym
, &local_symbols
);
1274 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1275 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1276 add_symbol_to_list (sym
, &file_symbols
);
1280 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1281 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1282 add_symbol_to_list (sym
, &global_symbols
);
1286 /* For a class G (global) symbol, it appears that the
1287 value is not correct. It is necessary to search for the
1288 corresponding linker definition to find the value.
1289 These definitions appear at the end of the namelist. */
1290 i
= hashname (SYMBOL_NAME (sym
));
1291 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1292 global_sym_chain
[i
] = sym
;
1293 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1294 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1295 add_symbol_to_list (sym
, &global_symbols
);
1298 /* This case is faked by a conditional above,
1299 when there is no code letter in the dbx data.
1300 Dbx data never actually contains 'l'. */
1302 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1303 SYMBOL_VALUE (sym
) = valu
;
1304 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1305 add_symbol_to_list (sym
, &local_symbols
);
1309 /* Normally this is a parameter, a LOC_ARG. On the i960, it
1310 can also be a LOC_LOCAL_ARG depending on symbol type. */
1311 #ifndef DBX_PARM_SYMBOL_CLASS
1312 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
1314 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
1315 SYMBOL_VALUE (sym
) = valu
;
1316 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1318 /* This doesn't work yet. */
1319 add_param_to_type (&in_function_type
, sym
);
1321 add_symbol_to_list (sym
, &local_symbols
);
1323 /* If it's gcc-compiled, if it says `short', believe it. */
1324 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
1327 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
1328 /* This macro is defined on machines (e.g. sparc) where
1329 we should believe the type of a PCC 'short' argument,
1330 but shouldn't believe the address (the address is
1331 the address of the corresponding int). Note that
1332 this is only different from the BELIEVE_PCC_PROMOTION
1333 case on big-endian machines.
1335 My guess is that this correction, as opposed to changing
1336 the parameter to an 'int' (as done below, for PCC
1337 on most machines), is the right thing to do
1338 on all machines, but I don't want to risk breaking
1339 something that already works. On most PCC machines,
1340 the sparc problem doesn't come up because the calling
1341 function has to zero the top bytes (not knowing whether
1342 the called function wants an int or a short), so there
1343 is no practical difference between an int and a short
1344 (except perhaps what happens when the GDB user types
1345 "print short_arg = 0x10000;").
1347 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
1348 actually produces the correct address (we don't need to fix it
1349 up). I made this code adapt so that it will offset the symbol
1350 if it was pointing at an int-aligned location and not
1351 otherwise. This way you can use the same gdb for 4.0.x and
1354 If the parameter is shorter than an int, and is integral
1355 (e.g. char, short, or unsigned equivalent), and is claimed to
1356 be passed on an integer boundary, don't believe it! Offset the
1357 parameter's address to the tail-end of that integer. */
1359 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
1360 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1361 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1362 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
1364 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
1365 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1369 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
1371 /* If PCC says a parameter is a short or a char,
1372 it is really an int. */
1373 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
1374 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
1375 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1377 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1378 ? lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
)
1383 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
1386 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1387 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1388 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1389 add_symbol_to_list (sym
, &local_symbols
);
1393 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1394 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1395 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1396 add_symbol_to_list (sym
, &local_symbols
);
1400 /* Static symbol at top level of file */
1401 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1402 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1403 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1404 add_symbol_to_list (sym
, &file_symbols
);
1408 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1409 SYMBOL_VALUE (sym
) = valu
;
1410 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1411 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1412 TYPE_NAME (SYMBOL_TYPE (sym
)) =
1413 obsavestring (SYMBOL_NAME (sym
),
1414 strlen (SYMBOL_NAME (sym
)),
1415 &objfile
-> symbol_obstack
);
1416 /* C++ vagaries: we may have a type which is derived from
1417 a base type which did not have its name defined when the
1418 derived class was output. We fill in the derived class's
1419 base part member's name here in that case. */
1420 else if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1421 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1422 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1425 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1426 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1427 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1428 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1431 add_symbol_to_list (sym
, &file_symbols
);
1435 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1436 SYMBOL_VALUE (sym
) = valu
;
1437 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1438 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1439 TYPE_NAME (SYMBOL_TYPE (sym
))
1440 = obconcat (&objfile
-> type_obstack
, "",
1441 (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_ENUM
1443 : (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1444 ? "struct " : "union ")),
1446 add_symbol_to_list (sym
, &file_symbols
);
1450 register struct symbol
*typedef_sym
= (struct symbol
*)
1451 obstack_alloc (&objfile
-> type_obstack
,
1452 sizeof (struct symbol
));
1453 SYMBOL_NAME (typedef_sym
) = SYMBOL_NAME (sym
);
1454 SYMBOL_TYPE (typedef_sym
) = SYMBOL_TYPE (sym
);
1456 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1457 SYMBOL_VALUE (typedef_sym
) = valu
;
1458 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
1459 add_symbol_to_list (typedef_sym
, &file_symbols
);
1464 /* Static symbol of local scope */
1465 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1466 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1467 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1468 add_symbol_to_list (sym
, &local_symbols
);
1472 /* Reference parameter */
1473 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
1474 SYMBOL_VALUE (sym
) = valu
;
1475 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1476 add_symbol_to_list (sym
, &local_symbols
);
1480 /* This is used by Sun FORTRAN for "function result value".
1481 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1482 that Pascal uses it too, but when I tried it Pascal used
1483 "x:3" (local symbol) instead. */
1484 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1485 SYMBOL_VALUE (sym
) = valu
;
1486 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1487 add_symbol_to_list (sym
, &local_symbols
);
1491 error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype
, symnum
);
1496 /* What about types defined as forward references inside of a small lexical
1498 /* Add a type to the list of undefined types to be checked through
1499 once this file has been read in. */
1501 add_undefined_type (type
)
1504 if (undef_types_length
== undef_types_allocated
)
1506 undef_types_allocated
*= 2;
1507 undef_types
= (struct type
**)
1508 xrealloc ((char *) undef_types
,
1509 undef_types_allocated
* sizeof (struct type
*));
1511 undef_types
[undef_types_length
++] = type
;
1514 /* Go through each undefined type, see if it's still undefined, and fix it
1515 up if possible. We have two kinds of undefined types:
1517 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
1518 Fix: update array length using the element bounds
1519 and the target type's length.
1520 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
1521 yet defined at the time a pointer to it was made.
1522 Fix: Do a full lookup on the struct/union tag. */
1524 cleanup_undefined_types ()
1528 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++) {
1529 switch (TYPE_CODE (*type
)) {
1531 case TYPE_CODE_STRUCT
:
1532 case TYPE_CODE_UNION
:
1533 case TYPE_CODE_ENUM
:
1535 /* Reasonable test to see if it's been defined since. */
1536 if (TYPE_NFIELDS (*type
) == 0)
1538 struct pending
*ppt
;
1540 /* Name of the type, without "struct" or "union" */
1541 char *typename
= TYPE_NAME (*type
);
1543 if (!strncmp (typename
, "struct ", 7))
1545 if (!strncmp (typename
, "union ", 6))
1547 if (!strncmp (typename
, "enum ", 5))
1550 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1551 for (i
= 0; i
< ppt
->nsyms
; i
++)
1553 struct symbol
*sym
= ppt
->symbol
[i
];
1555 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1556 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1557 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
1559 && !strcmp (SYMBOL_NAME (sym
), typename
))
1560 memcpy (*type
, SYMBOL_TYPE (sym
), sizeof (struct type
));
1564 /* It has been defined; don't mark it as a stub. */
1565 TYPE_FLAGS (*type
) &= ~TYPE_FLAG_STUB
;
1569 case TYPE_CODE_ARRAY
:
1571 struct type
*range_type
;
1574 if (TYPE_LENGTH (*type
) != 0) /* Better be unknown */
1576 if (TYPE_NFIELDS (*type
) != 1)
1578 range_type
= TYPE_FIELD_TYPE (*type
, 0);
1579 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
1582 /* Now recompute the length of the array type, based on its
1583 number of elements and the target type's length. */
1584 lower
= TYPE_FIELD_BITPOS (range_type
, 0);
1585 upper
= TYPE_FIELD_BITPOS (range_type
, 1);
1586 TYPE_LENGTH (*type
) = (upper
- lower
+ 1)
1587 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type
));
1593 error ("GDB internal error. cleanup_undefined_types with bad\
1594 type %d.", TYPE_CODE (*type
));
1598 undef_types_length
= 0;
1601 /* Skip rest of this symbol and return an error type.
1603 General notes on error recovery: error_type always skips to the
1604 end of the symbol (modulo cretinous dbx symbol name continuation).
1605 Thus code like this:
1607 if (*(*pp)++ != ';')
1608 return error_type (pp);
1610 is wrong because if *pp starts out pointing at '\0' (typically as the
1611 result of an earlier error), it will be incremented to point to the
1612 start of the next symbol, which might produce strange results, at least
1613 if you run off the end of the string table. Instead use
1616 return error_type (pp);
1622 foo = error_type (pp);
1626 And in case it isn't obvious, the point of all this hair is so the compiler
1627 can define new types and new syntaxes, and old versions of the
1628 debugger will be able to read the new symbol tables. */
1634 complain (&error_type_complaint
, 0);
1637 /* Skip to end of symbol. */
1638 while (**pp
!= '\0')
1641 /* Check for and handle cretinous dbx symbol name continuation! */
1642 if ((*pp
)[-1] == '\\')
1643 *pp
= next_symbol_text ();
1647 return builtin_type_error
;
1650 /* Read a dbx type reference or definition;
1651 return the type that is meant.
1652 This can be just a number, in which case it references
1653 a type already defined and placed in type_vector.
1654 Or the number can be followed by an =, in which case
1655 it means to define a new type according to the text that
1659 read_type (pp
, objfile
)
1661 struct objfile
*objfile
;
1663 register struct type
*type
= 0;
1668 /* Read type number if present. The type number may be omitted.
1669 for instance in a two-dimensional array declared with type
1670 "ar1;1;10;ar1;1;10;4". */
1671 if ((**pp
>= '0' && **pp
<= '9')
1674 read_type_number (pp
, typenums
);
1676 /* Type is not being defined here. Either it already exists,
1677 or this is a forward reference to it. dbx_alloc_type handles
1680 return dbx_alloc_type (typenums
, objfile
);
1682 /* Type is being defined here. */
1683 #if 0 /* Callers aren't prepared for a NULL result! FIXME -- metin! */
1687 /* if such a type already exists, this is an unnecessary duplication
1688 of the stab string, which is common in (RS/6000) xlc generated
1689 objects. In that case, simply return NULL and let the caller take
1692 tt
= *dbx_lookup_type (typenums
);
1693 if (tt
&& tt
->length
&& tt
->code
)
1702 /* 'typenums=' not present, type is anonymous. Read and return
1703 the definition, but don't put it in the type vector. */
1704 typenums
[0] = typenums
[1] = -1;
1712 enum type_code code
;
1714 /* Used to index through file_symbols. */
1715 struct pending
*ppt
;
1718 /* Name including "struct", etc. */
1721 /* Name without "struct", etc. */
1722 char *type_name_only
;
1728 /* Set the type code according to the following letter. */
1732 code
= TYPE_CODE_STRUCT
;
1736 code
= TYPE_CODE_UNION
;
1740 code
= TYPE_CODE_ENUM
;
1744 return error_type (pp
);
1747 to
= type_name
= (char *)
1748 obstack_alloc (&objfile
-> type_obstack
,
1750 ((char *) strchr (*pp
, ':') - (*pp
)) + 1));
1752 /* Copy the prefix. */
1754 while (*to
++ = *from
++)
1758 type_name_only
= to
;
1760 /* Copy the name. */
1762 while ((*to
++ = *from
++) != ':')
1766 /* Set the pointer ahead of the name which we just read. */
1770 /* The following hack is clearly wrong, because it doesn't
1771 check whether we are in a baseclass. I tried to reproduce
1772 the case that it is trying to fix, but I couldn't get
1773 g++ to put out a cross reference to a basetype. Perhaps
1774 it doesn't do it anymore. */
1775 /* Note: for C++, the cross reference may be to a base type which
1776 has not yet been seen. In this case, we skip to the comma,
1777 which will mark the end of the base class name. (The ':'
1778 at the end of the base class name will be skipped as well.)
1779 But sometimes (ie. when the cross ref is the last thing on
1780 the line) there will be no ','. */
1781 from
= (char *) strchr (*pp
, ',');
1787 /* Now check to see whether the type has already been declared. */
1788 /* This is necessary at least in the case where the
1789 program says something like
1791 The compiler puts out a cross-reference; we better find
1792 set the length of the structure correctly so we can
1793 set the length of the array. */
1794 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1795 for (i
= 0; i
< ppt
->nsyms
; i
++)
1797 struct symbol
*sym
= ppt
->symbol
[i
];
1799 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1800 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1801 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
1802 && !strcmp (SYMBOL_NAME (sym
), type_name_only
))
1804 obstack_free (&objfile
-> type_obstack
, type_name
);
1805 type
= SYMBOL_TYPE (sym
);
1810 /* Didn't find the type to which this refers, so we must
1811 be dealing with a forward reference. Allocate a type
1812 structure for it, and keep track of it so we can
1813 fill in the rest of the fields when we get the full
1815 type
= dbx_alloc_type (typenums
, objfile
);
1816 TYPE_CODE (type
) = code
;
1817 TYPE_NAME (type
) = type_name
;
1818 INIT_CPLUS_SPECIFIC(type
);
1819 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1821 add_undefined_type (type
);
1825 case '-': /* RS/6000 built-in type */
1827 type
= builtin_type (pp
); /* (in xcoffread.c) */
1842 read_type_number (pp
, xtypenums
);
1843 type
= *dbx_lookup_type (xtypenums
);
1848 type
= lookup_fundamental_type (objfile
, FT_VOID
);
1849 if (typenums
[0] != -1)
1850 *dbx_lookup_type (typenums
) = type
;
1854 type1
= read_type (pp
, objfile
);
1855 /* FIXME -- we should be doing smash_to_XXX types here. */
1857 /* postponed type decoration should be allowed. */
1858 if (typenums
[1] > 0 && typenums
[1] < type_vector_length
&&
1859 (type
= type_vector
[typenums
[1]])) {
1860 smash_to_pointer_type (type
, type1
);
1864 type
= lookup_pointer_type (type1
);
1865 if (typenums
[0] != -1)
1866 *dbx_lookup_type (typenums
) = type
;
1871 struct type
*domain
= read_type (pp
, objfile
);
1872 struct type
*memtype
;
1875 /* Invalid member type data format. */
1876 return error_type (pp
);
1879 memtype
= read_type (pp
, objfile
);
1880 type
= dbx_alloc_type (typenums
, objfile
);
1881 smash_to_member_type (type
, domain
, memtype
);
1886 if ((*pp
)[0] == '#')
1888 /* We'll get the parameter types from the name. */
1889 struct type
*return_type
;
1892 return_type
= read_type (pp
, objfile
);
1893 if (*(*pp
)++ != ';')
1894 complain (&invalid_member_complaint
, (char *) symnum
);
1895 type
= allocate_stub_method (return_type
);
1896 if (typenums
[0] != -1)
1897 *dbx_lookup_type (typenums
) = type
;
1901 struct type
*domain
= read_type (pp
, objfile
);
1902 struct type
*return_type
;
1905 if (*(*pp
)++ != ',')
1906 error ("invalid member type data format, at symtab pos %d.",
1909 return_type
= read_type (pp
, objfile
);
1910 args
= read_args (pp
, ';', objfile
);
1911 type
= dbx_alloc_type (typenums
, objfile
);
1912 smash_to_method_type (type
, domain
, return_type
, args
);
1917 type1
= read_type (pp
, objfile
);
1918 type
= lookup_reference_type (type1
);
1919 if (typenums
[0] != -1)
1920 *dbx_lookup_type (typenums
) = type
;
1924 type1
= read_type (pp
, objfile
);
1925 type
= lookup_function_type (type1
);
1926 if (typenums
[0] != -1)
1927 *dbx_lookup_type (typenums
) = type
;
1931 type
= read_range_type (pp
, typenums
, objfile
);
1932 if (typenums
[0] != -1)
1933 *dbx_lookup_type (typenums
) = type
;
1937 type
= dbx_alloc_type (typenums
, objfile
);
1938 type
= read_enum_type (pp
, type
, objfile
);
1939 *dbx_lookup_type (typenums
) = type
;
1943 type
= dbx_alloc_type (typenums
, objfile
);
1944 TYPE_NAME (type
) = type_synonym_name
;
1945 type_synonym_name
= 0;
1946 type
= read_struct_type (pp
, type
, objfile
);
1950 type
= dbx_alloc_type (typenums
, objfile
);
1951 TYPE_NAME (type
) = type_synonym_name
;
1952 type_synonym_name
= 0;
1953 type
= read_struct_type (pp
, type
, objfile
);
1954 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1959 return error_type (pp
);
1962 type
= dbx_alloc_type (typenums
, objfile
);
1963 type
= read_array_type (pp
, type
, objfile
);
1967 --*pp
; /* Go back to the symbol in error */
1968 /* Particularly important if it was \0! */
1969 return error_type (pp
);
1976 /* If this is an overriding temporary alteration for a header file's
1977 contents, and this type number is unknown in the global definition,
1978 put this type into the global definition at this type number. */
1979 if (header_file_prev_index
>= 0)
1981 register struct type
**tp
1982 = explicit_lookup_type (header_file_prev_index
, typenums
[1]);
1990 /* This page contains subroutines of read_type. */
1992 /* Read the description of a structure (or union type)
1993 and return an object describing the type. */
1995 static struct type
*
1996 read_struct_type (pp
, type
, objfile
)
1998 register struct type
*type
;
1999 struct objfile
*objfile
;
2001 /* Total number of methods defined in this class.
2002 If the class defines two `f' methods, and one `g' method,
2003 then this will have the value 3. */
2004 int total_length
= 0;
2008 struct nextfield
*next
;
2009 int visibility
; /* 0=public, 1=protected, 2=public */
2015 struct next_fnfield
*next
;
2016 struct fn_field fn_field
;
2019 struct next_fnfieldlist
2021 struct next_fnfieldlist
*next
;
2022 struct fn_fieldlist fn_fieldlist
;
2025 register struct nextfield
*list
= 0;
2026 struct nextfield
*new;
2029 int non_public_fields
= 0;
2032 register struct next_fnfieldlist
*mainlist
= 0;
2035 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2036 INIT_CPLUS_SPECIFIC(type
);
2038 /* First comes the total size in bytes. */
2040 TYPE_LENGTH (type
) = read_number (pp
, 0);
2042 /* C++: Now, if the class is a derived class, then the next character
2043 will be a '!', followed by the number of base classes derived from.
2044 Each element in the list contains visibility information,
2045 the offset of this base class in the derived structure,
2046 and then the base type. */
2049 int i
, n_baseclasses
, offset
;
2050 struct type
*baseclass
;
2053 /* Nonzero if it is a virtual baseclass, i.e.,
2057 struct C : public B, public virtual A {};
2059 B is a baseclass of C; A is a virtual baseclass for C. This is a C++
2060 2.0 language feature. */
2065 ALLOCATE_CPLUS_STRUCT_TYPE(type
);
2067 n_baseclasses
= read_number (pp
, ',');
2068 TYPE_FIELD_VIRTUAL_BITS (type
) =
2069 (B_TYPE
*) obstack_alloc (&objfile
-> type_obstack
,
2070 B_BYTES (n_baseclasses
));
2071 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), n_baseclasses
);
2073 for (i
= 0; i
< n_baseclasses
; i
++)
2076 *pp
= next_symbol_text ();
2087 /* Bad visibility format. */
2088 return error_type (pp
);
2096 non_public_fields
++;
2102 /* Bad visibility format. */
2103 return error_type (pp
);
2106 SET_TYPE_FIELD_VIRTUAL (type
, i
);
2109 /* Offset of the portion of the object corresponding to
2110 this baseclass. Always zero in the absence of
2111 multiple inheritance. */
2112 offset
= read_number (pp
, ',');
2113 baseclass
= read_type (pp
, objfile
);
2114 *pp
+= 1; /* skip trailing ';' */
2116 /* Make this baseclass visible for structure-printing purposes. */
2117 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2120 list
->visibility
= via_public
;
2121 list
->field
.type
= baseclass
;
2122 list
->field
.name
= type_name_no_tag (baseclass
);
2123 list
->field
.bitpos
= offset
;
2124 list
->field
.bitsize
= 0; /* this should be an unpacked field! */
2127 TYPE_N_BASECLASSES (type
) = n_baseclasses
;
2130 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
2131 At the end, we see a semicolon instead of a field.
2133 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2136 The `?' is a placeholder for one of '/2' (public visibility),
2137 '/1' (protected visibility), '/0' (private visibility), or nothing
2138 (C style symbol table, public visibility). */
2140 /* We better set p right now, in case there are no fields at all... */
2145 /* Check for and handle cretinous dbx symbol name continuation! */
2146 if (**pp
== '\\') *pp
= next_symbol_text ();
2148 /* Get space to record the next field's data. */
2149 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
2153 /* Get the field name. */
2155 if (*p
== CPLUS_MARKER
)
2157 /* Special GNU C++ name. */
2162 struct type
*context
;
2173 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2174 prefix
= "INVALID_C++_ABBREV";
2178 context
= read_type (pp
, objfile
);
2179 name
= type_name_no_tag (context
);
2182 complain (&invalid_cpp_type_complaint
, (char *) symnum
);
2183 TYPE_NAME (context
) = name
;
2185 list
->field
.name
= obconcat (&objfile
-> type_obstack
,
2189 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2190 list
->field
.type
= read_type (pp
, objfile
);
2191 (*pp
)++; /* Skip the comma. */
2192 list
->field
.bitpos
= read_number (pp
, ';');
2193 /* This field is unpacked. */
2194 list
->field
.bitsize
= 0;
2195 list
->visibility
= 0; /* private */
2196 non_public_fields
++;
2198 /* GNU C++ anonymous type. */
2202 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2208 while (*p
!= ':') p
++;
2209 list
->field
.name
= obsavestring (*pp
, p
- *pp
,
2210 &objfile
-> type_obstack
);
2212 /* C++: Check to see if we have hit the methods yet. */
2218 /* This means we have a visibility for a field coming. */
2224 list
->visibility
= 0; /* private */
2225 non_public_fields
++;
2230 list
->visibility
= 1; /* protected */
2231 non_public_fields
++;
2236 list
->visibility
= 2; /* public */
2241 else /* normal dbx-style format. */
2242 list
->visibility
= 2; /* public */
2244 list
->field
.type
= read_type (pp
, objfile
);
2247 /* Static class member. */
2248 list
->field
.bitpos
= (long)-1;
2250 while (*p
!= ';') p
++;
2251 list
->field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
2256 else if (**pp
!= ',')
2257 /* Bad structure-type format. */
2258 return error_type (pp
);
2260 (*pp
)++; /* Skip the comma. */
2261 list
->field
.bitpos
= read_number (pp
, ',');
2262 list
->field
.bitsize
= read_number (pp
, ';');
2265 /* FIXME-tiemann: Can't the compiler put out something which
2266 lets us distinguish these? (or maybe just not put out anything
2267 for the field). What is the story here? What does the compiler
2268 really do? Also, patch gdb.texinfo for this case; I document
2269 it as a possible problem there. Search for "DBX-style". */
2271 /* This is wrong because this is identical to the symbols
2272 produced for GCC 0-size arrays. For example:
2277 The code which dumped core in such circumstances should be
2278 fixed not to dump core. */
2280 /* g++ -g0 can put out bitpos & bitsize zero for a static
2281 field. This does not give us any way of getting its
2282 class, so we can't know its name. But we can just
2283 ignore the field so we don't dump core and other nasty
2285 if (list
->field
.bitpos
== 0
2286 && list
->field
.bitsize
== 0)
2288 complain (&dbx_class_complaint
, 0);
2289 /* Ignore this field. */
2295 /* Detect an unpacked field and mark it as such.
2296 dbx gives a bit size for all fields.
2297 Note that forward refs cannot be packed,
2298 and treat enums as if they had the width of ints. */
2299 if (TYPE_CODE (list
->field
.type
) != TYPE_CODE_INT
2300 && TYPE_CODE (list
->field
.type
) != TYPE_CODE_ENUM
)
2301 list
->field
.bitsize
= 0;
2302 if ((list
->field
.bitsize
== 8 * TYPE_LENGTH (list
->field
.type
)
2303 || (TYPE_CODE (list
->field
.type
) == TYPE_CODE_ENUM
2304 && (list
->field
.bitsize
2305 == 8 * TYPE_LENGTH (lookup_fundamental_type (objfile
, FT_INTEGER
)))
2309 list
->field
.bitpos
% 8 == 0)
2310 list
->field
.bitsize
= 0;
2316 /* chill the list of fields: the last entry (at the head)
2317 is a partially constructed entry which we now scrub. */
2320 /* Now create the vector of fields, and record how big it is.
2321 We need this info to record proper virtual function table information
2322 for this class's virtual functions. */
2324 TYPE_NFIELDS (type
) = nfields
;
2325 TYPE_FIELDS (type
) = (struct field
*)
2326 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct field
) * nfields
);
2328 if (non_public_fields
)
2330 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2332 TYPE_FIELD_PRIVATE_BITS (type
) =
2333 (B_TYPE
*) obstack_alloc (&objfile
-> type_obstack
,
2335 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2337 TYPE_FIELD_PROTECTED_BITS (type
) =
2338 (B_TYPE
*) obstack_alloc (&objfile
-> type_obstack
,
2340 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2343 /* Copy the saved-up fields into the field vector. */
2345 for (n
= nfields
; list
; list
= list
->next
)
2348 TYPE_FIELD (type
, n
) = list
->field
;
2349 if (list
->visibility
== 0)
2350 SET_TYPE_FIELD_PRIVATE (type
, n
);
2351 else if (list
->visibility
== 1)
2352 SET_TYPE_FIELD_PROTECTED (type
, n
);
2355 /* Now come the method fields, as NAME::methods
2356 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
2357 At the end, we see a semicolon instead of a field.
2359 For the case of overloaded operators, the format is
2360 op$::*.methods, where $ is the CPLUS_MARKER (usually '$'),
2361 `*' holds the place for an operator name (such as `+=')
2362 and `.' marks the end of the operator name. */
2365 /* Now, read in the methods. To simplify matters, we
2366 "unread" the name that has been read, so that we can
2367 start from the top. */
2369 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2370 /* For each list of method lists... */
2374 struct next_fnfield
*sublist
= 0;
2375 struct type
*look_ahead_type
= NULL
;
2377 struct next_fnfieldlist
*new_mainlist
=
2378 (struct next_fnfieldlist
*)alloca (sizeof (struct next_fnfieldlist
));
2383 /* read in the name. */
2384 while (*p
!= ':') p
++;
2385 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
2387 /* This is a completely wierd case. In order to stuff in the
2388 names that might contain colons (the usual name delimiter),
2389 Mike Tiemann defined a different name format which is
2390 signalled if the identifier is "op$". In that case, the
2391 format is "op$::XXXX." where XXXX is the name. This is
2392 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2393 /* This lets the user type "break operator+".
2394 We could just put in "+" as the name, but that wouldn't
2396 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
2397 char *o
= opname
+ 3;
2399 /* Skip past '::'. */
2401 if (**pp
== '\\') *pp
= next_symbol_text ();
2405 main_fn_name
= savestring (opname
, o
- opname
);
2411 main_fn_name
= savestring (*pp
, p
- *pp
);
2412 /* Skip past '::'. */
2415 new_mainlist
->fn_fieldlist
.name
= main_fn_name
;
2419 struct next_fnfield
*new_sublist
=
2420 (struct next_fnfield
*)alloca (sizeof (struct next_fnfield
));
2422 /* Check for and handle cretinous dbx symbol name continuation! */
2423 if (look_ahead_type
== NULL
) /* Normal case. */
2425 if (**pp
== '\\') *pp
= next_symbol_text ();
2427 new_sublist
->fn_field
.type
= read_type (pp
, objfile
);
2429 /* Invalid symtab info for method. */
2430 return error_type (pp
);
2433 { /* g++ version 1 kludge */
2434 new_sublist
->fn_field
.type
= look_ahead_type
;
2435 look_ahead_type
= NULL
;
2440 while (*p
!= ';') p
++;
2442 /* If this is just a stub, then we don't have the
2444 if (TYPE_FLAGS (new_sublist
->fn_field
.type
) & TYPE_FLAG_STUB
)
2445 new_sublist
->fn_field
.is_stub
= 1;
2446 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
2449 /* Set this method's visibility fields. */
2450 switch (*(*pp
)++ - '0')
2453 new_sublist
->fn_field
.is_private
= 1;
2456 new_sublist
->fn_field
.is_protected
= 1;
2460 if (**pp
== '\\') *pp
= next_symbol_text ();
2463 case 'A': /* Normal functions. */
2464 new_sublist
->fn_field
.is_const
= 0;
2465 new_sublist
->fn_field
.is_volatile
= 0;
2468 case 'B': /* `const' member functions. */
2469 new_sublist
->fn_field
.is_const
= 1;
2470 new_sublist
->fn_field
.is_volatile
= 0;
2473 case 'C': /* `volatile' member function. */
2474 new_sublist
->fn_field
.is_const
= 0;
2475 new_sublist
->fn_field
.is_volatile
= 1;
2478 case 'D': /* `const volatile' member function. */
2479 new_sublist
->fn_field
.is_const
= 1;
2480 new_sublist
->fn_field
.is_volatile
= 1;
2483 case '*': /* File compiled with g++ version 1 -- no info */
2488 complain (&const_vol_complaint
, (char *) (long) **pp
);
2495 /* virtual member function, followed by index. */
2496 /* The sign bit is set to distinguish pointers-to-methods
2497 from virtual function indicies. Since the array is
2498 in words, the quantity must be shifted left by 1
2499 on 16 bit machine, and by 2 on 32 bit machine, forcing
2500 the sign bit out, and usable as a valid index into
2501 the array. Remove the sign bit here. */
2502 new_sublist
->fn_field
.voffset
=
2503 (0x7fffffff & read_number (pp
, ';')) + 2;
2505 if (**pp
== '\\') *pp
= next_symbol_text ();
2507 if (**pp
== ';' || **pp
== '\0')
2508 /* Must be g++ version 1. */
2509 new_sublist
->fn_field
.fcontext
= 0;
2512 /* Figure out from whence this virtual function came.
2513 It may belong to virtual function table of
2514 one of its baseclasses. */
2515 look_ahead_type
= read_type (pp
, objfile
);
2517 { /* g++ version 1 overloaded methods. */ }
2520 new_sublist
->fn_field
.fcontext
= look_ahead_type
;
2522 return error_type (pp
);
2525 look_ahead_type
= NULL
;
2531 /* static member function. */
2532 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
2533 if (strncmp (new_sublist
->fn_field
.physname
,
2534 main_fn_name
, strlen (main_fn_name
)))
2535 new_sublist
->fn_field
.is_stub
= 1;
2540 complain (&member_fn_complaint
, (char *) (long) (*pp
)[-1]);
2541 /* Fall through into normal member function. */
2544 /* normal member function. */
2545 new_sublist
->fn_field
.voffset
= 0;
2546 new_sublist
->fn_field
.fcontext
= 0;
2550 new_sublist
->next
= sublist
;
2551 sublist
= new_sublist
;
2553 if (**pp
== '\\') *pp
= next_symbol_text ();
2555 while (**pp
!= ';' && **pp
!= '\0');
2559 new_mainlist
->fn_fieldlist
.fn_fields
=
2560 (struct fn_field
*) obstack_alloc (&objfile
-> type_obstack
,
2561 sizeof (struct fn_field
) * length
);
2562 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
2563 new_mainlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
2565 new_mainlist
->fn_fieldlist
.length
= length
;
2566 new_mainlist
->next
= mainlist
;
2567 mainlist
= new_mainlist
;
2569 total_length
+= length
;
2571 while (**pp
!= ';');
2579 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2580 obstack_alloc (&objfile
-> type_obstack
,
2581 sizeof (struct fn_fieldlist
) * nfn_fields
);
2582 TYPE_NFN_FIELDS (type
) = nfn_fields
;
2583 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2588 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
2589 TYPE_NFN_FIELDS_TOTAL (type
) +=
2590 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, i
));
2593 for (n
= nfn_fields
; mainlist
; mainlist
= mainlist
->next
) {
2594 --n
; /* Circumvent Sun3 compiler bug */
2595 TYPE_FN_FIELDLISTS (type
)[n
] = mainlist
->fn_fieldlist
;
2602 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
2604 /* Obsolete flags that used to indicate the presence
2605 of constructors and/or destructors. */
2609 /* Read either a '%' or the final ';'. */
2610 if (*(*pp
)++ == '%')
2612 /* We'd like to be able to derive the vtable pointer field
2613 from the type information, but when it's inherited, that's
2614 hard. A reason it's hard is because we may read in the
2615 info about a derived class before we read in info about
2616 the base class that provides the vtable pointer field.
2617 Once the base info has been read, we could fill in the info
2618 for the derived classes, but for the fact that by then,
2619 we don't remember who needs what. */
2621 int predicted_fieldno
= -1;
2623 /* Now we must record the virtual function table pointer's
2624 field information. */
2632 /* In version 2, we derive the vfield ourselves. */
2633 for (n
= 0; n
< nfields
; n
++)
2635 if (! strncmp (TYPE_FIELD_NAME (type
, n
), vptr_name
,
2636 sizeof (vptr_name
) -1))
2638 predicted_fieldno
= n
;
2642 if (predicted_fieldno
< 0)
2643 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
2644 if (! TYPE_FIELD_VIRTUAL (type
, n
)
2645 && TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
)) >= 0)
2647 predicted_fieldno
= TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
));
2653 t
= read_type (pp
, objfile
);
2655 while (*p
!= '\0' && *p
!= ';')
2658 /* Premature end of symbol. */
2659 return error_type (pp
);
2661 TYPE_VPTR_BASETYPE (type
) = t
;
2664 if (TYPE_FIELD_NAME (t
, TYPE_N_BASECLASSES (t
)) == 0)
2666 /* FIXME-tiemann: what's this? */
2668 TYPE_VPTR_FIELDNO (type
) = i
= TYPE_N_BASECLASSES (t
);
2673 else for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); --i
)
2674 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
2675 sizeof (vptr_name
) -1))
2677 TYPE_VPTR_FIELDNO (type
) = i
;
2681 /* Virtual function table field not found. */
2682 return error_type (pp
);
2685 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2688 if (TYPE_VPTR_FIELDNO (type
) != predicted_fieldno
)
2689 error ("TYPE_VPTR_FIELDNO miscalculated");
2699 /* Read a definition of an array type,
2700 and create and return a suitable type object.
2701 Also creates a range type which represents the bounds of that
2703 static struct type
*
2704 read_array_type (pp
, type
, objfile
)
2706 register struct type
*type
;
2707 struct objfile
*objfile
;
2709 struct type
*index_type
, *element_type
, *range_type
;
2713 /* Format of an array type:
2714 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2717 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2718 for these, produce a type like float[][]. */
2720 index_type
= read_type (pp
, objfile
);
2722 /* Improper format of array type decl. */
2723 return error_type (pp
);
2726 if (!(**pp
>= '0' && **pp
<= '9'))
2731 lower
= read_number (pp
, ';');
2733 if (!(**pp
>= '0' && **pp
<= '9'))
2738 upper
= read_number (pp
, ';');
2740 element_type
= read_type (pp
, objfile
);
2749 /* Create range type. */
2750 range_type
= (struct type
*)
2751 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
2752 bzero (range_type
, sizeof (struct type
));
2753 TYPE_OBJFILE (range_type
) = objfile
;
2754 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
2755 TYPE_TARGET_TYPE (range_type
) = index_type
;
2757 /* This should never be needed. */
2758 TYPE_LENGTH (range_type
) = sizeof (int);
2760 TYPE_NFIELDS (range_type
) = 2;
2761 TYPE_FIELDS (range_type
) =
2762 (struct field
*) obstack_alloc (&objfile
-> type_obstack
,
2763 2 * sizeof (struct field
));
2764 TYPE_FIELD_BITPOS (range_type
, 0) = lower
;
2765 TYPE_FIELD_BITPOS (range_type
, 1) = upper
;
2768 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
2769 TYPE_TARGET_TYPE (type
) = element_type
;
2770 TYPE_LENGTH (type
) = (upper
- lower
+ 1) * TYPE_LENGTH (element_type
);
2771 TYPE_NFIELDS (type
) = 1;
2772 TYPE_FIELDS (type
) =
2773 (struct field
*) obstack_alloc (&objfile
-> type_obstack
,
2774 sizeof (struct field
));
2775 TYPE_FIELD_TYPE (type
, 0) = range_type
;
2777 /* If we have an array whose element type is not yet known, but whose
2778 bounds *are* known, record it to be adjusted at the end of the file. */
2779 if (TYPE_LENGTH (element_type
) == 0 && !adjustable
)
2780 add_undefined_type (type
);
2786 /* Read a definition of an enumeration type,
2787 and create and return a suitable type object.
2788 Also defines the symbols that represent the values of the type. */
2790 static struct type
*
2791 read_enum_type (pp
, type
, objfile
)
2793 register struct type
*type
;
2794 struct objfile
*objfile
;
2799 register struct symbol
*sym
;
2801 struct pending
**symlist
;
2802 struct pending
*osyms
, *syms
;
2805 if (within_function
)
2806 symlist
= &local_symbols
;
2808 symlist
= &file_symbols
;
2810 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2812 /* Read the value-names and their values.
2813 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2814 A semicolon or comma instead of a NAME means the end. */
2815 while (**pp
&& **pp
!= ';' && **pp
!= ',')
2817 /* Check for and handle cretinous dbx symbol name continuation! */
2818 if (**pp
== '\\') *pp
= next_symbol_text ();
2821 while (*p
!= ':') p
++;
2822 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
2824 n
= read_number (pp
, ',');
2826 sym
= (struct symbol
*) obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2827 bzero (sym
, sizeof (struct symbol
));
2828 SYMBOL_NAME (sym
) = name
;
2829 SYMBOL_CLASS (sym
) = LOC_CONST
;
2830 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2831 SYMBOL_VALUE (sym
) = n
;
2832 add_symbol_to_list (sym
, symlist
);
2837 (*pp
)++; /* Skip the semicolon. */
2839 /* Now fill in the fields of the type-structure. */
2841 TYPE_LENGTH (type
) = sizeof (int);
2842 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2843 TYPE_NFIELDS (type
) = nsyms
;
2844 TYPE_FIELDS (type
) = (struct field
*)
2845 obstack_alloc (&objfile
-> type_obstack
,
2846 sizeof (struct field
) * nsyms
);
2848 /* Find the symbols for the values and put them into the type.
2849 The symbols can be found in the symlist that we put them on
2850 to cause them to be defined. osyms contains the old value
2851 of that symlist; everything up to there was defined by us. */
2852 /* Note that we preserve the order of the enum constants, so
2853 that in something like "enum {FOO, LAST_THING=FOO}" we print
2854 FOO, not LAST_THING. */
2856 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2861 for (; j
< syms
->nsyms
; j
++,n
++)
2863 struct symbol
*xsym
= syms
->symbol
[j
];
2864 SYMBOL_TYPE (xsym
) = type
;
2865 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2866 TYPE_FIELD_VALUE (type
, n
) = 0;
2867 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2868 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2875 /* This screws up perfectly good C programs with enums. FIXME. */
2876 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2877 if(TYPE_NFIELDS(type
) == 2 &&
2878 ((!strcmp(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2879 !strcmp(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2880 (!strcmp(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2881 !strcmp(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2882 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2888 /* Read a number from the string pointed to by *PP.
2889 The value of *PP is advanced over the number.
2890 If END is nonzero, the character that ends the
2891 number must match END, or an error happens;
2892 and that character is skipped if it does match.
2893 If END is zero, *PP is left pointing to that character.
2895 If the number fits in a long, set *VALUE and set *BITS to 0.
2896 If not, set *BITS to be the number of bits in the number.
2898 If encounter garbage, set *BITS to -1. */
2901 read_huge_number (pp
, end
, valu
, bits
)
2922 /* Leading zero means octal. GCC uses this to output values larger
2923 than an int (because that would be hard in decimal). */
2930 upper_limit
= LONG_MAX
/ radix
;
2931 while ((c
= *p
++) >= '0' && c
<= ('0' + radix
))
2933 if (n
<= upper_limit
)
2936 n
+= c
- '0'; /* FIXME this overflows anyway */
2941 /* This depends on large values being output in octal, which is
2948 /* Ignore leading zeroes. */
2952 else if (c
== '2' || c
== '3')
2978 /* Large decimal constants are an error (because it is hard to
2979 count how many bits are in them). */
2985 /* -0x7f is the same as 0x80. So deal with it by adding one to
2986 the number of bits. */
3001 #define MAX_OF_C_TYPE(t) ((1 << (sizeof (t)*8 - 1)) - 1)
3002 #define MIN_OF_C_TYPE(t) (-(1 << (sizeof (t)*8 - 1)))
3004 static struct type
*
3005 read_range_type (pp
, typenums
, objfile
)
3008 struct objfile
*objfile
;
3014 struct type
*result_type
;
3016 /* First comes a type we are a subrange of.
3017 In C it is usually 0, 1 or the type being defined. */
3018 read_type_number (pp
, rangenums
);
3019 self_subrange
= (rangenums
[0] == typenums
[0] &&
3020 rangenums
[1] == typenums
[1]);
3022 /* A semicolon should now follow; skip it. */
3026 /* The remaining two operands are usually lower and upper bounds
3027 of the range. But in some special cases they mean something else. */
3028 read_huge_number (pp
, ';', &n2
, &n2bits
);
3029 read_huge_number (pp
, ';', &n3
, &n3bits
);
3031 if (n2bits
== -1 || n3bits
== -1)
3032 return error_type (pp
);
3034 /* If limits are huge, must be large integral type. */
3035 if (n2bits
!= 0 || n3bits
!= 0)
3037 char got_signed
= 0;
3038 char got_unsigned
= 0;
3039 /* Number of bits in the type. */
3042 /* Range from 0 to <large number> is an unsigned large integral type. */
3043 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
3048 /* Range from <large number> to <large number>-1 is a large signed
3050 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
3056 /* Check for "long long". */
3057 if (got_signed
&& nbits
== TARGET_LONG_LONG_BIT
)
3058 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
3059 if (got_unsigned
&& nbits
== TARGET_LONG_LONG_BIT
)
3060 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
3062 if (got_signed
|| got_unsigned
)
3064 result_type
= (struct type
*)
3065 obstack_alloc (&objfile
-> type_obstack
,
3066 sizeof (struct type
));
3067 bzero (result_type
, sizeof (struct type
));
3068 TYPE_OBJFILE (result_type
) = objfile
;
3069 TYPE_LENGTH (result_type
) = nbits
/ TARGET_CHAR_BIT
;
3070 TYPE_CODE (result_type
) = TYPE_CODE_INT
;
3072 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
3076 return error_type (pp
);
3079 /* A type defined as a subrange of itself, with bounds both 0, is void. */
3080 if (self_subrange
&& n2
== 0 && n3
== 0)
3081 return (lookup_fundamental_type (objfile
, FT_VOID
));
3083 /* If n3 is zero and n2 is not, we want a floating type,
3084 and n2 is the width in bytes.
3086 Fortran programs appear to use this for complex types also,
3087 and they give no way to distinguish between double and single-complex!
3088 We don't have complex types, so we would lose on all fortran files!
3089 So return type `double' for all of those. It won't work right
3090 for the complex values, but at least it makes the file loadable.
3092 FIXME, we may be able to distinguish these by their names. FIXME. */
3094 if (n3
== 0 && n2
> 0)
3096 if (n2
== sizeof (float))
3097 return (lookup_fundamental_type (objfile
, FT_FLOAT
));
3098 return (lookup_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
));
3101 /* If the upper bound is -1, it must really be an unsigned int. */
3103 else if (n2
== 0 && n3
== -1)
3105 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
3106 long' is to look at its name! */
3108 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
3109 long_kludge_name
[9] == 'l' /* long */)
3110 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
3111 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
3113 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
3116 /* Special case: char is defined (Who knows why) as a subrange of
3117 itself with range 0-127. */
3118 else if (self_subrange
&& n2
== 0 && n3
== 127)
3119 return (lookup_fundamental_type (objfile
, FT_CHAR
));
3121 /* Assumptions made here: Subrange of self is equivalent to subrange
3122 of int. FIXME: Host and target type-sizes assumed the same. */
3123 /* FIXME: This is the *only* place in GDB that depends on comparing
3124 some type to a builtin type with ==. Fix it! */
3126 && (self_subrange
||
3127 *dbx_lookup_type (rangenums
) == lookup_fundamental_type (objfile
, FT_INTEGER
)))
3129 /* an unsigned type */
3131 if (n3
== - sizeof (long long))
3132 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
3134 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
3135 long' is to look at its name! */
3136 if (n3
== (unsigned long)~0L &&
3137 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
3138 long_kludge_name
[9] == 'l' /* long */)
3139 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
3140 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
3141 if (n3
== (unsigned int)~0L)
3142 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
3143 if (n3
== (unsigned short)~0L)
3144 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_SHORT
));
3145 if (n3
== (unsigned char)~0L)
3146 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_CHAR
));
3149 else if (n3
== 0 && n2
== -sizeof (long long))
3150 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
3152 else if (n2
== -n3
-1)
3155 /* FIXME -- the only way to distinguish `int' from `long' is to look
3157 if ((n3
== (1 << (8 * sizeof (long) - 1)) - 1) &&
3158 long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
3159 return (lookup_fundamental_type (objfile
, FT_LONG
));
3160 if (n3
== (1 << (8 * sizeof (int) - 1)) - 1)
3161 return (lookup_fundamental_type (objfile
, FT_INTEGER
));
3162 if (n3
== (1 << (8 * sizeof (short) - 1)) - 1)
3163 return (lookup_fundamental_type (objfile
, FT_SHORT
));
3164 if (n3
== (1 << (8 * sizeof (char) - 1)) - 1)
3165 return (lookup_fundamental_type (objfile
, FT_CHAR
));
3168 /* We have a real range type on our hands. Allocate space and
3169 return a real pointer. */
3171 /* At this point I don't have the faintest idea how to deal with
3172 a self_subrange type; I'm going to assume that this is used
3173 as an idiom, and that all of them are special cases. So . . . */
3175 return error_type (pp
);
3177 result_type
= (struct type
*)
3178 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
3179 bzero (result_type
, sizeof (struct type
));
3180 TYPE_OBJFILE (result_type
) = objfile
;
3182 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
3184 TYPE_TARGET_TYPE (result_type
) = *dbx_lookup_type(rangenums
);
3185 if (TYPE_TARGET_TYPE (result_type
) == 0) {
3186 complain (&range_type_base_complaint
, (char *) rangenums
[1]);
3187 TYPE_TARGET_TYPE (result_type
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
3190 TYPE_NFIELDS (result_type
) = 2;
3191 TYPE_FIELDS (result_type
) =
3192 (struct field
*) obstack_alloc (&objfile
-> type_obstack
,
3193 2 * sizeof (struct field
));
3194 bzero (TYPE_FIELDS (result_type
), 2 * sizeof (struct field
));
3195 TYPE_FIELD_BITPOS (result_type
, 0) = n2
;
3196 TYPE_FIELD_BITPOS (result_type
, 1) = n3
;
3198 TYPE_LENGTH (result_type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type
));
3203 /* Read a number from the string pointed to by *PP.
3204 The value of *PP is advanced over the number.
3205 If END is nonzero, the character that ends the
3206 number must match END, or an error happens;
3207 and that character is skipped if it does match.
3208 If END is zero, *PP is left pointing to that character. */
3211 read_number (pp
, end
)
3215 register char *p
= *pp
;
3216 register long n
= 0;
3220 /* Handle an optional leading minus sign. */
3228 /* Read the digits, as far as they go. */
3230 while ((c
= *p
++) >= '0' && c
<= '9')
3238 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c
, symnum
);
3247 /* Read in an argument list. This is a list of types, separated by commas
3248 and terminated with END. Return the list of types read in, or (struct type
3249 **)-1 if there is an error. */
3250 static struct type
**
3251 read_args (pp
, end
, objfile
)
3254 struct objfile
*objfile
;
3256 /* FIXME! Remove this arbitrary limit! */
3257 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
3263 /* Invalid argument list: no ','. */
3264 return (struct type
**)-1;
3267 /* Check for and handle cretinous dbx symbol name continuation! */
3269 *pp
= next_symbol_text ();
3271 types
[n
++] = read_type (pp
, objfile
);
3273 *pp
+= 1; /* get past `end' (the ':' character) */
3277 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
3279 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
3281 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
3282 bzero (rval
+ n
, sizeof (struct type
*));
3286 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
3288 memcpy (rval
, types
, n
* sizeof (struct type
*));
3292 /* Add a common block's start address to the offset of each symbol
3293 declared to be in it (by being between a BCOMM/ECOMM pair that uses
3294 the common block name). */
3297 fix_common_block (sym
, valu
)
3301 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
3302 for ( ; next
; next
= next
->next
)
3305 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
3306 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
3310 /* Initializer for this module */
3312 _initialize_buildsym ()
3314 undef_types_allocated
= 20;
3315 undef_types_length
= 0;
3316 undef_types
= (struct type
**) xmalloc (undef_types_allocated
*
3317 sizeof (struct type
*));