1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1986-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 three functions: dbx_symfile_init,
21 which initializes to read a symbol file; dbx_new_init, which
22 discards existing cached information when all symbols are being
23 discarded; and dbx_symfile_read, which reads a symbol table
26 dbx_symfile_read only does the minimum work necessary for letting the
27 user "name" things symbolically; it does not read the entire symtab.
28 Instead, it reads the external and static symbols and puts them in partial
29 symbol tables. When more extensive information is requested of a
30 file, the corresponding partial symbol table is mutated into a full
31 fledged symbol table by going back and reading the symbols
32 for real. dbx_psymtab_to_symtab() is the function that does this */
40 #include <sys/types.h>
46 #include "a.out.gnu.h"
47 #include "stab.gnu.h" /* We always use GNU stabs, not native, now */
52 * Define specifically gnu symbols here.
55 /* The following type indicates the definition of a symbol as being
56 an indirect reference to another symbol. The other symbol
57 appears as an undefined reference, immediately following this symbol.
59 Indirection is asymmetrical. The other symbol's value will be used
60 to satisfy requests for the indirect symbol, but not vice versa.
61 If the other symbol does not have a definition, libraries will
62 be searched to find a definition. */
67 /* The following symbols refer to set elements.
68 All the N_SET[ATDB] symbols with the same name form one set.
69 Space is allocated for the set in the text section, and each set
70 element's value is stored into one word of the space.
71 The first word of the space is the length of the set (number of elements).
73 The address of the set is made into an N_SETV symbol
74 whose name is the same as the name of the set.
75 This symbol acts like a N_DATA global symbol
76 in that it can satisfy undefined external references. */
79 #define N_SETA 0x14 /* Absolute set element symbol */
80 #endif /* This is input to LD, in a .o file. */
83 #define N_SETT 0x16 /* Text set element symbol */
84 #endif /* This is input to LD, in a .o file. */
87 #define N_SETD 0x18 /* Data set element symbol */
88 #endif /* This is input to LD, in a .o file. */
91 #define N_SETB 0x1A /* Bss set element symbol */
92 #endif /* This is input to LD, in a .o file. */
94 /* Macros dealing with the set element symbols defined in a.out.h */
95 #define SET_ELEMENT_P(x) ((x)>=N_SETA&&(x)<=(N_SETB|N_EXT))
96 #define TYPE_OF_SET_ELEMENT(x) ((x)-N_SETA+N_ABS)
99 #define N_SETV 0x1C /* Pointer to set vector in data area. */
100 #endif /* This is output from LD. */
103 #define N_WARNING 0x1E /* Warning message to print if file included */
104 #endif /* This is input to ld */
106 #endif /* NO_GNU_STABS */
109 #include <sys/param.h>
110 #include <sys/file.h>
111 #include <sys/stat.h>
113 #include "breakpoint.h"
116 #include "gdbcore.h" /* for bfd stuff */
117 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
120 struct dbx_symfile_info
{
121 asection
*text_sect
; /* Text section accessor */
122 int symcount
; /* How many symbols are there in the file */
123 char *stringtab
; /* The actual string table */
124 int stringtab_size
; /* Its size */
125 off_t symtab_offset
; /* Offset in file to symbol table */
126 int desc
; /* File descriptor of symbol file */
129 extern void qsort ();
130 extern double atof ();
131 extern struct cmd_list_element
*cmdlist
;
133 extern void symbol_file_command ();
135 /* Forward declarations */
137 static void add_symbol_to_list ();
138 static void read_dbx_symtab ();
139 static void init_psymbol_list ();
140 static void process_one_symbol ();
141 static struct type
*read_type ();
142 static struct type
*read_range_type ();
143 static struct type
*read_enum_type ();
144 static struct type
*read_struct_type ();
145 static struct type
*read_array_type ();
146 static long read_number ();
147 static void finish_block ();
148 static struct blockvector
*make_blockvector ();
149 static struct symbol
*define_symbol ();
150 static void start_subfile ();
151 static int hashname ();
152 static struct pending
*copy_pending ();
153 static void fix_common_block ();
154 static void add_undefined_type ();
155 static void cleanup_undefined_types ();
156 static void scan_file_globals ();
157 static struct symtab
*read_ofile_symtab ();
158 static void dbx_psymtab_to_symtab ();
161 static struct type
**read_args ();
163 static const char vptr_name
[] = { '_','v','p','t','r',CPLUS_MARKER
,'\0' };
164 static const char vb_name
[] = { '_','v','b',CPLUS_MARKER
,'\0' };
166 /* Macro to determine which symbols to ignore when reading the first symbol
167 of a file. Some machines override this definition. */
168 #ifndef IGNORE_SYMBOL
169 /* This code is used on Ultrix systems. Ignore it */
170 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
173 /* Macro for name of symbol to indicate a file compiled with gcc. */
174 #ifndef GCC_COMPILED_FLAG_SYMBOL
175 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
178 /* Convert stab register number (from `r' declaration) to a gdb REGNUM. */
180 #ifndef STAB_REG_TO_REGNUM
181 #define STAB_REG_TO_REGNUM(VALUE) (VALUE)
184 /* Define this as 1 if a pcc declaration of a char or short argument
185 gives the correct address. Otherwise assume pcc gives the
186 address of the corresponding int, which is not the same on a
187 big-endian machine. */
189 #ifndef BELIEVE_PCC_PROMOTION
190 #define BELIEVE_PCC_PROMOTION 0
193 /* Nonzero means give verbose info on gdb action. From main.c. */
194 extern int info_verbose
;
196 /* Name of source file whose symbol data we are now processing.
197 This comes from a symbol of type N_SO. */
199 static char *last_source_file
;
201 /* Core address of start of text of current source file.
202 This too comes from the N_SO symbol. */
204 static CORE_ADDR last_source_start_addr
;
206 /* The entry point of a file we are reading. */
207 CORE_ADDR entry_point
;
209 /* The list of sub-source-files within the current individual compilation.
210 Each file gets its own symtab with its own linetable and associated info,
211 but they all share one blockvector. */
215 struct subfile
*next
;
218 struct linetable
*line_vector
;
219 int line_vector_length
;
220 int line_vector_index
;
221 int prev_line_number
;
224 static struct subfile
*subfiles
;
226 static struct subfile
*current_subfile
;
228 /* Count symbols as they are processed, for error messages. */
230 static unsigned int symnum
;
232 /* Vector of types defined so far, indexed by their dbx type numbers.
233 (In newer sun systems, dbx uses a pair of numbers in parens,
234 as in "(SUBFILENUM,NUMWITHINSUBFILE)". Then these numbers must be
235 translated through the type_translations hash table to get
236 the index into the type vector.) */
238 static struct typevector
*type_vector
;
240 /* Number of elements allocated for type_vector currently. */
242 static int type_vector_length
;
244 /* Vector of line number information. */
246 static struct linetable
*line_vector
;
248 /* Index of next entry to go in line_vector_index. */
250 static int line_vector_index
;
252 /* Last line number recorded in the line vector. */
254 static int prev_line_number
;
256 /* Number of elements allocated for line_vector currently. */
258 static int line_vector_length
;
260 /* Hash table of global symbols whose values are not known yet.
261 They are chained thru the SYMBOL_VALUE_CHAIN, since we don't
262 have the correct data for that slot yet. */
263 /* The use of the LOC_BLOCK code in this chain is nonstandard--
264 it refers to a FORTRAN common block rather than the usual meaning. */
267 static struct symbol
*global_sym_chain
[HASHSIZE
];
269 /* Record the symbols defined for each context in a list.
270 We don't create a struct block for the context until we
271 know how long to make it. */
273 #define PENDINGSIZE 100
277 struct pending
*next
;
279 struct symbol
*symbol
[PENDINGSIZE
];
282 /* List of free `struct pending' structures for reuse. */
283 struct pending
*free_pendings
;
285 /* Here are the three lists that symbols are put on. */
287 struct pending
*file_symbols
; /* static at top level, and types */
289 struct pending
*global_symbols
; /* global functions and variables */
291 struct pending
*local_symbols
; /* everything local to lexical context */
293 /* List of symbols declared since the last BCOMM. This list is a tail
294 of local_symbols. When ECOMM is seen, the symbols on the list
295 are noted so their proper addresses can be filled in later,
296 using the common block base address gotten from the assembler
299 struct pending
*common_block
;
302 /* Stack representing unclosed lexical contexts
303 (that will become blocks, eventually). */
307 struct pending
*locals
;
308 struct pending_block
*old_blocks
;
310 CORE_ADDR start_addr
;
311 CORE_ADDR end_addr
; /* Temp slot for exception handling. */
315 struct context_stack
*context_stack
;
317 /* Index of first unused entry in context stack. */
318 int context_stack_depth
;
320 /* Currently allocated size of context stack. */
322 int context_stack_size
;
324 /* Nonzero if within a function (so symbols should be local,
325 if nothing says specifically). */
329 /* List of blocks already made (lexical contexts already closed).
330 This is used at the end to make the blockvector. */
334 struct pending_block
*next
;
338 struct pending_block
*pending_blocks
;
340 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
341 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
343 /* Global variable which, when set, indicates that we are processing a
344 .o file compiled with gcc */
346 static unsigned char processing_gcc_compilation
;
348 /* Make a list of forward references which haven't been defined. */
349 static struct type
**undef_types
;
350 static int undef_types_allocated
, undef_types_length
;
352 /* String table for the main symbol file. It is kept in memory
353 permanently, to speed up symbol reading. Other files' symbol tables
354 are read in on demand. FIXME, this should be cleaner. */
356 static char *symfile_string_table
;
357 static int symfile_string_table_size
;
359 /* Setup a define to deal cleanly with the underscore problem */
361 #ifdef NAMES_HAVE_UNDERSCORE
362 #define HASH_OFFSET 1
364 #define HASH_OFFSET 0
367 /* Complaints about the symbols we have encountered. */
369 struct complaint innerblock_complaint
=
370 {"inner block not inside outer block in %s", 0, 0};
372 struct complaint blockvector_complaint
=
373 {"block at %x out of order", 0, 0};
375 struct complaint lbrac_complaint
=
376 {"bad block start address patched", 0, 0};
379 struct complaint dbx_class_complaint
=
380 {"encountered DBX-style class variable debugging information.\n\
381 You seem to have compiled your program with \
382 \"g++ -g0\" instead of \"g++ -g\".\n\
383 Therefore GDB will not know about your class variables", 0, 0};
386 struct complaint string_table_offset_complaint
=
387 {"bad string table offset in symbol %d", 0, 0};
389 struct complaint unknown_symtype_complaint
=
390 {"unknown symbol type 0x%x", 0, 0};
392 struct complaint lbrac_rbrac_complaint
=
393 {"block start larger than block end", 0, 0};
395 struct complaint const_vol_complaint
=
396 {"const/volatile indicator missing, got '%c'", 0, 0};
398 struct complaint error_type_complaint
=
399 {"C++ type mismatch between compiler and debugger", 0, 0};
401 struct complaint invalid_member_complaint
=
402 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
404 /* Support for Sun changes to dbx symbol format */
406 /* For each identified header file, we have a table of types defined
409 header_files maps header file names to their type tables.
410 It is a vector of n_header_files elements.
411 Each element describes one header file.
412 It contains a vector of types.
414 Sometimes it can happen that the same header file produces
415 different results when included in different places.
416 This can result from conditionals or from different
417 things done before including the file.
418 When this happens, there are multiple entries for the file in this table,
419 one entry for each distinct set of results.
420 The entries are distinguished by the INSTANCE field.
421 The INSTANCE field appears in the N_BINCL and N_EXCL symbol table and is
422 used to match header-file references to their corresponding data. */
426 char *name
; /* Name of header file */
427 int instance
; /* Numeric code distinguishing instances
428 of one header file that produced
429 different results when included.
430 It comes from the N_BINCL or N_EXCL. */
431 struct type
**vector
; /* Pointer to vector of types */
432 int length
; /* Allocated length (# elts) of that vector */
435 static struct header_file
*header_files
= 0;
437 static int n_header_files
;
439 static int n_allocated_header_files
;
441 /* During initial symbol readin, we need to have a structure to keep
442 track of which psymtabs have which bincls in them. This structure
443 is used during readin to setup the list of dependencies within each
444 partial symbol table. */
446 struct header_file_location
448 char *name
; /* Name of header file */
449 int instance
; /* See above */
450 struct partial_symtab
*pst
; /* Partial symtab that has the
451 BINCL/EINCL defs for this file */
454 /* The actual list and controling variables */
455 static struct header_file_location
*bincl_list
, *next_bincl
;
456 static int bincls_allocated
;
458 /* Within each object file, various header files are assigned numbers.
459 A type is defined or referred to with a pair of numbers
460 (FILENUM,TYPENUM) where FILENUM is the number of the header file
461 and TYPENUM is the number within that header file.
462 TYPENUM is the index within the vector of types for that header file.
464 FILENUM == 1 is special; it refers to the main source of the object file,
465 and not to any header file. FILENUM != 1 is interpreted by looking it up
466 in the following table, which contains indices in header_files. */
468 static int *this_object_header_files
= 0;
470 static int n_this_object_header_files
;
472 static int n_allocated_this_object_header_files
;
474 /* When a header file is getting special overriding definitions
475 for one source file, record here the header_files index
476 of its normal definition vector.
477 At other times, this is -1. */
479 static int header_file_prev_index
;
481 /* Free up old header file tables, and allocate new ones.
482 We're reading a new symbol file now. */
485 free_and_init_header_files ()
488 for (i
= 0; i
< n_header_files
; i
++)
489 free (header_files
[i
].name
);
490 if (header_files
) /* First time null */
492 if (this_object_header_files
) /* First time null */
493 free (this_object_header_files
);
495 n_allocated_header_files
= 10;
496 header_files
= (struct header_file
*) xmalloc (10 * sizeof (struct header_file
));
499 n_allocated_this_object_header_files
= 10;
500 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
503 /* Called at the start of each object file's symbols.
504 Clear out the mapping of header file numbers to header files. */
507 new_object_header_files ()
509 /* Leave FILENUM of 0 free for builtin types and this file's types. */
510 n_this_object_header_files
= 1;
511 header_file_prev_index
= -1;
514 /* Add header file number I for this object file
515 at the next successive FILENUM. */
518 add_this_object_header_file (i
)
521 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
523 n_allocated_this_object_header_files
*= 2;
524 this_object_header_files
525 = (int *) xrealloc (this_object_header_files
,
526 n_allocated_this_object_header_files
* sizeof (int));
529 this_object_header_files
[n_this_object_header_files
++] = i
;
532 /* Add to this file an "old" header file, one already seen in
533 a previous object file. NAME is the header file's name.
534 INSTANCE is its instance code, to select among multiple
535 symbol tables for the same header file. */
538 add_old_header_file (name
, instance
)
542 register struct header_file
*p
= header_files
;
545 for (i
= 0; i
< n_header_files
; i
++)
546 if (!strcmp (p
[i
].name
, name
) && instance
== p
[i
].instance
)
548 add_this_object_header_file (i
);
551 error ("Invalid symbol data: \"repeated\" header file that hasn't been seen before, at symtab pos %d.",
555 /* Add to this file a "new" header file: definitions for its types follow.
556 NAME is the header file's name.
557 Most often this happens only once for each distinct header file,
558 but not necessarily. If it happens more than once, INSTANCE has
559 a different value each time, and references to the header file
560 use INSTANCE values to select among them.
562 dbx output contains "begin" and "end" markers for each new header file,
563 but at this level we just need to know which files there have been;
564 so we record the file when its "begin" is seen and ignore the "end". */
567 add_new_header_file (name
, instance
)
572 header_file_prev_index
= -1;
574 /* Make sure there is room for one more header file. */
576 if (n_header_files
== n_allocated_header_files
)
578 n_allocated_header_files
*= 2;
579 header_files
= (struct header_file
*)
580 xrealloc (header_files
,
581 (n_allocated_header_files
582 * sizeof (struct header_file
)));
585 /* Create an entry for this header file. */
587 i
= n_header_files
++;
588 header_files
[i
].name
= savestring (name
, strlen(name
));
589 header_files
[i
].instance
= instance
;
590 header_files
[i
].length
= 10;
591 header_files
[i
].vector
592 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
593 bzero (header_files
[i
].vector
, 10 * sizeof (struct type
*));
595 add_this_object_header_file (i
);
598 /* Look up a dbx type-number pair. Return the address of the slot
599 where the type for that number-pair is stored.
600 The number-pair is in TYPENUMS.
602 This can be used for finding the type associated with that pair
603 or for associating a new type with the pair. */
605 static struct type
**
606 dbx_lookup_type (typenums
)
609 register int filenum
= typenums
[0], index
= typenums
[1];
611 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
612 error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
613 filenum
, index
, symnum
);
617 /* Type is defined outside of header files.
618 Find it in this object file's type vector. */
619 if (index
>= type_vector_length
)
621 type_vector_length
*= 2;
622 type_vector
= (struct typevector
*)
623 xrealloc (type_vector
,
624 (sizeof (struct typevector
)
625 + type_vector_length
* sizeof (struct type
*)));
626 bzero (&type_vector
->type
[type_vector_length
/ 2],
627 type_vector_length
* sizeof (struct type
*) / 2);
629 return &type_vector
->type
[index
];
633 register int real_filenum
= this_object_header_files
[filenum
];
634 register struct header_file
*f
;
637 if (real_filenum
>= n_header_files
)
640 f
= &header_files
[real_filenum
];
642 f_orig_length
= f
->length
;
643 if (index
>= f_orig_length
)
645 while (index
>= f
->length
)
647 f
->vector
= (struct type
**)
648 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
649 bzero (&f
->vector
[f_orig_length
],
650 (f
->length
- f_orig_length
) * sizeof (struct type
*));
652 return &f
->vector
[index
];
656 /* Create a type object. Occaisionally used when you need a type
657 which isn't going to be given a type number. */
662 register struct type
*type
=
663 (struct type
*) obstack_alloc (symbol_obstack
, sizeof (struct type
));
665 bzero (type
, sizeof (struct type
));
666 TYPE_VPTR_FIELDNO (type
) = -1;
667 TYPE_VPTR_BASETYPE (type
) = 0;
671 /* Make sure there is a type allocated for type numbers TYPENUMS
672 and return the type object.
673 This can create an empty (zeroed) type object.
674 TYPENUMS may be (-1, -1) to return a new type object that is not
675 put into the type vector, and so may not be referred to by number. */
678 dbx_alloc_type (typenums
)
681 register struct type
**type_addr
;
682 register struct type
*type
;
684 if (typenums
[1] != -1)
686 type_addr
= dbx_lookup_type (typenums
);
695 /* If we are referring to a type not known at all yet,
696 allocate an empty type for it.
697 We will fill it in later if we find out how. */
700 type
= dbx_create_type ();
709 static struct type
**
710 explicit_lookup_type (real_filenum
, index
)
711 int real_filenum
, index
;
713 register struct header_file
*f
= &header_files
[real_filenum
];
715 if (index
>= f
->length
)
718 f
->vector
= (struct type
**)
719 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
720 bzero (&f
->vector
[f
->length
/ 2],
721 f
->length
* sizeof (struct type
*) / 2);
723 return &f
->vector
[index
];
727 /* maintain the lists of symbols and blocks */
729 /* Add a symbol to one of the lists of symbols. */
731 add_symbol_to_list (symbol
, listhead
)
732 struct symbol
*symbol
;
733 struct pending
**listhead
;
735 /* We keep PENDINGSIZE symbols in each link of the list.
736 If we don't have a link with room in it, add a new link. */
737 if (*listhead
== 0 || (*listhead
)->nsyms
== PENDINGSIZE
)
739 register struct pending
*link
;
742 link
= free_pendings
;
743 free_pendings
= link
->next
;
746 link
= (struct pending
*) xmalloc (sizeof (struct pending
));
748 link
->next
= *listhead
;
753 (*listhead
)->symbol
[(*listhead
)->nsyms
++] = symbol
;
756 /* At end of reading syms, or in case of quit,
757 really free as many `struct pending's as we can easily find. */
761 really_free_pendings (foo
)
764 struct pending
*next
, *next1
;
766 struct pending_block
*bnext
, *bnext1
;
769 for (next
= free_pendings
; next
; next
= next1
)
776 #if 0 /* Now we make the links in the symbol_obstack, so don't free them. */
777 for (bnext
= pending_blocks
; bnext
; bnext
= bnext1
)
779 bnext1
= bnext
->next
;
785 for (next
= file_symbols
; next
; next
= next1
)
792 for (next
= global_symbols
; next
; next
= next1
)
800 /* Take one of the lists of symbols and make a block from it.
801 Keep the order the symbols have in the list (reversed from the input file).
802 Put the block on the list of pending blocks. */
805 finish_block (symbol
, listhead
, old_blocks
, start
, end
)
806 struct symbol
*symbol
;
807 struct pending
**listhead
;
808 struct pending_block
*old_blocks
;
809 CORE_ADDR start
, end
;
811 register struct pending
*next
, *next1
;
812 register struct block
*block
;
813 register struct pending_block
*pblock
;
814 struct pending_block
*opblock
;
817 /* Count the length of the list of symbols. */
819 for (next
= *listhead
, i
= 0; next
; i
+= next
->nsyms
, next
= next
->next
)
822 block
= (struct block
*) obstack_alloc (symbol_obstack
,
823 (sizeof (struct block
)
825 * sizeof (struct symbol
*))));
827 /* Copy the symbols into the block. */
829 BLOCK_NSYMS (block
) = i
;
830 for (next
= *listhead
; next
; next
= next
->next
)
833 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
834 BLOCK_SYM (block
, --i
) = next
->symbol
[j
];
837 BLOCK_START (block
) = start
;
838 BLOCK_END (block
) = end
;
839 BLOCK_SUPERBLOCK (block
) = 0; /* Filled in when containing block is made */
840 BLOCK_GCC_COMPILED (block
) = processing_gcc_compilation
;
842 /* Put the block in as the value of the symbol that names it. */
846 SYMBOL_BLOCK_VALUE (symbol
) = block
;
847 BLOCK_FUNCTION (block
) = symbol
;
850 BLOCK_FUNCTION (block
) = 0;
852 /* Now "free" the links of the list, and empty the list. */
854 for (next
= *listhead
; next
; next
= next1
)
857 next
->next
= free_pendings
;
858 free_pendings
= next
;
862 /* Install this block as the superblock
863 of all blocks made since the start of this scope
864 that don't have superblocks yet. */
867 for (pblock
= pending_blocks
; pblock
!= old_blocks
; pblock
= pblock
->next
)
869 if (BLOCK_SUPERBLOCK (pblock
->block
) == 0) {
871 /* Check to be sure the blocks are nested as we receive them.
872 If the compiler/assembler/linker work, this just burns a small
874 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
)
875 || BLOCK_END (pblock
->block
) > BLOCK_END (block
)) {
876 complain(&innerblock_complaint
, symbol
? SYMBOL_NAME (symbol
):
878 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
879 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
882 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
887 /* Record this block on the list of all blocks in the file.
888 Put it after opblock, or at the beginning if opblock is 0.
889 This puts the block in the list after all its subblocks. */
891 /* Allocate in the symbol_obstack to save time.
892 It wastes a little space. */
893 pblock
= (struct pending_block
*)
894 obstack_alloc (symbol_obstack
,
895 sizeof (struct pending_block
));
896 pblock
->block
= block
;
899 pblock
->next
= opblock
->next
;
900 opblock
->next
= pblock
;
904 pblock
->next
= pending_blocks
;
905 pending_blocks
= pblock
;
909 static struct blockvector
*
912 register struct pending_block
*next
;
913 register struct blockvector
*blockvector
;
916 /* Count the length of the list of blocks. */
918 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++);
920 blockvector
= (struct blockvector
*)
921 obstack_alloc (symbol_obstack
,
922 (sizeof (struct blockvector
)
923 + (i
- 1) * sizeof (struct block
*)));
925 /* Copy the blocks into the blockvector.
926 This is done in reverse order, which happens to put
927 the blocks into the proper order (ascending starting address).
928 finish_block has hair to insert each block into the list
929 after its subblocks in order to make sure this is true. */
931 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
932 for (next
= pending_blocks
; next
; next
= next
->next
) {
933 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
936 #if 0 /* Now we make the links in the obstack, so don't free them. */
937 /* Now free the links of the list, and empty the list. */
939 for (next
= pending_blocks
; next
; next
= next1
)
947 #if 1 /* FIXME, shut this off after a while to speed up symbol reading. */
948 /* Some compilers output blocks in the wrong order, but we depend
949 on their being in the right order so we can binary search.
950 Check the order and moan about it. FIXME. */
951 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
952 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++) {
953 if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
-1))
954 > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
))) {
955 complain (&blockvector_complaint
,
956 BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
)));
964 /* Manage the vector of line numbers. */
967 record_line (line
, pc
)
971 struct linetable_entry
*e
;
972 /* Ignore the dummy line number in libg.o */
977 /* Make sure line vector is big enough. */
979 if (line_vector_index
+ 1 >= line_vector_length
)
981 line_vector_length
*= 2;
982 line_vector
= (struct linetable
*)
983 xrealloc (line_vector
,
984 (sizeof (struct linetable
)
985 + line_vector_length
* sizeof (struct linetable_entry
)));
986 current_subfile
->line_vector
= line_vector
;
989 e
= line_vector
->item
+ line_vector_index
++;
990 e
->line
= line
; e
->pc
= pc
;
993 /* Start a new symtab for a new source file.
994 This is called when a dbx symbol of type N_SO is seen;
995 it indicates the start of data for one original source file. */
998 start_symtab (name
, dirname
, start_addr
)
1001 CORE_ADDR start_addr
;
1004 last_source_file
= name
;
1005 last_source_start_addr
= start_addr
;
1008 within_function
= 0;
1010 /* Context stack is initially empty, with room for 10 levels. */
1012 = (struct context_stack
*) xmalloc (10 * sizeof (struct context_stack
));
1013 context_stack_size
= 10;
1014 context_stack_depth
= 0;
1016 new_object_header_files ();
1018 type_vector_length
= 160;
1019 type_vector
= (struct typevector
*)
1020 xmalloc (sizeof (struct typevector
)
1021 + type_vector_length
* sizeof (struct type
*));
1022 bzero (type_vector
->type
, type_vector_length
* sizeof (struct type
*));
1024 /* Initialize the list of sub source files with one entry
1025 for this file (the top-level source file). */
1028 current_subfile
= 0;
1029 start_subfile (name
, dirname
);
1032 /* Handle an N_SOL symbol, which indicates the start of
1033 code that came from an included (or otherwise merged-in)
1034 source file with a different name. */
1037 start_subfile (name
, dirname
)
1041 register struct subfile
*subfile
;
1043 /* Save the current subfile's line vector data. */
1045 if (current_subfile
)
1047 current_subfile
->line_vector_index
= line_vector_index
;
1048 current_subfile
->line_vector_length
= line_vector_length
;
1049 current_subfile
->prev_line_number
= prev_line_number
;
1052 /* See if this subfile is already known as a subfile of the
1053 current main source file. */
1055 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
1057 if (!strcmp (subfile
->name
, name
))
1059 line_vector
= subfile
->line_vector
;
1060 line_vector_index
= subfile
->line_vector_index
;
1061 line_vector_length
= subfile
->line_vector_length
;
1062 prev_line_number
= subfile
->prev_line_number
;
1063 current_subfile
= subfile
;
1068 /* This subfile is not known. Add an entry for it. */
1070 line_vector_index
= 0;
1071 line_vector_length
= 1000;
1072 prev_line_number
= -2; /* Force first line number to be explicit */
1073 line_vector
= (struct linetable
*)
1074 xmalloc (sizeof (struct linetable
)
1075 + line_vector_length
* sizeof (struct linetable_entry
));
1077 /* Make an entry for this subfile in the list of all subfiles
1078 of the current main source file. */
1080 subfile
= (struct subfile
*) xmalloc (sizeof (struct subfile
));
1081 subfile
->next
= subfiles
;
1082 subfile
->name
= obsavestring (name
, strlen (name
));
1083 if (dirname
== NULL
)
1084 subfile
->dirname
= NULL
;
1086 subfile
->dirname
= obsavestring (dirname
, strlen (dirname
));
1088 subfile
->line_vector
= line_vector
;
1090 current_subfile
= subfile
;
1093 /* Finish the symbol definitions for one main source file,
1094 close off all the lexical contexts for that file
1095 (creating struct block's for them), then make the struct symtab
1096 for that file and put it in the list of all such.
1098 END_ADDR is the address of the end of the file's text. */
1100 static struct symtab
*
1101 end_symtab (end_addr
)
1104 register struct symtab
*symtab
;
1105 register struct blockvector
*blockvector
;
1106 register struct subfile
*subfile
;
1107 register struct linetable
*lv
;
1108 struct subfile
*nextsub
;
1110 /* Finish the lexical context of the last function in the file;
1111 pop the context stack. */
1113 if (context_stack_depth
> 0)
1115 register struct context_stack
*cstk
;
1116 context_stack_depth
--;
1117 cstk
= &context_stack
[context_stack_depth
];
1118 /* Make a block for the local symbols within. */
1119 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
1120 cstk
->start_addr
, end_addr
);
1123 /* Cleanup any undefined types that have been left hanging around
1124 (this needs to be done before the finish_blocks so that
1125 file_symbols is still good). */
1126 cleanup_undefined_types ();
1128 /* Define the STATIC_BLOCK and GLOBAL_BLOCK, and build the blockvector. */
1129 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
);
1130 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
);
1131 blockvector
= make_blockvector ();
1133 current_subfile
->line_vector_index
= line_vector_index
;
1135 /* Now create the symtab objects proper, one for each subfile. */
1136 /* (The main file is the last one on the chain.) */
1138 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
1140 symtab
= (struct symtab
*) xmalloc (sizeof (struct symtab
));
1142 /* Fill in its components. */
1143 symtab
->blockvector
= blockvector
;
1144 lv
= subfile
->line_vector
;
1145 lv
->nitems
= subfile
->line_vector_index
;
1146 symtab
->linetable
= (struct linetable
*)
1147 xrealloc (lv
, (sizeof (struct linetable
)
1148 + lv
->nitems
* sizeof (struct linetable_entry
)));
1149 type_vector
->length
= type_vector_length
;
1150 symtab
->typevector
= type_vector
;
1152 symtab
->filename
= subfile
->name
;
1153 symtab
->dirname
= subfile
->dirname
;
1155 symtab
->free_code
= free_linetable
;
1156 symtab
->free_ptr
= 0;
1157 if (subfile
->next
== 0)
1158 symtab
->free_ptr
= (char *) type_vector
;
1161 symtab
->line_charpos
= 0;
1163 symtab
->language
= language_unknown
;
1164 symtab
->fullname
= NULL
;
1166 /* There should never already be a symtab for this name, since
1167 any prev dups have been removed when the psymtab was read in.
1168 FIXME, there ought to be a way to check this here. */
1169 /* FIXME blewit |= free_named_symtabs (symtab->filename); */
1171 /* Link the new symtab into the list of such. */
1172 symtab
->next
= symtab_list
;
1173 symtab_list
= symtab
;
1175 nextsub
= subfile
->next
;
1180 type_vector_length
= -1;
1182 line_vector_length
= -1;
1183 last_source_file
= 0;
1188 /* Handle the N_BINCL and N_EINCL symbol types
1189 that act like N_SOL for switching source files
1190 (different subfiles, as we call them) within one object file,
1191 but using a stack rather than in an arbitrary order. */
1193 struct subfile_stack
1195 struct subfile_stack
*next
;
1200 struct subfile_stack
*subfile_stack
;
1205 register struct subfile_stack
*tem
1206 = (struct subfile_stack
*) xmalloc (sizeof (struct subfile_stack
));
1208 tem
->next
= subfile_stack
;
1209 subfile_stack
= tem
;
1210 if (current_subfile
== 0 || current_subfile
->name
== 0)
1212 tem
->name
= current_subfile
->name
;
1213 tem
->prev_index
= header_file_prev_index
;
1219 register char *name
;
1220 register struct subfile_stack
*link
= subfile_stack
;
1226 subfile_stack
= link
->next
;
1227 header_file_prev_index
= link
->prev_index
;
1234 record_misc_function (name
, address
, type
)
1239 enum misc_function_type misc_type
=
1240 (type
== (N_TEXT
| N_EXT
) ? mf_text
:
1241 (type
== (N_DATA
| N_EXT
)
1243 || type
== (N_SETV
| N_EXT
)
1245 type
== (N_BSS
| N_EXT
) ? mf_bss
:
1246 type
== (N_ABS
| N_EXT
) ? mf_abs
: mf_unknown
);
1248 prim_record_misc_function (obsavestring (name
, strlen (name
)),
1249 address
, misc_type
);
1252 /* The BFD for this file -- only good while we're actively reading
1253 symbols into a psymtab or a symtab. */
1255 static bfd
*symfile_bfd
;
1257 /* Scan and build partial symbols for a symbol file.
1258 We have been initialized by a call to dbx_symfile_init, which
1259 put all the relevant info into a "struct dbx_symfile_info"
1260 hung off the struct sym_fns SF.
1262 ADDR is the address relative to which the symbols in it are (e.g.
1263 the base address of the text segment).
1264 MAINLINE is true if we are reading the main symbol
1265 table (as opposed to a shared lib or dynamically loaded file). */
1268 dbx_symfile_read (sf
, addr
, mainline
)
1271 int mainline
; /* FIXME comments above */
1273 struct dbx_symfile_info
*info
= (struct dbx_symfile_info
*) (sf
->sym_private
);
1274 bfd
*sym_bfd
= sf
->sym_bfd
;
1276 char *filename
= bfd_get_filename (sym_bfd
);
1278 val
= lseek (info
->desc
, info
->symtab_offset
, L_SET
);
1280 perror_with_name (filename
);
1282 /* If mainline, set global string table pointers, and reinitialize global
1283 partial symbol list. */
1285 symfile_string_table
= info
->stringtab
;
1286 symfile_string_table_size
= info
->stringtab_size
;
1289 /* If we are reinitializing, or if we have never loaded syms yet, init */
1290 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
1291 init_psymbol_list (info
->symcount
);
1293 symfile_bfd
= sym_bfd
; /* Kludge for SWAP_SYMBOL */
1296 make_cleanup (really_free_pendings
, 0);
1298 init_misc_bunches ();
1299 make_cleanup (discard_misc_bunches
, 0);
1301 /* Now that the symbol table data of the executable file are all in core,
1302 process them and define symbols accordingly. */
1304 read_dbx_symtab (filename
,
1305 addr
- bfd_section_vma (sym_bfd
, info
->text_sect
), /*offset*/
1306 info
->desc
, info
->stringtab
, info
->stringtab_size
,
1308 bfd_section_vma (sym_bfd
, info
->text_sect
),
1309 bfd_section_size (sym_bfd
, info
->text_sect
));
1311 /* Go over the misc symbol bunches and install them in vector. */
1313 condense_misc_bunches (!mainline
);
1315 /* Free up any memory we allocated for ourselves. */
1318 free (info
->stringtab
); /* Stringtab is only saved for mainline */
1321 sf
->sym_private
= 0; /* Zap pointer to our (now gone) info struct */
1323 if (!partial_symtab_list
) {
1325 printf_filtered ("(no debugging symbols found)...");
1330 /* Initialize anything that needs initializing when a completely new
1331 symbol file is specified (not just adding some symbols from another
1332 file, e.g. a shared library). */
1337 /* Empty the hash table of global syms looking for values. */
1338 bzero (global_sym_chain
, sizeof global_sym_chain
);
1344 /* Don't put these on the cleanup chain; they need to stick around
1345 until the next call to dbx_new_init. *Then* we'll free them. */
1346 if (symfile_string_table
)
1348 free (symfile_string_table
);
1349 symfile_string_table
= 0;
1350 symfile_string_table_size
= 0;
1352 free_and_init_header_files ();
1356 /* dbx_symfile_init ()
1357 is the dbx-specific initialization routine for reading symbols.
1358 It is passed a struct sym_fns which contains, among other things,
1359 the BFD for the file whose symbols are being read, and a slot for a pointer
1360 to "private data" which we fill with goodies.
1362 We read the string table into malloc'd space and stash a pointer to it.
1364 Since BFD doesn't know how to read debug symbols in a format-independent
1365 way (and may never do so...), we have to do it ourselves. We will never
1366 be called unless this is an a.out (or very similar) file.
1367 FIXME, there should be a cleaner peephole into the BFD environment here. */
1370 dbx_symfile_init (sf
)
1375 struct stat statbuf
;
1376 bfd
*sym_bfd
= sf
->sym_bfd
;
1377 char *name
= bfd_get_filename (sym_bfd
);
1378 struct dbx_symfile_info
*info
;
1379 unsigned char size_temp
[4];
1381 /* Allocate struct to keep track of the symfile */
1382 sf
->sym_private
= xmalloc (sizeof (*info
)); /* FIXME storage leak */
1383 info
= (struct dbx_symfile_info
*)sf
->sym_private
;
1385 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
1386 desc
= fileno ((FILE *)(sym_bfd
->iostream
)); /* Raw file descriptor */
1387 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
1388 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
1389 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
1392 info
->text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
1393 if (!info
->text_sect
)
1395 info
->symcount
= bfd_get_symcount (sym_bfd
);
1397 /* Read the string table size and check it for bogosity. */
1398 val
= lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
1400 perror_with_name (name
);
1401 if (fstat (desc
, &statbuf
) == -1)
1402 perror_with_name (name
);
1404 val
= myread (desc
, size_temp
, sizeof (long));
1406 perror_with_name (name
);
1407 info
->stringtab_size
= bfd_h_get_32 (sym_bfd
, size_temp
);
1409 if (info
->stringtab_size
>= 0 && info
->stringtab_size
< statbuf
.st_size
)
1411 info
->stringtab
= (char *) xmalloc (info
->stringtab_size
);
1412 /* Caller is responsible for freeing the string table. No cleanup. */
1415 info
->stringtab
= NULL
;
1416 if (info
->stringtab
== NULL
&& info
->stringtab_size
!= 0)
1417 error ("ridiculous string table size: %d bytes", info
->stringtab_size
);
1419 /* Now read in the string table in one big gulp. */
1421 val
= lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
1423 perror_with_name (name
);
1424 val
= myread (desc
, info
->stringtab
, info
->stringtab_size
);
1426 perror_with_name (name
);
1428 /* Record the position of the symbol table for later use. */
1430 info
->symtab_offset
= SYMBOL_TABLE_OFFSET
;
1433 /* Buffer for reading the symbol table entries. */
1434 static struct nlist symbuf
[4096];
1435 static int symbuf_idx
;
1436 static int symbuf_end
;
1438 /* I/O descriptor for reading the symbol table. */
1439 static int symtab_input_desc
;
1441 /* The address in memory of the string table of the object file we are
1442 reading (which might not be the "main" object file, but might be a
1443 shared library or some other dynamically loaded thing). This is set
1444 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
1445 when building symtabs, and is used only by next_symbol_text. */
1446 static char *stringtab_global
;
1448 /* Refill the symbol table input buffer
1449 and set the variables that control fetching entries from it.
1450 Reports an error if no data available.
1451 This function can read past the end of the symbol table
1452 (into the string table) but this does no harm. */
1457 int nbytes
= myread (symtab_input_desc
, symbuf
, sizeof (symbuf
));
1459 perror_with_name ("<symbol file>");
1460 else if (nbytes
== 0)
1461 error ("Premature end of file reading symbol table");
1462 symbuf_end
= nbytes
/ sizeof (struct nlist
);
1467 #define SWAP_SYMBOL(symp) \
1469 (symp)->n_un.n_strx = bfd_h_get_32(symfile_bfd, \
1470 (unsigned char *)&(symp)->n_un.n_strx); \
1471 (symp)->n_desc = bfd_h_get_16 (symfile_bfd, \
1472 (unsigned char *)&(symp)->n_desc); \
1473 (symp)->n_value = bfd_h_get_32 (symfile_bfd, \
1474 (unsigned char *)&(symp)->n_value); \
1477 /* Invariant: The symbol pointed to by symbuf_idx is the first one
1478 that hasn't been swapped. Swap the symbol at the same time
1479 that symbuf_idx is incremented. */
1481 /* dbx allows the text of a symbol name to be continued into the
1482 next symbol name! When such a continuation is encountered
1483 (a \ at the end of the text of a name)
1484 call this function to get the continuation. */
1489 if (symbuf_idx
== symbuf_end
)
1492 SWAP_SYMBOL(&symbuf
[symbuf_idx
]);
1493 return symbuf
[symbuf_idx
++].n_un
.n_strx
+ stringtab_global
;
1496 /* Initializes storage for all of the partial symbols that will be
1497 created by read_dbx_symtab and subsidiaries. */
1500 init_psymbol_list (total_symbols
)
1503 /* Free any previously allocated psymbol lists. */
1504 if (global_psymbols
.list
)
1505 free (global_psymbols
.list
);
1506 if (static_psymbols
.list
)
1507 free (static_psymbols
.list
);
1509 /* Current best guess is that there are approximately a twentieth
1510 of the total symbols (in a debugging file) are global or static
1512 global_psymbols
.size
= total_symbols
/ 10;
1513 static_psymbols
.size
= total_symbols
/ 10;
1514 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
1515 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
1516 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
1517 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
1520 /* Initialize the list of bincls to contain none and have some
1524 init_bincl_list (number
)
1527 bincls_allocated
= number
;
1528 next_bincl
= bincl_list
= (struct header_file_location
*)
1529 xmalloc (bincls_allocated
* sizeof(struct header_file_location
));
1532 /* Add a bincl to the list. */
1535 add_bincl_to_list (pst
, name
, instance
)
1536 struct partial_symtab
*pst
;
1540 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1542 int offset
= next_bincl
- bincl_list
;
1543 bincls_allocated
*= 2;
1544 bincl_list
= (struct header_file_location
*)
1545 xrealloc ((char *)bincl_list
,
1546 bincls_allocated
* sizeof (struct header_file_location
));
1547 next_bincl
= bincl_list
+ offset
;
1549 next_bincl
->pst
= pst
;
1550 next_bincl
->instance
= instance
;
1551 next_bincl
++->name
= name
;
1554 /* Given a name, value pair, find the corresponding
1555 bincl in the list. Return the partial symtab associated
1556 with that header_file_location. */
1558 struct partial_symtab
*
1559 find_corresponding_bincl_psymtab (name
, instance
)
1563 struct header_file_location
*bincl
;
1565 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1566 if (bincl
->instance
== instance
1567 && !strcmp (name
, bincl
->name
))
1570 return (struct partial_symtab
*) 0;
1573 /* Free the storage allocated for the bincl list. */
1579 bincls_allocated
= 0;
1582 static struct partial_symtab
*start_psymtab ();
1583 static void end_psymtab();
1586 /* This is normally a macro defined in read_dbx_symtab, but this
1587 is a lot easier to debug. */
1589 ADD_PSYMBOL_TO_PLIST(NAME
, NAMELENGTH
, NAMESPACE
, CLASS
, PLIST
, VALUE
)
1592 enum namespace NAMESPACE
;
1593 enum address_class CLASS
;
1594 struct psymbol_allocation_list
*PLIST
;
1595 unsigned long VALUE
;
1597 register struct partial_symbol
*psym
;
1602 (LIST
).list
+ (LIST
).size
)
1604 (LIST
).list
= (struct partial_symbol
*)
1605 xrealloc ((LIST
).list
,
1607 * sizeof (struct partial_symbol
)));
1608 /* Next assumes we only went one over. Should be good if
1609 program works correctly */
1611 (LIST
).list
+ (LIST
).size
;
1614 psym
= (LIST
).next
++;
1617 SYMBOL_NAME (psym
) = (char *) obstack_alloc (psymbol_obstack
,
1619 strncpy (SYMBOL_NAME (psym
), (NAME
), (NAMELENGTH
));
1620 SYMBOL_NAME (psym
)[(NAMELENGTH
)] = '\0';
1621 SYMBOL_NAMESPACE (psym
) = (NAMESPACE
);
1622 SYMBOL_CLASS (psym
) = (CLASS
);
1623 SYMBOL_VALUE (psym
) = (VALUE
);
1627 /* Since one arg is a struct, we have to pass in a ptr and deref it (sigh) */
1628 #define ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
1629 ADD_PSYMBOL_TO_PLIST(NAME, NAMELENGTH, NAMESPACE, CLASS, &LIST, VALUE)
1633 /* Given pointers to an a.out symbol table in core containing dbx
1634 style data, setup partial_symtab's describing each source file for
1635 which debugging information is available. NLISTLEN is the number
1636 of symbols in the symbol table. All symbol names are given as
1637 offsets relative to STRINGTAB. STRINGTAB_SIZE is the size of
1638 STRINGTAB. SYMFILE_NAME is the name of the file we are reading from
1639 and ADDR is its relocated address (if incremental) or 0 (if not). */
1642 read_dbx_symtab (symfile_name
, addr
,
1643 desc
, stringtab
, stringtab_size
, nlistlen
,
1644 text_addr
, text_size
)
1648 register char *stringtab
;
1649 register long stringtab_size
;
1650 register int nlistlen
;
1651 CORE_ADDR text_addr
;
1654 register struct nlist
*bufp
;
1655 register char *namestring
;
1656 register struct partial_symbol
*psym
;
1658 int past_first_source_file
= 0;
1659 CORE_ADDR last_o_file_start
= 0;
1660 struct cleanup
*old_chain
;
1663 /* End of the text segment of the executable file. */
1664 CORE_ADDR end_of_text_addr
;
1666 /* Current partial symtab */
1667 struct partial_symtab
*pst
;
1669 /* List of current psymtab's include files */
1670 char **psymtab_include_list
;
1671 int includes_allocated
;
1674 /* Index within current psymtab dependency list */
1675 struct partial_symtab
**dependency_list
;
1676 int dependencies_used
, dependencies_allocated
;
1678 stringtab_global
= stringtab
;
1680 pst
= (struct partial_symtab
*) 0;
1682 includes_allocated
= 30;
1684 psymtab_include_list
= (char **) alloca (includes_allocated
*
1687 dependencies_allocated
= 30;
1688 dependencies_used
= 0;
1690 (struct partial_symtab
**) alloca (dependencies_allocated
*
1691 sizeof (struct partial_symtab
*));
1693 /* FIXME!! If an error occurs, this blows away the whole symbol table!
1694 It should only blow away the psymtabs created herein. We could
1695 be reading a shared library or a dynloaded file! */
1696 old_chain
= make_cleanup (free_all_psymtabs
, 0);
1698 /* Init bincl list */
1699 init_bincl_list (20);
1700 make_cleanup (free_bincl_list
, 0);
1702 last_source_file
= 0;
1704 #ifdef END_OF_TEXT_DEFAULT
1705 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
1707 end_of_text_addr
= text_addr
+ text_size
;
1710 symtab_input_desc
= desc
; /* This is needed for fill_symbuf below */
1711 symbuf_end
= symbuf_idx
= 0;
1713 for (symnum
= 0; symnum
< nlistlen
; symnum
++)
1715 /* Get the symbol for this run and pull out some info */
1716 QUIT
; /* allow this to be interruptable */
1717 if (symbuf_idx
== symbuf_end
)
1719 bufp
= &symbuf
[symbuf_idx
++];
1722 * Special case to speed up readin.
1724 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1728 /* Ok. There is a lot of code duplicated in the rest of this
1729 switch statement (for efficiency reasons). Since I don't
1730 like duplicating code, I will do my penance here, and
1731 describe the code which is duplicated:
1733 *) The assignment to namestring.
1734 *) The call to strchr.
1735 *) The addition of a partial symbol the the two partial
1736 symbol lists. This last is a large section of code, so
1737 I've imbedded it in the following macro.
1740 /* Set namestring based on bufp. If the string table index is invalid,
1741 give a fake name, and print a single error message per symbol file read,
1742 rather than abort the symbol reading or flood the user with messages. */
1743 #define SET_NAMESTRING()\
1744 if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size) { \
1745 complain (&string_table_offset_complaint, symnum); \
1746 namestring = "foo"; \
1748 namestring = bufp->n_un.n_strx + stringtab
1750 /* Add a symbol with an integer value to a psymtab. */
1751 /* This is a macro unless we're debugging. See above this function. */
1753 # define ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
1754 ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, \
1758 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1759 #define ADD_PSYMBOL_ADDR_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
1760 ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, \
1761 SYMBOL_VALUE_ADDRESS)
1763 /* Add any kind of symbol to a psymtab. */
1764 #define ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, VT)\
1766 if ((LIST).next >= \
1767 (LIST).list + (LIST).size) \
1769 (LIST).list = (struct partial_symbol *) \
1770 xrealloc ((LIST).list, \
1772 * sizeof (struct partial_symbol))); \
1773 /* Next assumes we only went one over. Should be good if \
1774 program works correctly */ \
1776 (LIST).list + (LIST).size; \
1779 psym = (LIST).next++; \
1781 SYMBOL_NAME (psym) = (char *) obstack_alloc (psymbol_obstack, \
1782 (NAMELENGTH) + 1); \
1783 strncpy (SYMBOL_NAME (psym), (NAME), (NAMELENGTH)); \
1784 SYMBOL_NAME (psym)[(NAMELENGTH)] = '\0'; \
1785 SYMBOL_NAMESPACE (psym) = (NAMESPACE); \
1786 SYMBOL_CLASS (psym) = (CLASS); \
1787 VT (psym) = (VALUE); \
1790 /* End of macro definitions, now let's handle them symbols! */
1792 switch (bufp
->n_type
)
1795 * Standard, external, non-debugger, symbols
1798 case N_TEXT
| N_EXT
:
1799 case N_NBTEXT
| N_EXT
:
1800 case N_NBDATA
| N_EXT
:
1801 case N_NBBSS
| N_EXT
:
1802 case N_SETV
| N_EXT
:
1804 case N_DATA
| N_EXT
:
1807 bufp
->n_value
+= addr
; /* Relocate */
1812 record_misc_function (namestring
, bufp
->n_value
,
1813 bufp
->n_type
); /* Always */
1817 /* Standard, local, non-debugger, symbols */
1821 /* We need to be able to deal with both N_FN or N_TEXT,
1822 because we have no way of knowing whether the sys-supplied ld
1823 or GNU ld was used to make the executable. */
1824 #if ! (N_FN & N_EXT)
1829 bufp
->n_value
+= addr
; /* Relocate */
1831 if ((namestring
[0] == '-' && namestring
[1] == 'l')
1832 || (namestring
[(nsl
= strlen (namestring
)) - 1] == 'o'
1833 && namestring
[nsl
- 2] == '.'))
1835 if (entry_point
< bufp
->n_value
1836 && entry_point
>= last_o_file_start
1837 && addr
== 0) /* FIXME nogood nomore */
1839 startup_file_start
= last_o_file_start
;
1840 startup_file_end
= bufp
->n_value
;
1842 if (past_first_source_file
&& pst
1843 /* The gould NP1 uses low values for .o and -l symbols
1844 which are not the address. */
1845 && bufp
->n_value
> pst
->textlow
)
1847 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1848 symnum
* sizeof (struct nlist
), bufp
->n_value
,
1849 dependency_list
, dependencies_used
,
1850 global_psymbols
.next
, static_psymbols
.next
);
1851 pst
= (struct partial_symtab
*) 0;
1853 dependencies_used
= 0;
1856 past_first_source_file
= 1;
1857 last_o_file_start
= bufp
->n_value
;
1862 bufp
->n_value
+= addr
; /* Relocate */
1864 /* Check for __DYNAMIC, which is used by Sun shared libraries.
1865 Record it even if it's local, not global, so we can find it.
1866 Same with virtual function tables, both global and static. */
1867 if ((namestring
[8] == 'C' && (strcmp ("__DYNAMIC", namestring
) == 0))
1868 || VTBL_PREFIX_P ((namestring
+HASH_OFFSET
)))
1870 /* Not really a function here, but... */
1871 record_misc_function (namestring
, bufp
->n_value
,
1872 bufp
->n_type
); /* Always */
1876 case N_UNDF
| N_EXT
:
1877 if (bufp
->n_value
!= 0) {
1878 /* This is a "Fortran COMMON" symbol. See if the target
1879 environment knows where it has been relocated to. */
1884 if (target_lookup_symbol (namestring
, &reladdr
)) {
1885 continue; /* Error in lookup; ignore symbol for now. */
1887 bufp
->n_type
^= (N_BSS
^N_UNDF
); /* Define it as a bss-symbol */
1888 bufp
->n_value
= reladdr
;
1889 goto bss_ext_symbol
;
1891 continue; /* Just undefined, not COMMON */
1893 /* Lots of symbol types we can just ignore. */
1902 /* Keep going . . .*/
1905 * Special symbol types for GNU
1908 case N_INDR
| N_EXT
:
1910 case N_SETA
| N_EXT
:
1912 case N_SETT
| N_EXT
:
1914 case N_SETD
| N_EXT
:
1916 case N_SETB
| N_EXT
:
1925 unsigned long valu
= bufp
->n_value
;
1926 /* Symbol number of the first symbol of this file (i.e. the N_SO
1927 if there is just one, or the first if we have a pair). */
1928 int first_symnum
= symnum
;
1930 /* End the current partial symtab and start a new one */
1934 /* Peek at the next symbol. If it is also an N_SO, the
1935 first one just indicates the directory. */
1936 if (symbuf_idx
== symbuf_end
)
1938 bufp
= &symbuf
[symbuf_idx
];
1939 /* n_type is only a char, so swapping swapping is irrelevant. */
1940 if (bufp
->n_type
== (unsigned char)N_SO
)
1944 valu
= bufp
->n_value
;
1948 valu
+= addr
; /* Relocate */
1950 if (pst
&& past_first_source_file
)
1952 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1953 first_symnum
* sizeof (struct nlist
), valu
,
1954 dependency_list
, dependencies_used
,
1955 global_psymbols
.next
, static_psymbols
.next
);
1956 pst
= (struct partial_symtab
*) 0;
1958 dependencies_used
= 0;
1961 past_first_source_file
= 1;
1963 pst
= start_psymtab (symfile_name
, addr
,
1965 first_symnum
* sizeof (struct nlist
),
1966 global_psymbols
.next
, static_psymbols
.next
);
1972 /* Add this bincl to the bincl_list for future EXCLs. No
1973 need to save the string; it'll be around until
1974 read_dbx_symtab function returns */
1978 add_bincl_to_list (pst
, namestring
, bufp
->n_value
);
1980 /* Mark down an include file in the current psymtab */
1982 psymtab_include_list
[includes_used
++] = namestring
;
1983 if (includes_used
>= includes_allocated
)
1985 char **orig
= psymtab_include_list
;
1987 psymtab_include_list
= (char **)
1988 alloca ((includes_allocated
*= 2) *
1990 bcopy (orig
, psymtab_include_list
,
1991 includes_used
* sizeof (char *));
1997 /* Mark down an include file in the current psymtab */
2001 /* In C++, one may expect the same filename to come round many
2002 times, when code is coming alternately from the main file
2003 and from inline functions in other files. So I check to see
2004 if this is a file we've seen before -- either the main
2005 source file, or a previously included file.
2007 This seems to be a lot of time to be spending on N_SOL, but
2008 things like "break expread.y:435" need to work (I
2009 suppose the psymtab_include_list could be hashed or put
2010 in a binary tree, if profiling shows this is a major hog). */
2011 if (!strcmp (namestring
, pst
->filename
))
2015 for (i
= 0; i
< includes_used
; i
++)
2016 if (!strcmp (namestring
, psymtab_include_list
[i
]))
2025 psymtab_include_list
[includes_used
++] = namestring
;
2026 if (includes_used
>= includes_allocated
)
2028 char **orig
= psymtab_include_list
;
2030 psymtab_include_list
= (char **)
2031 alloca ((includes_allocated
*= 2) *
2033 bcopy (orig
, psymtab_include_list
,
2034 includes_used
* sizeof (char *));
2038 case N_LSYM
: /* Typedef or automatic variable. */
2041 p
= (char *) strchr (namestring
, ':');
2043 /* Skip if there is no :. */
2049 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2050 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2051 static_psymbols
, bufp
->n_value
);
2054 /* Also a typedef with the same name. */
2055 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2056 VAR_NAMESPACE
, LOC_TYPEDEF
,
2057 static_psymbols
, bufp
->n_value
);
2062 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2063 VAR_NAMESPACE
, LOC_TYPEDEF
,
2064 static_psymbols
, bufp
->n_value
);
2066 /* If this is an enumerated type, we need to
2067 add all the enum constants to the partial symbol
2068 table. This does not cover enums without names, e.g.
2069 "enum {a, b} c;" in C, but fortunately those are
2070 rare. There is no way for GDB to find those from the
2071 enum type without spending too much time on it. Thus
2072 to solve this problem, the compiler needs to put out separate
2073 constant symbols ('c' N_LSYMS) for enum constants in
2074 enums without names, or put out a dummy type. */
2076 /* We are looking for something of the form
2077 <name> ":" ("t" | "T") [<number> "="] "e"
2078 {<constant> ":" <value> ","} ";". */
2080 /* Skip over the colon and the 't' or 'T'. */
2082 /* This type may be given a number. Skip over it. */
2083 while ((*p
>= '0' && *p
<= '9')
2089 /* We have found an enumerated type. */
2090 /* According to comments in read_enum_type
2091 a comma could end it instead of a semicolon.
2092 I don't know where that happens.
2094 while (*p
&& *p
!= ';' && *p
!= ',')
2098 /* Check for and handle cretinous dbx symbol name
2101 p
= next_symbol_text ();
2103 /* Point to the character after the name
2104 of the enum constant. */
2105 for (q
= p
; *q
&& *q
!= ':'; q
++)
2107 /* Note that the value doesn't matter for
2108 enum constants in psymtabs, just in symtabs. */
2109 ADD_PSYMBOL_TO_LIST (p
, q
- p
,
2110 VAR_NAMESPACE
, LOC_CONST
,
2111 static_psymbols
, 0);
2112 /* Point past the name. */
2114 /* Skip over the value. */
2115 while (*p
&& *p
!= ',')
2117 /* Advance past the comma. */
2125 /* Constant, e.g. from "const" in Pascal. */
2126 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2127 VAR_NAMESPACE
, LOC_CONST
,
2128 static_psymbols
, bufp
->n_value
);
2131 /* Skip if the thing following the : is
2132 not a letter (which indicates declaration of a local
2133 variable, which we aren't interested in). */
2138 case N_GSYM
: /* Global (extern) variable; can be
2139 data or bss (sigh). */
2140 case N_STSYM
: /* Data seg var -- static */
2141 case N_LCSYM
: /* BSS " */
2143 case N_NBSTS
: /* Gould nobase. */
2144 case N_NBLCS
: /* symbols. */
2146 /* Following may probably be ignored; I'll leave them here
2147 for now (until I do Pascal and Modula 2 extensions). */
2149 case N_PC
: /* I may or may not need this; I
2151 case N_M2C
: /* I suspect that I can ignore this here. */
2152 case N_SCOPE
: /* Same. */
2156 p
= (char *) strchr (namestring
, ':');
2158 continue; /* Not a debugging symbol. */
2162 /* Main processing section for debugging symbols which
2163 the initial read through the symbol tables needs to worry
2164 about. If we reach this point, the symbol which we are
2165 considering is definitely one we are interested in.
2166 p must also contain the (valid) index into the namestring
2167 which indicates the debugging type symbol. */
2172 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2173 VAR_NAMESPACE
, LOC_CONST
,
2174 static_psymbols
, bufp
->n_value
);
2177 bufp
->n_value
+= addr
; /* Relocate */
2178 ADD_PSYMBOL_ADDR_TO_LIST (namestring
, p
- namestring
,
2179 VAR_NAMESPACE
, LOC_STATIC
,
2180 static_psymbols
, bufp
->n_value
);
2183 bufp
->n_value
+= addr
; /* Relocate */
2184 /* The addresses in these entries are reported to be
2185 wrong. See the code that reads 'G's for symtabs. */
2186 ADD_PSYMBOL_ADDR_TO_LIST (namestring
, p
- namestring
,
2187 VAR_NAMESPACE
, LOC_STATIC
,
2188 global_psymbols
, bufp
->n_value
);
2192 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2193 VAR_NAMESPACE
, LOC_TYPEDEF
,
2194 global_psymbols
, bufp
->n_value
);
2198 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2199 VAR_NAMESPACE
, LOC_BLOCK
,
2200 static_psymbols
, bufp
->n_value
);
2203 /* Global functions were ignored here, but now they
2204 are put into the global psymtab like one would expect.
2205 They're also in the misc fn vector...
2206 FIXME, why did it used to ignore these? That broke
2207 "i fun" on these functions. */
2209 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2210 VAR_NAMESPACE
, LOC_BLOCK
,
2211 global_psymbols
, bufp
->n_value
);
2214 /* Two things show up here (hopefully); static symbols of
2215 local scope (static used inside braces) or extensions
2216 of structure symbols. We can ignore both. */
2232 /* Unexpected symbol. Ignore it; perhaps it is an extension
2233 that we don't know about.
2235 Someone says sun cc puts out symbols like
2236 /foo/baz/maclib::/usr/local/bin/maclib,
2237 which would get here with a symbol type of ':'. */
2245 /* Find the corresponding bincl and mark that psymtab on the
2246 psymtab dependency list */
2248 struct partial_symtab
*needed_pst
=
2249 find_corresponding_bincl_psymtab (namestring
, bufp
->n_value
);
2251 /* If this include file was defined earlier in this file,
2253 if (needed_pst
== pst
) continue;
2260 for (i
= 0; i
< dependencies_used
; i
++)
2261 if (dependency_list
[i
] == needed_pst
)
2267 /* If it's already in the list, skip the rest. */
2268 if (found
) continue;
2270 dependency_list
[dependencies_used
++] = needed_pst
;
2271 if (dependencies_used
>= dependencies_allocated
)
2273 struct partial_symtab
**orig
= dependency_list
;
2275 (struct partial_symtab
**)
2276 alloca ((dependencies_allocated
*= 2)
2277 * sizeof (struct partial_symtab
*));
2278 bcopy (orig
, dependency_list
,
2280 * sizeof (struct partial_symtab
*)));
2282 fprintf (stderr
, "Had to reallocate dependency list.\n");
2283 fprintf (stderr
, "New dependencies allocated: %d\n",
2284 dependencies_allocated
);
2289 error ("Invalid symbol data: \"repeated\" header file not previously seen, at symtab pos %d.",
2297 case N_SSYM
: /* Claim: Structure or union element.
2298 Hopefully, I can ignore this. */
2299 case N_ENTRY
: /* Alternate entry point; can ignore. */
2300 case N_MAIN
: /* Can definitely ignore this. */
2301 case N_CATCH
: /* These are GNU C++ extensions */
2302 case N_EHDECL
: /* that can safely be ignored here. */
2313 case N_NSYMS
: /* Ultrix 4.0: symbol count */
2314 /* These symbols aren't interesting; don't worry about them */
2319 /* If we haven't found it yet, ignore it. It's probably some
2320 new type we don't know about yet. */
2321 complain (&unknown_symtype_complaint
, bufp
->n_type
);
2326 /* If there's stuff to be cleaned up, clean it up. */
2327 if (nlistlen
> 0 /* We have some syms */
2328 && entry_point
< bufp
->n_value
2329 && entry_point
>= last_o_file_start
)
2331 startup_file_start
= last_o_file_start
;
2332 startup_file_end
= bufp
->n_value
;
2337 end_psymtab (pst
, psymtab_include_list
, includes_used
,
2338 symnum
* sizeof (struct nlist
), end_of_text_addr
,
2339 dependency_list
, dependencies_used
,
2340 global_psymbols
.next
, static_psymbols
.next
);
2342 dependencies_used
= 0;
2343 pst
= (struct partial_symtab
*) 0;
2347 discard_cleanups (old_chain
);
2351 * Allocate and partially fill a partial symtab. It will be
2352 * completely filled at the end of the symbol list.
2354 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2355 is the address relative to which its symbols are (incremental) or 0
2357 static struct partial_symtab
*
2358 start_psymtab (symfile_name
, addr
,
2359 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
2365 struct partial_symbol
*global_syms
;
2366 struct partial_symbol
*static_syms
;
2368 struct partial_symtab
*result
=
2369 (struct partial_symtab
*) obstack_alloc (psymbol_obstack
,
2370 sizeof (struct partial_symtab
));
2372 result
->addr
= addr
;
2374 result
->symfile_name
=
2375 (char *) obstack_alloc (psymbol_obstack
,
2376 strlen (symfile_name
) + 1);
2377 strcpy (result
->symfile_name
, symfile_name
);
2380 (char *) obstack_alloc (psymbol_obstack
,
2381 strlen (filename
) + 1);
2382 strcpy (result
->filename
, filename
);
2384 result
->textlow
= textlow
;
2385 result
->ldsymoff
= ldsymoff
;
2389 result
->read_symtab
= dbx_psymtab_to_symtab
;
2391 result
->globals_offset
= global_syms
- global_psymbols
.list
;
2392 result
->statics_offset
= static_syms
- static_psymbols
.list
;
2394 result
->n_global_syms
= 0;
2395 result
->n_static_syms
= 0;
2402 compare_psymbols (s1
, s2
)
2403 register struct partial_symbol
*s1
, *s2
;
2406 *st1
= SYMBOL_NAME (s1
),
2407 *st2
= SYMBOL_NAME (s2
);
2409 return (st1
[0] - st2
[0] ? st1
[0] - st2
[0] :
2410 strcmp (st1
+ 1, st2
+ 1));
2414 /* Close off the current usage of a partial_symbol table entry. This
2415 involves setting the correct number of includes (with a realloc),
2416 setting the high text mark, setting the symbol length in the
2417 executable, and setting the length of the global and static lists
2420 The global symbols and static symbols are then seperately sorted.
2422 Then the partial symtab is put on the global list.
2423 *** List variables and peculiarities of same. ***
2426 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
2427 capping_text
, dependency_list
, number_dependencies
,
2428 capping_global
, capping_static
)
2429 struct partial_symtab
*pst
;
2430 char **include_list
;
2432 int capping_symbol_offset
;
2433 CORE_ADDR capping_text
;
2434 struct partial_symtab
**dependency_list
;
2435 int number_dependencies
;
2436 struct partial_symbol
*capping_global
, *capping_static
;
2440 pst
->ldsymlen
= capping_symbol_offset
- pst
->ldsymoff
;
2441 pst
->texthigh
= capping_text
;
2443 pst
->n_global_syms
=
2444 capping_global
- (global_psymbols
.list
+ pst
->globals_offset
);
2445 pst
->n_static_syms
=
2446 capping_static
- (static_psymbols
.list
+ pst
->statics_offset
);
2448 pst
->number_of_dependencies
= number_dependencies
;
2449 if (number_dependencies
)
2451 pst
->dependencies
= (struct partial_symtab
**)
2452 obstack_alloc (psymbol_obstack
,
2453 number_dependencies
* sizeof (struct partial_symtab
*));
2454 bcopy (dependency_list
, pst
->dependencies
,
2455 number_dependencies
* sizeof (struct partial_symtab
*));
2458 pst
->dependencies
= 0;
2460 for (i
= 0; i
< num_includes
; i
++)
2462 /* Eventually, put this on obstack */
2463 struct partial_symtab
*subpst
=
2464 (struct partial_symtab
*)
2465 obstack_alloc (psymbol_obstack
,
2466 sizeof (struct partial_symtab
));
2469 (char *) obstack_alloc (psymbol_obstack
,
2470 strlen (include_list
[i
]) + 1);
2471 strcpy (subpst
->filename
, include_list
[i
]);
2473 subpst
->symfile_name
= pst
->symfile_name
;
2474 subpst
->addr
= pst
->addr
;
2478 subpst
->texthigh
= 0;
2480 /* We could save slight bits of space by only making one of these,
2481 shared by the entire set of include files. FIXME-someday. */
2482 subpst
->dependencies
= (struct partial_symtab
**)
2483 obstack_alloc (psymbol_obstack
,
2484 sizeof (struct partial_symtab
*));
2485 subpst
->dependencies
[0] = pst
;
2486 subpst
->number_of_dependencies
= 1;
2488 subpst
->globals_offset
=
2489 subpst
->n_global_syms
=
2490 subpst
->statics_offset
=
2491 subpst
->n_static_syms
= 0;
2495 subpst
->read_symtab
= dbx_psymtab_to_symtab
;
2497 subpst
->next
= partial_symtab_list
;
2498 partial_symtab_list
= subpst
;
2501 /* Sort the global list; don't sort the static list */
2502 qsort (global_psymbols
.list
+ pst
->globals_offset
, pst
->n_global_syms
,
2503 sizeof (struct partial_symbol
), compare_psymbols
);
2505 /* If there is already a psymtab or symtab for a file of this name, remove it.
2506 (If there is a symtab, more drastic things also happen.)
2507 This happens in VxWorks. */
2508 free_named_symtabs (pst
->filename
);
2510 /* Put the psymtab on the psymtab list */
2511 pst
->next
= partial_symtab_list
;
2512 partial_symtab_list
= pst
;
2516 psymtab_to_symtab_1 (pst
, desc
, stringtab
, stringtab_size
, sym_offset
)
2517 struct partial_symtab
*pst
;
2523 struct cleanup
*old_chain
;
2531 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2536 /* Read in all partial symbtabs on which this one is dependent */
2537 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2538 if (!pst
->dependencies
[i
]->readin
)
2540 /* Inform about additional files that need to be read in. */
2543 fputs_filtered (" ", stdout
);
2545 fputs_filtered ("and ", stdout
);
2547 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2548 wrap_here (""); /* Flush output */
2551 psymtab_to_symtab_1 (pst
->dependencies
[i
], desc
,
2552 stringtab
, stringtab_size
, sym_offset
);
2555 if (pst
->ldsymlen
) /* Otherwise it's a dummy */
2557 /* Init stuff necessary for reading in symbols */
2562 old_chain
= make_cleanup (really_free_pendings
, 0);
2564 /* Read in this files symbols */
2565 lseek (desc
, sym_offset
, L_SET
);
2567 read_ofile_symtab (desc
, stringtab
, stringtab_size
,
2569 pst
->ldsymlen
, pst
->textlow
,
2570 pst
->texthigh
- pst
->textlow
, pst
->addr
);
2571 sort_symtab_syms (pst
->symtab
);
2573 do_cleanups (old_chain
);
2580 * Read in all of the symbols for a given psymtab for real.
2581 * Be verbose about it if the user wants that.
2584 dbx_psymtab_to_symtab (pst
)
2585 struct partial_symtab
*pst
;
2590 struct stat statbuf
;
2591 struct cleanup
*old_chain
;
2600 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2605 if (pst
->ldsymlen
|| pst
->number_of_dependencies
)
2607 /* Print the message now, before reading the string table,
2608 to avoid disconcerting pauses. */
2611 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
2615 /* Open symbol file and read in string table. Symbol_file_command
2616 guarantees that the symbol file name will be absolute, so there is
2617 no need for openp. */
2618 desc
= open(pst
->symfile_name
, O_RDONLY
, 0);
2621 perror_with_name (pst
->symfile_name
);
2623 sym_bfd
= bfd_fdopenr (pst
->symfile_name
, NULL
, desc
);
2627 error ("Could not open `%s' to read symbols: %s",
2628 pst
->symfile_name
, bfd_errmsg (bfd_error
));
2630 old_chain
= make_cleanup (bfd_close
, sym_bfd
);
2631 if (!bfd_check_format (sym_bfd
, bfd_object
))
2632 error ("\"%s\": can't read symbols: %s.",
2633 pst
->symfile_name
, bfd_errmsg (bfd_error
));
2635 /* We keep the string table for symfile resident in memory, but
2636 not the string table for any other symbol files. */
2637 if ((symfile
== 0) || 0 != strcmp(pst
->symfile_name
, symfile
))
2639 /* Read in the string table */
2641 /* FIXME, this uses internal BFD variables. See above in
2642 dbx_symbol_file_open where the macro is defined! */
2643 lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
2645 val
= myread (desc
, &st_temp
, sizeof st_temp
);
2647 perror_with_name (pst
->symfile_name
);
2648 stsize
= bfd_h_get_32 (sym_bfd
, (unsigned char *)&st_temp
);
2649 if (fstat (desc
, &statbuf
) < 0)
2650 perror_with_name (pst
->symfile_name
);
2652 if (stsize
>= 0 && stsize
< statbuf
.st_size
)
2654 #ifdef BROKEN_LARGE_ALLOCA
2655 stringtab
= (char *) xmalloc (stsize
);
2656 make_cleanup (free
, stringtab
);
2658 stringtab
= (char *) alloca (stsize
);
2663 if (stringtab
== NULL
&& stsize
!= 0)
2664 error ("ridiculous string table size: %d bytes", stsize
);
2666 /* FIXME, this uses internal BFD variables. See above in
2667 dbx_symbol_file_open where the macro is defined! */
2668 val
= lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
2670 perror_with_name (pst
->symfile_name
);
2671 val
= myread (desc
, stringtab
, stsize
);
2673 perror_with_name (pst
->symfile_name
);
2677 stringtab
= symfile_string_table
;
2678 stsize
= symfile_string_table_size
;
2681 symfile_bfd
= sym_bfd
; /* Kludge for SWAP_SYMBOL */
2683 /* FIXME, this uses internal BFD variables. See above in
2684 dbx_symbol_file_open where the macro is defined! */
2685 psymtab_to_symtab_1 (pst
, desc
, stringtab
, stsize
,
2686 SYMBOL_TABLE_OFFSET
);
2688 /* Match with global symbols. This only needs to be done once,
2689 after all of the symtabs and dependencies have been read in. */
2690 scan_file_globals ();
2692 do_cleanups (old_chain
);
2694 /* Finish up the debug error message. */
2696 printf_filtered ("done.\n");
2701 * Scan through all of the global symbols defined in the object file,
2702 * assigning values to the debugging symbols that need to be assigned
2703 * to. Get these symbols from the misc function list.
2706 scan_file_globals ()
2711 for (mf
= 0; mf
< misc_function_count
; mf
++)
2713 char *namestring
= misc_function_vector
[mf
].name
;
2714 struct symbol
*sym
, *prev
;
2718 prev
= (struct symbol
*) 0;
2720 /* Get the hash index and check all the symbols
2721 under that hash index. */
2723 hash
= hashname (namestring
);
2725 for (sym
= global_sym_chain
[hash
]; sym
;)
2727 if (*namestring
== SYMBOL_NAME (sym
)[0]
2728 && !strcmp(namestring
+ 1, SYMBOL_NAME (sym
) + 1))
2730 /* Splice this symbol out of the hash chain and
2731 assign the value we have to it. */
2733 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
2735 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
2737 /* Check to see whether we need to fix up a common block. */
2738 /* Note: this code might be executed several times for
2739 the same symbol if there are multiple references. */
2740 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2741 fix_common_block (sym
, misc_function_vector
[mf
].address
);
2743 SYMBOL_VALUE_ADDRESS (sym
) = misc_function_vector
[mf
].address
;
2746 sym
= SYMBOL_VALUE_CHAIN (prev
);
2748 sym
= global_sym_chain
[hash
];
2753 sym
= SYMBOL_VALUE_CHAIN (sym
);
2759 /* Process a pair of symbols. Currently they must both be N_SO's. */
2761 process_symbol_pair (type1
, desc1
, value1
, name1
,
2762 type2
, desc2
, value2
, name2
)
2772 /* No need to check PCC_SOL_BROKEN, on the assumption that such
2773 broken PCC's don't put out N_SO pairs. */
2774 if (last_source_file
)
2775 (void)end_symtab (value2
);
2776 start_symtab (name2
, name1
, value2
);
2780 * Read in a defined section of a specific object file's symbols.
2782 * DESC is the file descriptor for the file, positioned at the
2783 * beginning of the symtab
2784 * STRINGTAB is a pointer to the files string
2785 * table, already read in
2786 * SYM_OFFSET is the offset within the file of
2787 * the beginning of the symbols we want to read, NUM_SUMBOLS is the
2788 * number of symbols to read
2789 * TEXT_OFFSET is the beginning of the text segment we are reading symbols for
2790 * TEXT_SIZE is the size of the text segment read in.
2791 * OFFSET is a relocation offset which gets added to each symbol
2794 static struct symtab
*
2795 read_ofile_symtab (desc
, stringtab
, stringtab_size
, sym_offset
,
2796 sym_size
, text_offset
, text_size
, offset
)
2798 register char *stringtab
;
2799 unsigned int stringtab_size
;
2802 CORE_ADDR text_offset
;
2806 register char *namestring
;
2811 stringtab_global
= stringtab
;
2812 last_source_file
= 0;
2814 symtab_input_desc
= desc
;
2815 symbuf_end
= symbuf_idx
= 0;
2817 /* It is necessary to actually read one symbol *before* the start
2818 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
2819 occurs before the N_SO symbol.
2821 Detecting this in read_dbx_symtab
2822 would slow down initial readin, so we look for it here instead. */
2823 if (sym_offset
>= (int)sizeof (struct nlist
))
2825 lseek (desc
, sym_offset
- sizeof (struct nlist
), L_INCR
);
2827 bufp
= &symbuf
[symbuf_idx
++];
2830 if (bufp
->n_un
.n_strx
< 0 || bufp
->n_un
.n_strx
>= stringtab_size
)
2831 error ("Invalid symbol data: bad string table offset: %d",
2833 namestring
= bufp
->n_un
.n_strx
+ stringtab
;
2835 processing_gcc_compilation
=
2836 (bufp
->n_type
== N_TEXT
2837 && !strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
));
2841 /* The N_SO starting this symtab is the first symbol, so we
2842 better not check the symbol before it. I'm not this can
2843 happen, but it doesn't hurt to check for it. */
2844 lseek(desc
, sym_offset
, L_INCR
);
2845 processing_gcc_compilation
= 0;
2848 if (symbuf_idx
== symbuf_end
)
2850 bufp
= &symbuf
[symbuf_idx
];
2851 if (bufp
->n_type
!= (unsigned char)N_SO
)
2852 error("First symbol in segment of executable not a source symbol");
2855 symnum
< sym_size
/ sizeof(struct nlist
);
2858 QUIT
; /* Allow this to be interruptable */
2859 if (symbuf_idx
== symbuf_end
)
2861 bufp
= &symbuf
[symbuf_idx
++];
2864 type
= bufp
->n_type
& N_TYPE
;
2865 if (type
== (unsigned char)N_CATCH
)
2867 /* N_CATCH is not fixed up by the linker, and unfortunately,
2868 there's no other place to put it in the .stab map. */
2869 bufp
->n_value
+= text_offset
+ offset
;
2871 else if (type
== N_TEXT
|| type
== N_DATA
|| type
== N_BSS
)
2872 bufp
->n_value
+= offset
;
2874 type
= bufp
->n_type
;
2875 if (bufp
->n_un
.n_strx
< 0 || bufp
->n_un
.n_strx
>= stringtab_size
)
2876 error ("Invalid symbol data: bad string table offset: %d",
2878 namestring
= bufp
->n_un
.n_strx
+ stringtab
;
2882 short bufp_n_desc
= bufp
->n_desc
;
2883 unsigned long valu
= bufp
->n_value
;
2885 /* Check for a pair of N_SO symbols. */
2886 if (type
== (unsigned char)N_SO
)
2888 if (symbuf_idx
== symbuf_end
)
2890 bufp
= &symbuf
[symbuf_idx
];
2891 if (bufp
->n_type
== (unsigned char)N_SO
)
2896 bufp
->n_value
+= offset
; /* Relocate */
2900 if (bufp
->n_un
.n_strx
< 0
2901 || bufp
->n_un
.n_strx
>= stringtab_size
)
2902 error ("Invalid symbol data: bad string table offset: %d",
2904 namestring2
= bufp
->n_un
.n_strx
+ stringtab
;
2906 process_symbol_pair (N_SO
, bufp_n_desc
, valu
, namestring
,
2907 N_SO
, bufp
->n_desc
, bufp
->n_value
,
2911 process_one_symbol(type
, bufp_n_desc
, valu
, namestring
);
2914 process_one_symbol (type
, bufp_n_desc
, valu
, namestring
);
2916 /* We skip checking for a new .o or -l file; that should never
2917 happen in this routine. */
2918 else if (type
== N_TEXT
2919 && !strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
2920 /* I don't think this code will ever be executed, because
2921 the GCC_COMPILED_FLAG_SYMBOL usually is right before
2922 the N_SO symbol which starts this source file.
2923 However, there is no reason not to accept
2924 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
2925 processing_gcc_compilation
= 1;
2926 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
2927 || type
== (unsigned char)N_NBTEXT
2929 /* Global symbol: see if we came across a dbx defintion for
2930 a corresponding symbol. If so, store the value. Remove
2931 syms from the chain when their values are stored, but
2932 search the whole chain, as there may be several syms from
2933 different files with the same name. */
2934 /* This is probably not true. Since the files will be read
2935 in one at a time, each reference to a global symbol will
2936 be satisfied in each file as it appears. So we skip this
2941 return end_symtab (text_offset
+ text_size
);
2948 register char *p
= name
;
2949 register int total
= p
[0];
2962 /* Ensure result is positive. */
2963 if (total
< 0) total
+= (1000 << 6);
2964 return total
% HASHSIZE
;
2969 process_one_symbol (type
, desc
, valu
, name
)
2974 #ifndef SUN_FIXED_LBRAC_BUG
2975 /* This records the last pc address we've seen. We depend on their being
2976 an SLINE or FUN or SO before the first LBRAC, since the variable does
2977 not get reset in between reads of different symbol files. */
2978 static CORE_ADDR last_pc_address
;
2980 register struct context_stack
*new;
2983 /* Something is wrong if we see real data before
2984 seeing a source file name. */
2986 if (last_source_file
== 0 && type
!= (unsigned char)N_SO
)
2988 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
2989 where that code is defined. */
2990 if (IGNORE_SYMBOL (type
))
2993 /* FIXME, this should not be an error, since it precludes extending
2994 the symbol table information in this way... */
2995 error ("Invalid symbol data: does not start by identifying a source file.");
3002 /* Either of these types of symbols indicates the start of
3003 a new function. We must process its "name" normally for dbx,
3004 but also record the start of a new lexical context, and possibly
3005 also the end of the lexical context for the previous function. */
3006 /* This is not always true. This type of symbol may indicate a
3007 text segment variable. */
3009 #ifndef SUN_FIXED_LBRAC_BUG
3010 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
3013 colon_pos
= strchr (name
, ':');
3015 || (*colon_pos
!= 'f' && *colon_pos
!= 'F'))
3017 define_symbol (valu
, name
, desc
, type
);
3021 within_function
= 1;
3022 if (context_stack_depth
> 0)
3024 new = &context_stack
[--context_stack_depth
];
3025 /* Make a block for the local symbols within. */
3026 finish_block (new->name
, &local_symbols
, new->old_blocks
,
3027 new->start_addr
, valu
);
3029 /* Stack must be empty now. */
3030 if (context_stack_depth
!= 0)
3031 error ("Invalid symbol data: unmatched N_LBRAC before symtab pos %d.",
3034 new = &context_stack
[context_stack_depth
++];
3035 new->old_blocks
= pending_blocks
;
3036 new->start_addr
= valu
;
3037 new->name
= define_symbol (valu
, name
, desc
, type
);
3042 /* Record the address at which this catch takes place. */
3043 define_symbol (valu
, name
, desc
, type
);
3047 /* Don't know what to do with these yet. */
3048 error ("action uncertain for eh extensions");
3052 /* This "symbol" just indicates the start of an inner lexical
3053 context within a function. */
3055 #if !defined (BLOCK_ADDRESS_ABSOLUTE)
3056 /* On most machines, the block addresses are relative to the
3057 N_SO, the linker did not relocate them (sigh). */
3058 valu
+= last_source_start_addr
;
3061 #ifndef SUN_FIXED_LBRAC_BUG
3062 if (valu
< last_pc_address
) {
3063 /* Patch current LBRAC pc value to match last handy pc value */
3064 complain (&lbrac_complaint
, 0);
3065 valu
= last_pc_address
;
3068 if (context_stack_depth
== context_stack_size
)
3070 context_stack_size
*= 2;
3071 context_stack
= (struct context_stack
*)
3072 xrealloc (context_stack
,
3074 * sizeof (struct context_stack
)));
3077 new = &context_stack
[context_stack_depth
++];
3079 new->locals
= local_symbols
;
3080 new->old_blocks
= pending_blocks
;
3081 new->start_addr
= valu
;
3087 /* This "symbol" just indicates the end of an inner lexical
3088 context that was started with N_LBRAC. */
3090 #if !defined (BLOCK_ADDRESS_ABSOLUTE)
3091 /* On most machines, the block addresses are relative to the
3092 N_SO, the linker did not relocate them (sigh). */
3093 valu
+= last_source_start_addr
;
3096 new = &context_stack
[--context_stack_depth
];
3097 if (desc
!= new->depth
)
3098 error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum
);
3100 /* Some compilers put the variable decls inside of an
3101 LBRAC/RBRAC block. This macro should be nonzero if this
3102 is true. DESC is N_DESC from the N_RBRAC symbol.
3103 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL. */
3104 #if !defined (VARIABLES_INSIDE_BLOCK)
3105 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
3108 /* Can only use new->locals as local symbols here if we're in
3109 gcc or on a machine that puts them before the lbrack. */
3110 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
3111 local_symbols
= new->locals
;
3113 /* If this is not the outermost LBRAC...RBRAC pair in the
3114 function, its local symbols preceded it, and are the ones
3115 just recovered from the context stack. Defined the block for them.
3117 If this is the outermost LBRAC...RBRAC pair, there is no
3118 need to do anything; leave the symbols that preceded it
3119 to be attached to the function's own block. However, if
3120 it is so, we need to indicate that we just moved outside
3123 && (context_stack_depth
3124 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
3126 /* FIXME Muzzle a compiler bug that makes end < start. */
3127 if (new->start_addr
> valu
)
3129 complain(&lbrac_rbrac_complaint
, 0);
3130 new->start_addr
= valu
;
3132 /* Make a block for the local symbols within. */
3133 finish_block (0, &local_symbols
, new->old_blocks
,
3134 new->start_addr
, valu
);
3138 within_function
= 0;
3140 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
3141 /* Now pop locals of block just finished. */
3142 local_symbols
= new->locals
;
3146 /* This kind of symbol supposedly indicates the start
3147 of an object file. In fact this type does not appear. */
3151 /* This type of symbol indicates the start of data
3152 for one source file.
3153 Finish the symbol table of the previous source file
3154 (if any) and start accumulating a new symbol table. */
3155 #ifndef SUN_FIXED_LBRAC_BUG
3156 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
3159 #ifdef PCC_SOL_BROKEN
3160 /* pcc bug, occasionally puts out SO for SOL. */
3161 if (context_stack_depth
> 0)
3163 start_subfile (name
, NULL
);
3167 if (last_source_file
)
3168 (void)end_symtab (valu
);
3169 start_symtab (name
, NULL
, valu
);
3173 /* This type of symbol indicates the start of data for
3174 a sub-source-file, one whose contents were copied or
3175 included in the compilation of the main source file
3176 (whose name was given in the N_SO symbol.) */
3177 start_subfile (name
, NULL
);
3182 add_new_header_file (name
, valu
);
3183 start_subfile (name
, NULL
);
3187 start_subfile (pop_subfile (), NULL
);
3191 add_old_header_file (name
, valu
);
3195 /* This type of "symbol" really just records
3196 one line-number -- core-address correspondence.
3197 Enter it in the line list for this symbol table. */
3198 #ifndef SUN_FIXED_LBRAC_BUG
3199 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
3201 record_line (desc
, valu
);
3206 error ("Invalid symbol data: common within common at symtab pos %d",
3208 common_block
= local_symbols
;
3209 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
3213 /* Symbols declared since the BCOMM are to have the common block
3214 start address added in when we know it. common_block points to
3215 the first symbol after the BCOMM in the local_symbols list;
3216 copy the list and hang it off the symbol for the common block name
3220 struct symbol
*sym
=
3221 (struct symbol
*) xmalloc (sizeof (struct symbol
));
3222 bzero (sym
, sizeof *sym
);
3223 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
3224 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3225 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
3226 copy_pending (local_symbols
, common_block_i
, common_block
));
3227 i
= hashname (SYMBOL_NAME (sym
));
3228 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
3229 global_sym_chain
[i
] = sym
;
3240 define_symbol (valu
, name
, desc
, type
);
3244 /* Read a number by which a type is referred to in dbx data,
3245 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
3246 Just a single number N is equivalent to (0,N).
3247 Return the two numbers by storing them in the vector TYPENUMS.
3248 TYPENUMS will then be used as an argument to dbx_lookup_type. */
3251 read_type_number (pp
, typenums
)
3253 register int *typenums
;
3258 typenums
[0] = read_number (pp
, ',');
3259 typenums
[1] = read_number (pp
, ')');
3264 typenums
[1] = read_number (pp
, 0);
3268 /* To handle GNU C++ typename abbreviation, we need to be able to
3269 fill in a type's name as soon as space for that type is allocated.
3270 `type_synonym_name' is the name of the type being allocated.
3271 It is cleared as soon as it is used (lest all allocated types
3273 static char *type_synonym_name
;
3275 static struct symbol
*
3276 define_symbol (valu
, string
, desc
, type
)
3282 register struct symbol
*sym
;
3283 char *p
= (char *) strchr (string
, ':');
3288 /* Ignore syms with empty names. */
3292 /* Ignore old-style symbols from cc -go */
3296 sym
= (struct symbol
*)obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
3298 if (processing_gcc_compilation
) {
3299 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
3300 number of bytes occupied by a type or object, which we ignore. */
3301 SYMBOL_LINE(sym
) = desc
;
3303 SYMBOL_LINE(sym
) = 0; /* unknown */
3306 if (string
[0] == CPLUS_MARKER
)
3308 /* Special GNU C++ names. */
3312 SYMBOL_NAME (sym
) = "this";
3314 case 'v': /* $vtbl_ptr_type */
3315 /* Was: SYMBOL_NAME (sym) = "vptr"; */
3318 SYMBOL_NAME (sym
) = "eh_throw";
3322 /* This was an anonymous type that was never fixed up. */
3333 = (char *) obstack_alloc (symbol_obstack
, ((p
- string
) + 1));
3334 /* Open-coded bcopy--saves function call time. */
3336 register char *p1
= string
;
3337 register char *p2
= SYMBOL_NAME (sym
);
3344 /* Determine the type of name being defined. */
3345 /* The Acorn RISC machine's compiler can put out locals that don't
3346 start with "234=" or "(3,4)=", so assume anything other than the
3347 deftypes we know how to handle is a local. */
3348 /* (Peter Watkins @ Computervision)
3349 Handle Sun-style local fortran array types 'ar...' .
3350 (gnu@cygnus.com) -- this strchr() handles them properly?
3351 (tiemann@cygnus.com) -- 'C' is for catch. */
3352 if (!strchr ("cfFGpPrStTvVXC", *p
))
3357 /* c is a special case, not followed by a type-number.
3358 SYMBOL:c=iVALUE for an integer constant symbol.
3359 SYMBOL:c=rVALUE for a floating constant symbol.
3360 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
3361 e.g. "b:c=e6,0" for "const b = blob1"
3362 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
3366 error ("Invalid symbol data at symtab pos %d.", symnum
);
3371 double d
= atof (p
);
3374 SYMBOL_TYPE (sym
) = builtin_type_double
;
3376 (char *) obstack_alloc (symbol_obstack
, sizeof (double));
3377 bcopy (&d
, dbl_valu
, sizeof (double));
3378 SWAP_TARGET_AND_HOST (dbl_valu
, sizeof (double));
3379 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
3380 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
3385 SYMBOL_TYPE (sym
) = builtin_type_int
;
3386 SYMBOL_VALUE (sym
) = atoi (p
);
3387 SYMBOL_CLASS (sym
) = LOC_CONST
;
3391 /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
3392 e.g. "b:c=e6,0" for "const b = blob1"
3393 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
3397 read_type_number (&p
, typenums
);
3399 error ("Invalid symbol data: no comma in enum const symbol");
3401 SYMBOL_TYPE (sym
) = *dbx_lookup_type (typenums
);
3402 SYMBOL_VALUE (sym
) = atoi (p
);
3403 SYMBOL_CLASS (sym
) = LOC_CONST
;
3407 error ("Invalid symbol data at symtab pos %d.", symnum
);
3409 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3410 add_symbol_to_list (sym
, &file_symbols
);
3414 /* Now usually comes a number that says which data type,
3415 and possibly more stuff to define the type
3416 (all of which is handled by read_type) */
3418 if (deftype
== 'p' && *p
== 'F')
3419 /* pF is a two-letter code that means a function parameter in Fortran.
3420 The type-number specifies the type of the return value.
3421 Translate it into a pointer-to-function type. */
3425 = lookup_pointer_type (lookup_function_type (read_type (&p
)));
3429 struct type
*type_read
;
3430 synonym
= *p
== 't';
3435 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
3436 strlen (SYMBOL_NAME (sym
)));
3439 type_read
= read_type (&p
);
3441 if ((deftype
== 'F' || deftype
== 'f')
3442 && TYPE_CODE (type_read
) != TYPE_CODE_FUNC
)
3443 SYMBOL_TYPE (sym
) = lookup_function_type (type_read
);
3445 SYMBOL_TYPE (sym
) = type_read
;
3451 /* The name of a caught exception. */
3452 SYMBOL_CLASS (sym
) = LOC_LABEL
;
3453 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3454 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
3455 add_symbol_to_list (sym
, &local_symbols
);
3459 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3460 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3461 add_symbol_to_list (sym
, &file_symbols
);
3465 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3466 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3467 add_symbol_to_list (sym
, &global_symbols
);
3471 /* For a class G (global) symbol, it appears that the
3472 value is not correct. It is necessary to search for the
3473 corresponding linker definition to find the value.
3474 These definitions appear at the end of the namelist. */
3475 i
= hashname (SYMBOL_NAME (sym
));
3476 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
3477 global_sym_chain
[i
] = sym
;
3478 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3479 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3480 add_symbol_to_list (sym
, &global_symbols
);
3483 /* This case is faked by a conditional above,
3484 when there is no code letter in the dbx data.
3485 Dbx data never actually contains 'l'. */
3487 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3488 SYMBOL_VALUE (sym
) = valu
;
3489 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3490 add_symbol_to_list (sym
, &local_symbols
);
3494 /* Normally this is a parameter, a LOC_ARG. On the i960, it
3495 can also be a LOC_LOCAL_ARG depending on symbol type. */
3496 #ifndef DBX_PARM_SYMBOL_CLASS
3497 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
3499 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
3500 SYMBOL_VALUE (sym
) = valu
;
3501 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3502 add_symbol_to_list (sym
, &local_symbols
);
3504 /* If it's gcc-compiled, if it says `short', believe it. */
3505 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
3508 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
3509 /* This macro is defined on machines (e.g. sparc) where
3510 we should believe the type of a PCC 'short' argument,
3511 but shouldn't believe the address (the address is
3512 the address of the corresponding int). Note that
3513 this is only different from the BELIEVE_PCC_PROMOTION
3514 case on big-endian machines.
3516 My guess is that this correction, as opposed to changing
3517 the parameter to an 'int' (as done below, for PCC
3518 on most machines), is the right thing to do
3519 on all machines, but I don't want to risk breaking
3520 something that already works. On most PCC machines,
3521 the sparc problem doesn't come up because the calling
3522 function has to zero the top bytes (not knowing whether
3523 the called function wants an int or a short), so there
3524 is no practical difference between an int and a short
3525 (except perhaps what happens when the GDB user types
3526 "print short_arg = 0x10000;").
3528 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
3529 actually produces the correct address (we don't need to fix it
3530 up). I made this code adapt so that it will offset the symbol
3531 if it was pointing at an int-aligned location and not
3532 otherwise. This way you can use the same gdb for 4.0.x and
3535 if (0 == SYMBOL_VALUE (sym
) % sizeof (int))
3537 if (SYMBOL_TYPE (sym
) == builtin_type_char
3538 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
)
3539 SYMBOL_VALUE (sym
) += 3;
3540 else if (SYMBOL_TYPE (sym
) == builtin_type_short
3541 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
3542 SYMBOL_VALUE (sym
) += 2;
3546 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
3548 /* If PCC says a parameter is a short or a char,
3549 it is really an int. */
3550 if (SYMBOL_TYPE (sym
) == builtin_type_char
3551 || SYMBOL_TYPE (sym
) == builtin_type_short
)
3552 SYMBOL_TYPE (sym
) = builtin_type_int
;
3553 else if (SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
3554 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
3555 SYMBOL_TYPE (sym
) = builtin_type_unsigned_int
;
3558 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
3561 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3562 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
3563 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3564 add_symbol_to_list (sym
, &local_symbols
);
3568 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
3569 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
3570 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3571 add_symbol_to_list (sym
, &local_symbols
);
3575 /* Static symbol at top level of file */
3576 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3577 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
3578 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3579 add_symbol_to_list (sym
, &file_symbols
);
3583 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3584 SYMBOL_VALUE (sym
) = valu
;
3585 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3586 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0
3587 && (TYPE_FLAGS (SYMBOL_TYPE (sym
)) & TYPE_FLAG_PERM
) == 0)
3588 TYPE_NAME (SYMBOL_TYPE (sym
)) =
3589 obsavestring (SYMBOL_NAME (sym
),
3590 strlen (SYMBOL_NAME (sym
)));
3591 /* C++ vagaries: we may have a type which is derived from
3592 a base type which did not have its name defined when the
3593 derived class was output. We fill in the derived class's
3594 base part member's name here in that case. */
3595 else if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
3596 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
3597 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
3600 for (i
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; i
>= 0; i
--)
3601 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), i
) == 0)
3602 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), i
) =
3603 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), i
));
3606 add_symbol_to_list (sym
, &file_symbols
);
3610 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3611 SYMBOL_VALUE (sym
) = valu
;
3612 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3613 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0
3614 && (TYPE_FLAGS (SYMBOL_TYPE (sym
)) & TYPE_FLAG_PERM
) == 0)
3615 TYPE_NAME (SYMBOL_TYPE (sym
))
3617 (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_ENUM
3619 : (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
3620 ? "struct " : "union ")),
3622 add_symbol_to_list (sym
, &file_symbols
);
3626 register struct symbol
*typedef_sym
3627 = (struct symbol
*) obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
3628 SYMBOL_NAME (typedef_sym
) = SYMBOL_NAME (sym
);
3629 SYMBOL_TYPE (typedef_sym
) = SYMBOL_TYPE (sym
);
3631 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
3632 SYMBOL_VALUE (typedef_sym
) = valu
;
3633 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
3634 add_symbol_to_list (typedef_sym
, &file_symbols
);
3639 /* Static symbol of local scope */
3640 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3641 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
3642 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3643 add_symbol_to_list (sym
, &local_symbols
);
3647 /* Reference parameter */
3648 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
3649 SYMBOL_VALUE (sym
) = valu
;
3650 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3651 add_symbol_to_list (sym
, &local_symbols
);
3655 /* This is used by Sun FORTRAN for "function result value".
3656 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
3657 that Pascal uses it too, but when I tried it Pascal used
3658 "x:3" (local symbol) instead. */
3659 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3660 SYMBOL_VALUE (sym
) = valu
;
3661 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3662 add_symbol_to_list (sym
, &local_symbols
);
3666 error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype
, symnum
);
3671 /* What about types defined as forward references inside of a small lexical
3673 /* Add a type to the list of undefined types to be checked through
3674 once this file has been read in. */
3676 add_undefined_type (type
)
3679 if (undef_types_length
== undef_types_allocated
)
3681 undef_types_allocated
*= 2;
3682 undef_types
= (struct type
**)
3683 xrealloc (undef_types
,
3684 undef_types_allocated
* sizeof (struct type
*));
3686 undef_types
[undef_types_length
++] = type
;
3689 /* Add here something to go through each undefined type, see if it's
3690 still undefined, and do a full lookup if so. */
3692 cleanup_undefined_types ()
3696 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
3698 /* Reasonable test to see if it's been defined since. */
3699 if (TYPE_NFIELDS (*type
) == 0)
3701 struct pending
*ppt
;
3703 /* Name of the type, without "struct" or "union" */
3704 char *typename
= TYPE_NAME (*type
);
3706 if (!strncmp (typename
, "struct ", 7))
3708 if (!strncmp (typename
, "union ", 6))
3711 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
3712 for (i
= 0; i
< ppt
->nsyms
; i
++)
3714 struct symbol
*sym
= ppt
->symbol
[i
];
3716 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3717 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
3718 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
3720 && !strcmp (SYMBOL_NAME (sym
), typename
))
3721 bcopy (SYMBOL_TYPE (sym
), *type
, sizeof (struct type
));
3725 /* It has been defined; don't mark it as a stub. */
3726 TYPE_FLAGS (*type
) &= ~TYPE_FLAG_STUB
;
3728 undef_types_length
= 0;
3731 /* Skip rest of this symbol and return an error type.
3733 General notes on error recovery: error_type always skips to the
3734 end of the symbol (modulo cretinous dbx symbol name continuation).
3735 Thus code like this:
3737 if (*(*pp)++ != ';')
3738 return error_type (pp);
3740 is wrong because if *pp starts out pointing at '\0' (typically as the
3741 result of an earlier error), it will be incremented to point to the
3742 start of the next symbol, which might produce strange results, at least
3743 if you run off the end of the string table. Instead use
3746 return error_type (pp);
3752 foo = error_type (pp);
3756 And in case it isn't obvious, the point of all this hair is so the compiler
3757 can define new types and new syntaxes, and old versions of the
3758 debugger will be able to read the new symbol tables. */
3760 static struct type
*
3764 complain (&error_type_complaint
, 0);
3767 /* Skip to end of symbol. */
3768 while (**pp
!= '\0')
3771 /* Check for and handle cretinous dbx symbol name continuation! */
3772 if ((*pp
)[-1] == '\\')
3773 *pp
= next_symbol_text ();
3777 return builtin_type_error
;
3780 /* Read a dbx type reference or definition;
3781 return the type that is meant.
3782 This can be just a number, in which case it references
3783 a type already defined and placed in type_vector.
3784 Or the number can be followed by an =, in which case
3785 it means to define a new type according to the text that
3793 register struct type
*type
= 0;
3798 /* Read type number if present. The type number may be omitted.
3799 for instance in a two-dimensional array declared with type
3800 "ar1;1;10;ar1;1;10;4". */
3801 if ((**pp
>= '0' && **pp
<= '9')
3804 read_type_number (pp
, typenums
);
3806 /* Detect random reference to type not yet defined.
3807 Allocate a type object but leave it zeroed. */
3809 return dbx_alloc_type (typenums
);
3815 /* 'typenums=' not present, type is anonymous. Read and return
3816 the definition, but don't put it in the type vector. */
3817 typenums
[0] = typenums
[1] = -1;
3825 enum type_code code
;
3827 /* Used to index through file_symbols. */
3828 struct pending
*ppt
;
3831 /* Name including "struct", etc. */
3834 /* Name without "struct", etc. */
3835 char *type_name_only
;
3841 /* Set the type code according to the following letter. */
3845 code
= TYPE_CODE_STRUCT
;
3849 code
= TYPE_CODE_UNION
;
3853 code
= TYPE_CODE_ENUM
;
3857 return error_type (pp
);
3860 to
= type_name
= (char *)
3861 obstack_alloc (symbol_obstack
,
3863 ((char *) strchr (*pp
, ':') - (*pp
)) + 1));
3865 /* Copy the prefix. */
3867 while (*to
++ = *from
++)
3871 type_name_only
= to
;
3873 /* Copy the name. */
3875 while ((*to
++ = *from
++) != ':')
3879 /* Set the pointer ahead of the name which we just read. */
3883 /* The following hack is clearly wrong, because it doesn't
3884 check whether we are in a baseclass. I tried to reproduce
3885 the case that it is trying to fix, but I couldn't get
3886 g++ to put out a cross reference to a basetype. Perhaps
3887 it doesn't do it anymore. */
3888 /* Note: for C++, the cross reference may be to a base type which
3889 has not yet been seen. In this case, we skip to the comma,
3890 which will mark the end of the base class name. (The ':'
3891 at the end of the base class name will be skipped as well.)
3892 But sometimes (ie. when the cross ref is the last thing on
3893 the line) there will be no ','. */
3894 from
= (char *) strchr (*pp
, ',');
3900 /* Now check to see whether the type has already been declared. */
3901 /* This is necessary at least in the case where the
3902 program says something like
3904 The compiler puts out a cross-reference; we better find
3905 set the length of the structure correctly so we can
3906 set the length of the array. */
3907 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
3908 for (i
= 0; i
< ppt
->nsyms
; i
++)
3910 struct symbol
*sym
= ppt
->symbol
[i
];
3912 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3913 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
3914 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
3915 && !strcmp (SYMBOL_NAME (sym
), type_name_only
))
3917 obstack_free (symbol_obstack
, type_name
);
3918 type
= SYMBOL_TYPE (sym
);
3923 /* Didn't find the type to which this refers, so we must
3924 be dealing with a forward reference. Allocate a type
3925 structure for it, and keep track of it so we can
3926 fill in the rest of the fields when we get the full
3928 type
= dbx_alloc_type (typenums
);
3929 TYPE_CODE (type
) = code
;
3930 TYPE_NAME (type
) = type_name
;
3932 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3934 add_undefined_type (type
);
3950 read_type_number (pp
, xtypenums
);
3951 type
= *dbx_lookup_type (xtypenums
);
3953 type
= builtin_type_void
;
3954 if (typenums
[0] != -1)
3955 *dbx_lookup_type (typenums
) = type
;
3959 type1
= read_type (pp
);
3960 type
= lookup_pointer_type (type1
);
3961 if (typenums
[0] != -1)
3962 *dbx_lookup_type (typenums
) = type
;
3967 struct type
*domain
= read_type (pp
);
3968 struct type
*memtype
;
3971 /* Invalid member type data format. */
3972 return error_type (pp
);
3975 memtype
= read_type (pp
);
3976 type
= dbx_alloc_type (typenums
);
3977 smash_to_member_type (type
, domain
, memtype
);
3982 if ((*pp
)[0] == '#')
3984 /* We'll get the parameter types from the name. */
3985 struct type
*return_type
;
3988 return_type
= read_type (pp
);
3989 if (*(*pp
)++ != ';')
3990 complain (&invalid_member_complaint
, symnum
);
3991 type
= allocate_stub_method (return_type
);
3992 if (typenums
[0] != -1)
3993 *dbx_lookup_type (typenums
) = type
;
3997 struct type
*domain
= read_type (pp
);
3998 struct type
*return_type
;
4001 if (*(*pp
)++ != ',')
4002 error ("invalid member type data format, at symtab pos %d.",
4005 return_type
= read_type (pp
);
4006 args
= read_args (pp
, ';');
4007 type
= dbx_alloc_type (typenums
);
4008 smash_to_method_type (type
, domain
, return_type
, args
);
4013 type1
= read_type (pp
);
4014 type
= lookup_reference_type (type1
);
4015 if (typenums
[0] != -1)
4016 *dbx_lookup_type (typenums
) = type
;
4020 type1
= read_type (pp
);
4021 type
= lookup_function_type (type1
);
4022 if (typenums
[0] != -1)
4023 *dbx_lookup_type (typenums
) = type
;
4027 type
= read_range_type (pp
, typenums
);
4028 if (typenums
[0] != -1)
4029 *dbx_lookup_type (typenums
) = type
;
4033 type
= dbx_alloc_type (typenums
);
4034 type
= read_enum_type (pp
, type
);
4035 *dbx_lookup_type (typenums
) = type
;
4039 type
= dbx_alloc_type (typenums
);
4040 TYPE_NAME (type
) = type_synonym_name
;
4041 type_synonym_name
= 0;
4042 type
= read_struct_type (pp
, type
);
4046 type
= dbx_alloc_type (typenums
);
4047 TYPE_NAME (type
) = type_synonym_name
;
4048 type_synonym_name
= 0;
4049 type
= read_struct_type (pp
, type
);
4050 TYPE_CODE (type
) = TYPE_CODE_UNION
;
4055 return error_type (pp
);
4058 type
= dbx_alloc_type (typenums
);
4059 type
= read_array_type (pp
, type
);
4063 return error_type (pp
);
4070 /* If this is an overriding temporary alteration for a header file's
4071 contents, and this type number is unknown in the global definition,
4072 put this type into the global definition at this type number. */
4073 if (header_file_prev_index
>= 0)
4075 register struct type
**tp
4076 = explicit_lookup_type (header_file_prev_index
, typenums
[1]);
4085 /* This would be a good idea, but it doesn't really work. The problem
4086 is that in order to get the virtual context for a particular type,
4087 you need to know the virtual info from all of its basetypes,
4088 and you need to have processed its methods. Since GDB reads
4089 symbols on a file-by-file basis, this means processing the symbols
4090 of all the files that are needed for each baseclass, which
4091 means potentially reading in all the debugging info just to fill
4092 in information we may never need. */
4094 /* This page contains subroutines of read_type. */
4096 /* FOR_TYPE is a struct type defining a virtual function NAME with type
4097 FN_TYPE. The `virtual context' for this virtual function is the
4098 first base class of FOR_TYPE in which NAME is defined with signature
4099 matching FN_TYPE. OFFSET serves as a hash on matches here.
4101 TYPE is the current type in which we are searching. */
4103 static struct type
*
4104 virtual_context (for_type
, type
, name
, fn_type
, offset
)
4105 struct type
*for_type
, *type
;
4107 struct type
*fn_type
;
4110 struct type
*basetype
= 0;
4113 if (for_type
!= type
)
4115 /* Check the methods of TYPE. */
4116 /* Need to do a check_stub_type here, but that breaks
4117 things because we can get infinite regress. */
4118 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
4119 if (!strcmp (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
4123 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
4124 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
4127 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == offset
-1)
4128 return TYPE_FN_FIELD_FCONTEXT (f
, j
);
4131 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
4133 basetype
= virtual_context (for_type
, TYPE_BASECLASS (type
, i
), name
,
4135 if (basetype
!= for_type
)
4142 /* Read the description of a structure (or union type)
4143 and return an object describing the type. */
4145 static struct type
*
4146 read_struct_type (pp
, type
)
4148 register struct type
*type
;
4150 /* Total number of methods defined in this class.
4151 If the class defines two `f' methods, and one `g' method,
4152 then this will have the value 3. */
4153 int total_length
= 0;
4157 struct nextfield
*next
;
4158 int visibility
; /* 0=public, 1=protected, 2=public */
4164 struct next_fnfield
*next
;
4165 int visibility
; /* 0=public, 1=protected, 2=public */
4166 struct fn_field fn_field
;
4169 struct next_fnfieldlist
4171 struct next_fnfieldlist
*next
;
4172 struct fn_fieldlist fn_fieldlist
;
4175 register struct nextfield
*list
= 0;
4176 struct nextfield
*new;
4181 register struct next_fnfieldlist
*mainlist
= 0;
4184 if (TYPE_MAIN_VARIANT (type
) == 0)
4186 TYPE_MAIN_VARIANT (type
) = type
;
4189 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
4191 /* First comes the total size in bytes. */
4193 TYPE_LENGTH (type
) = read_number (pp
, 0);
4195 /* C++: Now, if the class is a derived class, then the next character
4196 will be a '!', followed by the number of base classes derived from.
4197 Each element in the list contains visibility information,
4198 the offset of this base class in the derived structure,
4199 and then the base type. */
4202 int i
, n_baseclasses
, offset
;
4203 struct type
*baseclass
;
4206 /* Nonzero if it is a virtual baseclass, i.e.,
4210 struct C : public B, public virtual A {};
4212 B is a baseclass of C; A is a virtual baseclass for C. This is a C++
4213 2.0 language feature. */
4218 n_baseclasses
= read_number (pp
, ',');
4219 TYPE_FIELD_VIRTUAL_BITS (type
) =
4220 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (n_baseclasses
));
4221 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), n_baseclasses
);
4223 for (i
= 0; i
< n_baseclasses
; i
++)
4226 *pp
= next_symbol_text ();
4237 /* Bad visibility format. */
4238 return error_type (pp
);
4251 /* Bad visibility format. */
4252 return error_type (pp
);
4255 SET_TYPE_FIELD_VIRTUAL (type
, i
);
4258 /* Offset of the portion of the object corresponding to
4259 this baseclass. Always zero in the absence of
4260 multiple inheritance. */
4261 offset
= read_number (pp
, ',');
4262 baseclass
= read_type (pp
);
4263 *pp
+= 1; /* skip trailing ';' */
4266 /* One's understanding improves, grasshopper... */
4269 static int error_printed
= 0;
4274 "\nWarning: GDB has limited understanding of multiple inheritance...");
4276 fprintf(stderr
, "\n");
4282 /* Make this baseclass visible for structure-printing purposes. */
4283 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4286 list
->visibility
= via_public
;
4287 list
->field
.type
= baseclass
;
4288 list
->field
.name
= type_name_no_tag (baseclass
);
4289 list
->field
.bitpos
= offset
;
4290 list
->field
.bitsize
= 0; /* this should be an unpacked field! */
4293 TYPE_N_BASECLASSES (type
) = n_baseclasses
;
4296 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
4297 At the end, we see a semicolon instead of a field.
4299 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
4302 The `?' is a placeholder for one of '/2' (public visibility),
4303 '/1' (protected visibility), '/0' (private visibility), or nothing
4304 (C style symbol table, public visibility). */
4306 /* We better set p right now, in case there are no fields at all... */
4311 /* Check for and handle cretinous dbx symbol name continuation! */
4312 if (**pp
== '\\') *pp
= next_symbol_text ();
4314 /* Get space to record the next field's data. */
4315 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4319 /* Get the field name. */
4321 if (*p
== CPLUS_MARKER
)
4323 /* Special GNU C++ name. */
4328 struct type
*context
;
4339 error ("invalid abbreviation at symtab pos %d.", symnum
);
4342 context
= read_type (pp
);
4343 if (type_name_no_tag (context
) == 0)
4346 error ("type name unknown at symtab pos %d.", symnum
);
4347 /* FIXME-tiemann: when is `name' ever non-0? */
4348 TYPE_NAME (context
) = obsavestring (name
, p
- name
- 1);
4350 list
->field
.name
= obconcat (prefix
, type_name_no_tag (context
), "");
4353 error ("invalid abbreviation at symtab pos %d.", symnum
);
4354 list
->field
.type
= read_type (pp
);
4355 (*pp
)++; /* Skip the comma. */
4356 list
->field
.bitpos
= read_number (pp
, ';');
4357 /* This field is unpacked. */
4358 list
->field
.bitsize
= 0;
4360 /* GNU C++ anonymous type. */
4364 error ("invalid abbreviation at symtab pos %d.", symnum
);
4370 while (*p
!= ':') p
++;
4371 list
->field
.name
= obsavestring (*pp
, p
- *pp
);
4373 /* C++: Check to see if we have hit the methods yet. */
4379 /* This means we have a visibility for a field coming. */
4385 list
->visibility
= 0; /* private */
4390 list
->visibility
= 1; /* protected */
4395 list
->visibility
= 2; /* public */
4400 else /* normal dbx-style format. */
4401 list
->visibility
= 2; /* public */
4403 list
->field
.type
= read_type (pp
);
4406 /* Static class member. */
4407 list
->field
.bitpos
= (long)-1;
4409 while (*p
!= ';') p
++;
4410 list
->field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
4415 else if (**pp
!= ',')
4416 /* Bad structure-type format. */
4417 return error_type (pp
);
4419 (*pp
)++; /* Skip the comma. */
4420 list
->field
.bitpos
= read_number (pp
, ',');
4421 list
->field
.bitsize
= read_number (pp
, ';');
4424 /* FIXME-tiemann: Can't the compiler put out something which
4425 lets us distinguish these? (or maybe just not put out anything
4426 for the field). What is the story here? What does the compiler
4427 really do? Also, patch gdb.texinfo for this case; I document
4428 it as a possible problem there. Search for "DBX-style". */
4430 /* This is wrong because this is identical to the symbols
4431 produced for GCC 0-size arrays. For example:
4436 The code which dumped core in such circumstances should be
4437 fixed not to dump core. */
4439 /* g++ -g0 can put out bitpos & bitsize zero for a static
4440 field. This does not give us any way of getting its
4441 class, so we can't know its name. But we can just
4442 ignore the field so we don't dump core and other nasty
4444 if (list
->field
.bitpos
== 0
4445 && list
->field
.bitsize
== 0)
4447 complain (&dbx_class_complaint
, 0);
4448 /* Ignore this field. */
4454 /* Detect an unpacked field and mark it as such.
4455 dbx gives a bit size for all fields.
4456 Note that forward refs cannot be packed,
4457 and treat enums as if they had the width of ints. */
4458 if (TYPE_CODE (list
->field
.type
) != TYPE_CODE_INT
4459 && TYPE_CODE (list
->field
.type
) != TYPE_CODE_ENUM
)
4460 list
->field
.bitsize
= 0;
4461 if ((list
->field
.bitsize
== 8 * TYPE_LENGTH (list
->field
.type
)
4462 || (TYPE_CODE (list
->field
.type
) == TYPE_CODE_ENUM
4463 && (list
->field
.bitsize
4464 == 8 * TYPE_LENGTH (builtin_type_int
))
4468 list
->field
.bitpos
% 8 == 0)
4469 list
->field
.bitsize
= 0;
4475 /* chill the list of fields: the last entry (at the head)
4476 is a partially constructed entry which we now scrub. */
4479 /* Now create the vector of fields, and record how big it is.
4480 We need this info to record proper virtual function table information
4481 for this class's virtual functions. */
4483 TYPE_NFIELDS (type
) = nfields
;
4484 TYPE_FIELDS (type
) = (struct field
*) obstack_alloc (symbol_obstack
,
4485 sizeof (struct field
) * nfields
);
4487 TYPE_FIELD_PRIVATE_BITS (type
) =
4488 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (nfields
));
4489 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4491 TYPE_FIELD_PROTECTED_BITS (type
) =
4492 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (nfields
));
4493 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4495 /* Copy the saved-up fields into the field vector. */
4497 for (n
= nfields
; list
; list
= list
->next
)
4500 TYPE_FIELD (type
, n
) = list
->field
;
4501 if (list
->visibility
== 0)
4502 SET_TYPE_FIELD_PRIVATE (type
, n
);
4503 else if (list
->visibility
== 1)
4504 SET_TYPE_FIELD_PROTECTED (type
, n
);
4507 /* Now come the method fields, as NAME::methods
4508 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
4509 At the end, we see a semicolon instead of a field.
4511 For the case of overloaded operators, the format is
4512 OPERATOR::*.methods, where OPERATOR is the string "operator",
4513 `*' holds the place for an operator name (such as `+=')
4514 and `.' marks the end of the operator name. */
4517 /* Now, read in the methods. To simplify matters, we
4518 "unread" the name that has been read, so that we can
4519 start from the top. */
4521 /* For each list of method lists... */
4525 struct next_fnfield
*sublist
= 0;
4526 struct type
*look_ahead_type
= NULL
;
4528 struct next_fnfieldlist
*new_mainlist
=
4529 (struct next_fnfieldlist
*)alloca (sizeof (struct next_fnfieldlist
));
4534 /* read in the name. */
4535 while (*p
!= ':') p
++;
4536 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
4538 /* This lets the user type "break operator+".
4539 We could just put in "+" as the name, but that wouldn't
4541 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
4542 char *o
= opname
+ 3;
4544 /* Skip past '::'. */
4548 main_fn_name
= savestring (opname
, o
- opname
);
4555 main_fn_name
= savestring (*pp
, p
- *pp
);
4556 /* Skip past '::'. */
4559 new_mainlist
->fn_fieldlist
.name
= main_fn_name
;
4563 struct next_fnfield
*new_sublist
=
4564 (struct next_fnfield
*)alloca (sizeof (struct next_fnfield
));
4566 /* Check for and handle cretinous dbx symbol name continuation! */
4567 if (look_ahead_type
== NULL
) /* Normal case. */
4569 if (**pp
== '\\') *pp
= next_symbol_text ();
4571 new_sublist
->fn_field
.type
= read_type (pp
);
4573 /* Invalid symtab info for method. */
4574 return error_type (pp
);
4577 { /* g++ version 1 kludge */
4578 new_sublist
->fn_field
.type
= look_ahead_type
;
4579 look_ahead_type
= NULL
;
4584 while (*p
!= ';') p
++;
4585 /* If this is just a stub, then we don't have the
4587 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
4589 new_sublist
->visibility
= *(*pp
)++ - '0';
4590 if (**pp
== '\\') *pp
= next_symbol_text ();
4591 /* FIXME-tiemann: need to add const/volatile info
4592 to the methods. For now, just skip the char.
4593 In future, here's what we need to implement:
4595 A for normal functions.
4596 B for `const' member functions.
4597 C for `volatile' member functions.
4598 D for `const volatile' member functions. */
4599 if (**pp
== 'A' || **pp
== 'B' || **pp
== 'C' || **pp
== 'D')
4602 /* This probably just means we're processing a file compiled
4603 with g++ version 1. */
4605 complain(&const_vol_complaint
, **pp
);
4611 /* virtual member function, followed by index. */
4612 /* The sign bit is set to distinguish pointers-to-methods
4613 from virtual function indicies. Since the array is
4614 in words, the quantity must be shifted left by 1
4615 on 16 bit machine, and by 2 on 32 bit machine, forcing
4616 the sign bit out, and usable as a valid index into
4617 the array. Remove the sign bit here. */
4618 new_sublist
->fn_field
.voffset
=
4619 (0x7fffffff & read_number (pp
, ';')) + 1;
4621 if (**pp
== '\\') *pp
= next_symbol_text ();
4623 if (**pp
== ';' || **pp
== '\0')
4624 /* Must be g++ version 1. */
4625 new_sublist
->fn_field
.fcontext
= 0;
4628 /* Figure out from whence this virtual function came.
4629 It may belong to virtual function table of
4630 one of its baseclasses. */
4631 look_ahead_type
= read_type (pp
);
4633 { /* g++ version 1 overloaded methods. */ }
4636 new_sublist
->fn_field
.fcontext
= look_ahead_type
;
4638 return error_type (pp
);
4641 look_ahead_type
= NULL
;
4647 /* static member function. */
4648 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
4652 /* normal member function. */
4653 new_sublist
->fn_field
.voffset
= 0;
4654 new_sublist
->fn_field
.fcontext
= 0;
4658 new_sublist
->next
= sublist
;
4659 sublist
= new_sublist
;
4662 while (**pp
!= ';' && **pp
!= '\0');
4666 new_mainlist
->fn_fieldlist
.fn_fields
=
4667 (struct fn_field
*) obstack_alloc (symbol_obstack
,
4668 sizeof (struct fn_field
) * length
);
4669 TYPE_FN_PRIVATE_BITS (new_mainlist
->fn_fieldlist
) =
4670 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (length
));
4671 B_CLRALL (TYPE_FN_PRIVATE_BITS (new_mainlist
->fn_fieldlist
), length
);
4673 TYPE_FN_PROTECTED_BITS (new_mainlist
->fn_fieldlist
) =
4674 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (length
));
4675 B_CLRALL (TYPE_FN_PROTECTED_BITS (new_mainlist
->fn_fieldlist
), length
);
4677 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
4679 new_mainlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
4680 if (sublist
->visibility
== 0)
4681 B_SET (new_mainlist
->fn_fieldlist
.private_fn_field_bits
, i
);
4682 else if (sublist
->visibility
== 1)
4683 B_SET (new_mainlist
->fn_fieldlist
.protected_fn_field_bits
, i
);
4686 new_mainlist
->fn_fieldlist
.length
= length
;
4687 new_mainlist
->next
= mainlist
;
4688 mainlist
= new_mainlist
;
4690 total_length
+= length
;
4692 while (**pp
!= ';');
4697 TYPE_FN_FIELDLISTS (type
) =
4698 (struct fn_fieldlist
*) obstack_alloc (symbol_obstack
,
4699 sizeof (struct fn_fieldlist
) * nfn_fields
);
4701 TYPE_NFN_FIELDS (type
) = nfn_fields
;
4702 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
4706 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
4707 TYPE_NFN_FIELDS_TOTAL (type
) +=
4708 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, i
));
4711 for (n
= nfn_fields
; mainlist
; mainlist
= mainlist
->next
)
4712 TYPE_FN_FIELDLISTS (type
)[--n
] = mainlist
->fn_fieldlist
;
4721 |= TYPE_FLAG_HAS_CONSTRUCTOR
| TYPE_FLAG_HAS_DESTRUCTOR
;
4724 else if (**pp
== '+')
4726 TYPE_FLAGS (type
) |= TYPE_FLAG_HAS_CONSTRUCTOR
;
4729 else if (**pp
== '-')
4731 TYPE_FLAGS (type
) |= TYPE_FLAG_HAS_DESTRUCTOR
;
4735 /* Read either a '%' or the final ';'. */
4736 if (*(*pp
)++ == '%')
4738 /* Now we must record the virtual function table pointer's
4739 field information. */
4746 while (*p
!= '\0' && *p
!= ';')
4749 /* Premature end of symbol. */
4750 return error_type (pp
);
4752 TYPE_VPTR_BASETYPE (type
) = t
;
4755 if (TYPE_FIELD_NAME (t
, TYPE_N_BASECLASSES (t
)) == 0)
4757 /* FIXME-tiemann: what's this? */
4759 TYPE_VPTR_FIELDNO (type
) = i
= TYPE_N_BASECLASSES (t
);
4764 else for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); --i
)
4765 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
4766 sizeof (vptr_name
) -1))
4768 TYPE_VPTR_FIELDNO (type
) = i
;
4772 /* Virtual function table field not found. */
4773 return error_type (pp
);
4776 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
4784 /* Read a definition of an array type,
4785 and create and return a suitable type object.
4786 Also creates a range type which represents the bounds of that
4788 static struct type
*
4789 read_array_type (pp
, type
)
4791 register struct type
*type
;
4793 struct type
*index_type
, *element_type
, *range_type
;
4797 /* Format of an array type:
4798 "ar<index type>;lower;upper;<array_contents_type>". Put code in
4801 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
4802 for these, produce a type like float[][]. */
4804 index_type
= read_type (pp
);
4806 /* Improper format of array type decl. */
4807 return error_type (pp
);
4810 if (!(**pp
>= '0' && **pp
<= '9'))
4815 lower
= read_number (pp
, ';');
4817 if (!(**pp
>= '0' && **pp
<= '9'))
4822 upper
= read_number (pp
, ';');
4824 element_type
= read_type (pp
);
4833 /* Create range type. */
4834 range_type
= (struct type
*) obstack_alloc (symbol_obstack
,
4835 sizeof (struct type
));
4836 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
4837 TYPE_TARGET_TYPE (range_type
) = index_type
;
4839 /* This should never be needed. */
4840 TYPE_LENGTH (range_type
) = sizeof (int);
4842 TYPE_NFIELDS (range_type
) = 2;
4843 TYPE_FIELDS (range_type
) =
4844 (struct field
*) obstack_alloc (symbol_obstack
,
4845 2 * sizeof (struct field
));
4846 TYPE_FIELD_BITPOS (range_type
, 0) = lower
;
4847 TYPE_FIELD_BITPOS (range_type
, 1) = upper
;
4850 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
4851 TYPE_TARGET_TYPE (type
) = element_type
;
4852 TYPE_LENGTH (type
) = (upper
- lower
+ 1) * TYPE_LENGTH (element_type
);
4853 TYPE_NFIELDS (type
) = 1;
4854 TYPE_FIELDS (type
) =
4855 (struct field
*) obstack_alloc (symbol_obstack
,
4856 sizeof (struct field
));
4857 TYPE_FIELD_TYPE (type
, 0) = range_type
;
4863 /* Read a definition of an enumeration type,
4864 and create and return a suitable type object.
4865 Also defines the symbols that represent the values of the type. */
4867 static struct type
*
4868 read_enum_type (pp
, type
)
4870 register struct type
*type
;
4875 register struct symbol
*sym
;
4877 struct pending
**symlist
;
4878 struct pending
*osyms
, *syms
;
4881 if (within_function
)
4882 symlist
= &local_symbols
;
4884 symlist
= &file_symbols
;
4886 o_nsyms
= osyms
? osyms
->nsyms
: 0;
4888 /* Read the value-names and their values.
4889 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
4890 A semicolon or comman instead of a NAME means the end. */
4891 while (**pp
&& **pp
!= ';' && **pp
!= ',')
4893 /* Check for and handle cretinous dbx symbol name continuation! */
4894 if (**pp
== '\\') *pp
= next_symbol_text ();
4897 while (*p
!= ':') p
++;
4898 name
= obsavestring (*pp
, p
- *pp
);
4900 n
= read_number (pp
, ',');
4902 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
4903 bzero (sym
, sizeof (struct symbol
));
4904 SYMBOL_NAME (sym
) = name
;
4905 SYMBOL_CLASS (sym
) = LOC_CONST
;
4906 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4907 SYMBOL_VALUE (sym
) = n
;
4908 add_symbol_to_list (sym
, symlist
);
4913 (*pp
)++; /* Skip the semicolon. */
4915 /* Now fill in the fields of the type-structure. */
4917 TYPE_LENGTH (type
) = sizeof (int);
4918 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4919 TYPE_NFIELDS (type
) = nsyms
;
4920 TYPE_FIELDS (type
) = (struct field
*) obstack_alloc (symbol_obstack
, sizeof (struct field
) * nsyms
);
4922 /* Find the symbols for the values and put them into the type.
4923 The symbols can be found in the symlist that we put them on
4924 to cause them to be defined. osyms contains the old value
4925 of that symlist; everything up to there was defined by us. */
4926 /* Note that we preserve the order of the enum constants, so
4927 that in something like "enum {FOO, LAST_THING=FOO}" we print
4928 FOO, not LAST_THING. */
4930 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
4935 for (; j
< syms
->nsyms
; j
++,n
++)
4937 struct symbol
*sym
= syms
->symbol
[j
];
4938 SYMBOL_TYPE (sym
) = type
;
4939 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (sym
);
4940 TYPE_FIELD_VALUE (type
, n
) = 0;
4941 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (sym
);
4942 TYPE_FIELD_BITSIZE (type
, n
) = 0;
4951 /* Read a number from the string pointed to by *PP.
4952 The value of *PP is advanced over the number.
4953 If END is nonzero, the character that ends the
4954 number must match END, or an error happens;
4955 and that character is skipped if it does match.
4956 If END is zero, *PP is left pointing to that character.
4958 If the number fits in a long, set *VALUE and set *BITS to 0.
4959 If not, set *BITS to be the number of bits in the number.
4961 If encounter garbage, set *BITS to -1. */
4964 read_huge_number (pp
, end
, valu
, bits
)
4985 /* Leading zero means octal. GCC uses this to output values larger
4986 than an int (because that would be hard in decimal). */
4993 upper_limit
= LONG_MAX
/ radix
;
4994 while ((c
= *p
++) >= '0' && c
<= ('0' + radix
))
4996 if (n
<= upper_limit
)
4999 n
+= c
- '0'; /* FIXME this overflows anyway */
5004 /* This depends on large values being output in octal, which is
5011 /* Ignore leading zeroes. */
5015 else if (c
== '2' || c
== '3')
5041 /* Large decimal constants are an error (because it is hard to
5042 count how many bits are in them). */
5048 /* -0x7f is the same as 0x80. So deal with it by adding one to
5049 the number of bits. */
5064 #define MAX_OF_TYPE(t) ((1 << (sizeof (t)*8 - 1)) - 1)
5065 #define MIN_OF_TYPE(t) (-(1 << (sizeof (t)*8 - 1)))
5067 static struct type
*
5068 read_range_type (pp
, typenums
)
5076 struct type
*result_type
;
5078 /* First comes a type we are a subrange of.
5079 In C it is usually 0, 1 or the type being defined. */
5080 read_type_number (pp
, rangenums
);
5081 self_subrange
= (rangenums
[0] == typenums
[0] &&
5082 rangenums
[1] == typenums
[1]);
5084 /* A semicolon should now follow; skip it. */
5088 /* The remaining two operands are usually lower and upper bounds
5089 of the range. But in some special cases they mean something else. */
5090 read_huge_number (pp
, ';', &n2
, &n2bits
);
5091 read_huge_number (pp
, ';', &n3
, &n3bits
);
5093 if (n2bits
== -1 || n3bits
== -1)
5094 return error_type (pp
);
5096 /* If limits are huge, must be large integral type. */
5097 if (n2bits
!= 0 || n3bits
!= 0)
5099 char got_signed
= 0;
5100 char got_unsigned
= 0;
5101 /* Number of bits in the type. */
5104 /* Range from 0 to <large number> is an unsigned large integral type. */
5105 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
5110 /* Range from <large number> to <large number>-1 is a large signed
5112 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
5118 /* Check for "long long". */
5119 if (got_signed
&& nbits
== TARGET_LONG_LONG_BIT
)
5120 return builtin_type_long_long
;
5121 if (got_unsigned
&& nbits
== TARGET_LONG_LONG_BIT
)
5122 return builtin_type_unsigned_long_long
;
5124 if (got_signed
|| got_unsigned
)
5126 result_type
= (struct type
*) obstack_alloc (symbol_obstack
,
5127 sizeof (struct type
));
5128 bzero (result_type
, sizeof (struct type
));
5129 TYPE_LENGTH (result_type
) = nbits
/ TARGET_CHAR_BIT
;
5130 TYPE_MAIN_VARIANT (result_type
) = result_type
;
5131 TYPE_CODE (result_type
) = TYPE_CODE_INT
;
5133 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
5137 return error_type (pp
);
5140 /* A type defined as a subrange of itself, with bounds both 0, is void. */
5141 if (self_subrange
&& n2
== 0 && n3
== 0)
5142 return builtin_type_void
;
5144 /* If n3 is zero and n2 is not, we want a floating type,
5145 and n2 is the width in bytes.
5147 Fortran programs appear to use this for complex types also,
5148 and they give no way to distinguish between double and single-complex!
5149 We don't have complex types, so we would lose on all fortran files!
5150 So return type `double' for all of those. It won't work right
5151 for the complex values, but at least it makes the file loadable. */
5153 if (n3
== 0 && n2
> 0)
5155 if (n2
== sizeof (float))
5156 return builtin_type_float
;
5157 return builtin_type_double
;
5160 /* If the upper bound is -1, it must really be an unsigned int. */
5162 else if (n2
== 0 && n3
== -1)
5164 if (sizeof (int) == sizeof (long))
5165 return builtin_type_unsigned_int
;
5167 return builtin_type_unsigned_long
;
5170 /* Special case: char is defined (Who knows why) as a subrange of
5171 itself with range 0-127. */
5172 else if (self_subrange
&& n2
== 0 && n3
== 127)
5173 return builtin_type_char
;
5175 /* Assumptions made here: Subrange of self is equivalent to subrange
5178 && (self_subrange
||
5179 *dbx_lookup_type (rangenums
) == builtin_type_int
))
5181 /* an unsigned type */
5183 if (n3
== - sizeof (long long))
5184 return builtin_type_unsigned_long_long
;
5186 if (n3
== (unsigned int)~0L)
5187 return builtin_type_unsigned_int
;
5188 if (n3
== (unsigned long)~0L)
5189 return builtin_type_unsigned_long
;
5190 if (n3
== (unsigned short)~0L)
5191 return builtin_type_unsigned_short
;
5192 if (n3
== (unsigned char)~0L)
5193 return builtin_type_unsigned_char
;
5196 else if (n3
== 0 && n2
== -sizeof (long long))
5197 return builtin_type_long_long
;
5199 else if (n2
== -n3
-1)
5202 if (n3
== (1 << (8 * sizeof (int) - 1)) - 1)
5203 return builtin_type_int
;
5204 if (n3
== (1 << (8 * sizeof (long) - 1)) - 1)
5205 return builtin_type_long
;
5206 if (n3
== (1 << (8 * sizeof (short) - 1)) - 1)
5207 return builtin_type_short
;
5208 if (n3
== (1 << (8 * sizeof (char) - 1)) - 1)
5209 return builtin_type_char
;
5212 /* We have a real range type on our hands. Allocate space and
5213 return a real pointer. */
5215 /* At this point I don't have the faintest idea how to deal with
5216 a self_subrange type; I'm going to assume that this is used
5217 as an idiom, and that all of them are special cases. So . . . */
5219 return error_type (pp
);
5221 result_type
= (struct type
*) obstack_alloc (symbol_obstack
,
5222 sizeof (struct type
));
5223 bzero (result_type
, sizeof (struct type
));
5225 TYPE_TARGET_TYPE (result_type
) = (self_subrange
?
5227 *dbx_lookup_type(rangenums
));
5229 /* We have to figure out how many bytes it takes to hold this
5230 range type. I'm going to assume that anything that is pushing
5231 the bounds of a long was taken care of above. */
5232 if (n2
>= MIN_OF_TYPE(char) && n3
<= MAX_OF_TYPE(char))
5233 TYPE_LENGTH (result_type
) = 1;
5234 else if (n2
>= MIN_OF_TYPE(short) && n3
<= MAX_OF_TYPE(short))
5235 TYPE_LENGTH (result_type
) = sizeof (short);
5236 else if (n2
>= MIN_OF_TYPE(int) && n3
<= MAX_OF_TYPE(int))
5237 TYPE_LENGTH (result_type
) = sizeof (int);
5238 else if (n2
>= MIN_OF_TYPE(long) && n3
<= MAX_OF_TYPE(long))
5239 TYPE_LENGTH (result_type
) = sizeof (long);
5241 /* Ranged type doesn't fit within known sizes. */
5242 return error_type (pp
);
5244 TYPE_LENGTH (result_type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type
));
5245 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
5246 TYPE_NFIELDS (result_type
) = 2;
5247 TYPE_FIELDS (result_type
) =
5248 (struct field
*) obstack_alloc (symbol_obstack
,
5249 2 * sizeof (struct field
));
5250 bzero (TYPE_FIELDS (result_type
), 2 * sizeof (struct field
));
5251 TYPE_FIELD_BITPOS (result_type
, 0) = n2
;
5252 TYPE_FIELD_BITPOS (result_type
, 1) = n3
;
5257 /* Read a number from the string pointed to by *PP.
5258 The value of *PP is advanced over the number.
5259 If END is nonzero, the character that ends the
5260 number must match END, or an error happens;
5261 and that character is skipped if it does match.
5262 If END is zero, *PP is left pointing to that character. */
5265 read_number (pp
, end
)
5269 register char *p
= *pp
;
5270 register long n
= 0;
5274 /* Handle an optional leading minus sign. */
5282 /* Read the digits, as far as they go. */
5284 while ((c
= *p
++) >= '0' && c
<= '9')
5292 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c
, symnum
);
5301 /* Read in an argument list. This is a list of types, separated by commas
5302 and terminated with END. Return the list of types read in, or (struct type
5303 **)-1 if there is an error. */
5304 static struct type
**
5309 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
5315 /* Invalid argument list: no ','. */
5316 return (struct type
**)-1;
5319 /* Check for and handle cretinous dbx symbol name continuation! */
5321 *pp
= next_symbol_text ();
5323 types
[n
++] = read_type (pp
);
5325 *pp
+= 1; /* get past `end' (the ':' character) */
5329 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
5331 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
5333 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
5334 bzero (rval
+ n
, sizeof (struct type
*));
5338 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
5340 bcopy (types
, rval
, n
* sizeof (struct type
*));
5344 /* Copy a pending list, used to record the contents of a common
5345 block for later fixup. */
5346 static struct pending
*
5347 copy_pending (beg
, begi
, end
)
5348 struct pending
*beg
, *end
;
5351 struct pending
*new = 0;
5352 struct pending
*next
;
5354 for (next
= beg
; next
!= 0 && (next
!= end
|| begi
< end
->nsyms
);
5355 next
= next
->next
, begi
= 0)
5358 for (j
= begi
; j
< next
->nsyms
; j
++)
5359 add_symbol_to_list (next
->symbol
[j
], &new);
5364 /* Add a common block's start address to the offset of each symbol
5365 declared to be in it (by being between a BCOMM/ECOMM pair that uses
5366 the common block name). */
5369 fix_common_block (sym
, valu
)
5373 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
5374 for ( ; next
; next
= next
->next
)
5377 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
5378 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
5382 /* Register our willingness to decode symbols for SunOS and a.out and
5383 b.out files handled by BFD... */
5384 static struct sym_fns sunos_sym_fns
= {"sunOs", 6,
5385 dbx_new_init
, dbx_symfile_init
, dbx_symfile_read
};
5387 static struct sym_fns aout_sym_fns
= {"a.out", 5,
5388 dbx_new_init
, dbx_symfile_init
, dbx_symfile_read
};
5390 static struct sym_fns bout_sym_fns
= {"b.out", 5,
5391 dbx_new_init
, dbx_symfile_init
, dbx_symfile_read
};
5394 _initialize_dbxread ()
5396 add_symtab_fns(&sunos_sym_fns
);
5397 add_symtab_fns(&aout_sym_fns
);
5398 add_symtab_fns(&bout_sym_fns
);
5400 undef_types_allocated
= 20;
5401 undef_types_length
= 0;
5402 undef_types
= (struct type
**) xmalloc (undef_types_allocated
*
5403 sizeof (struct type
*));