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 GDB 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 1, or (at your option)
11 GDB 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 GDB; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* Symbol read-in occurs in two phases:
21 1. A scan (read_dbx_symtab()) of the entire executable, whose sole
22 purpose is to make a list of symbols (partial symbol table)
23 which will cause symbols
24 to be read in if referenced. This scan happens when the
25 "symbol-file" command is given (symbol_file_command()).
26 1a. The "add-file" command. Similar to #1.
27 2. Full read-in of symbols. (dbx_psymtab_to_symtab()). This happens
28 when a symbol in a file for which symbols have not yet been
29 read in is referenced. */
31 /* There used to be some PROFILE_TYPES code in this file which counted
32 the number of occurances of various symbols. I'd suggest instead:
33 nm -ap foo | awk 'print $5' | sort | uniq -c
34 to print how many of each n_type, or something like
35 nm -ap foo | awk '$5 == "LSYM" {print $6 $7 $8 $9 $10 $11}' | \
37 {print substr($2,1,1)}' | sort | uniq -c
38 to print the number of each kind of symbol descriptor (i.e. the letter
47 #include <sys/types.h>
53 #include "a.out.gnu.h"
54 #include "stab.gnu.h" /* We always use GNU stabs, not native, now */
59 * Define specifically gnu symbols here.
62 /* The following type indicates the definition of a symbol as being
63 an indirect reference to another symbol. The other symbol
64 appears as an undefined reference, immediately following this symbol.
66 Indirection is asymmetrical. The other symbol's value will be used
67 to satisfy requests for the indirect symbol, but not vice versa.
68 If the other symbol does not have a definition, libraries will
69 be searched to find a definition. */
74 /* The following symbols refer to set elements.
75 All the N_SET[ATDB] symbols with the same name form one set.
76 Space is allocated for the set in the text section, and each set
77 element's value is stored into one word of the space.
78 The first word of the space is the length of the set (number of elements).
80 The address of the set is made into an N_SETV symbol
81 whose name is the same as the name of the set.
82 This symbol acts like a N_DATA global symbol
83 in that it can satisfy undefined external references. */
86 #define N_SETA 0x14 /* Absolute set element symbol */
87 #endif /* This is input to LD, in a .o file. */
90 #define N_SETT 0x16 /* Text set element symbol */
91 #endif /* This is input to LD, in a .o file. */
94 #define N_SETD 0x18 /* Data set element symbol */
95 #endif /* This is input to LD, in a .o file. */
98 #define N_SETB 0x1A /* Bss set element symbol */
99 #endif /* This is input to LD, in a .o file. */
101 /* Macros dealing with the set element symbols defined in a.out.h */
102 #define SET_ELEMENT_P(x) ((x)>=N_SETA&&(x)<=(N_SETB|N_EXT))
103 #define TYPE_OF_SET_ELEMENT(x) ((x)-N_SETA+N_ABS)
106 #define N_SETV 0x1C /* Pointer to set vector in data area. */
107 #endif /* This is output from LD. */
110 #define N_WARNING 0x1E /* Warning message to print if file included */
111 #endif /* This is input to ld */
113 #endif /* NO_GNU_STABS */
116 #include <sys/param.h>
117 #include <sys/file.h>
118 #include <sys/stat.h>
120 #include "breakpoint.h"
123 #include "gdbcore.h" /* for bfd stuff */
124 #include "liba.out.h" /* FIXME Secret internal BFD stuff for a.out */
127 struct dbx_symfile_info
{
128 asection
*text_sect
; /* Text section accessor */
129 int symcount
; /* How many symbols are there in the file */
130 char *stringtab
; /* The actual string table */
131 int stringtab_size
; /* Its size */
132 off_t symtab_offset
; /* Offset in file to symbol table */
133 int desc
; /* File descriptor of symbol file */
136 extern void qsort ();
137 extern double atof ();
138 extern struct cmd_list_element
*cmdlist
;
140 extern void symbol_file_command ();
142 /* Forward declarations */
144 static void add_symbol_to_list ();
145 static void read_dbx_symtab ();
146 static void init_psymbol_list ();
147 static void process_one_symbol ();
148 static struct type
*read_type ();
149 static struct type
*read_range_type ();
150 static struct type
*read_enum_type ();
151 static struct type
*read_struct_type ();
152 static struct type
*read_array_type ();
153 static long read_number ();
154 static void finish_block ();
155 static struct blockvector
*make_blockvector ();
156 static struct symbol
*define_symbol ();
157 static void start_subfile ();
158 static int hashname ();
159 static struct pending
*copy_pending ();
160 static void fix_common_block ();
161 static void add_undefined_type ();
162 static void cleanup_undefined_types ();
163 static void scan_file_globals ();
164 static void read_ofile_symtab ();
165 static void dbx_psymtab_to_symtab ();
168 static struct type
**read_args ();
170 static const char vptr_name
[] = { '_','v','p','t','r',CPLUS_MARKER
};
171 static const char vb_name
[] = { '_','v','b',CPLUS_MARKER
};
173 /* Macro to determine which symbols to ignore when reading the first symbol
174 of a file. Some machines override this definition. */
175 #ifndef IGNORE_SYMBOL
176 /* This code is used on Ultrix systems. Ignore it */
177 #define IGNORE_SYMBOL(type) (type == (int)N_NSYMS)
180 /* Macro for name of symbol to indicate a file compiled with gcc. */
181 #ifndef GCC_COMPILED_FLAG_SYMBOL
182 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
185 /* Convert stab register number (from `r' declaration) to a gdb REGNUM. */
187 #ifndef STAB_REG_TO_REGNUM
188 #define STAB_REG_TO_REGNUM(VALUE) (VALUE)
191 /* Define this as 1 if a pcc declaration of a char or short argument
192 gives the correct address. Otherwise assume pcc gives the
193 address of the corresponding int, which is not the same on a
194 big-endian machine. */
196 #ifndef BELIEVE_PCC_PROMOTION
197 #define BELIEVE_PCC_PROMOTION 0
200 /* Nonzero means give verbose info on gdb action. From main.c. */
201 extern int info_verbose
;
203 /* Name of source file whose symbol data we are now processing.
204 This comes from a symbol of type N_SO. */
206 static char *last_source_file
;
208 /* Core address of start of text of current source file.
209 This too comes from the N_SO symbol. */
211 static CORE_ADDR last_source_start_addr
;
213 /* The entry point of a file we are reading. */
214 CORE_ADDR entry_point
;
216 /* The list of sub-source-files within the current individual compilation.
217 Each file gets its own symtab with its own linetable and associated info,
218 but they all share one blockvector. */
222 struct subfile
*next
;
225 struct linetable
*line_vector
;
226 int line_vector_length
;
227 int line_vector_index
;
228 int prev_line_number
;
231 static struct subfile
*subfiles
;
233 static struct subfile
*current_subfile
;
235 /* Count symbols as they are processed, for error messages. */
237 static unsigned int symnum
;
239 /* Vector of types defined so far, indexed by their dbx type numbers.
240 (In newer sun systems, dbx uses a pair of numbers in parens,
241 as in "(SUBFILENUM,NUMWITHINSUBFILE)". Then these numbers must be
242 translated through the type_translations hash table to get
243 the index into the type vector.) */
245 static struct typevector
*type_vector
;
247 /* Number of elements allocated for type_vector currently. */
249 static int type_vector_length
;
251 /* Vector of line number information. */
253 static struct linetable
*line_vector
;
255 /* Index of next entry to go in line_vector_index. */
257 static int line_vector_index
;
259 /* Last line number recorded in the line vector. */
261 static int prev_line_number
;
263 /* Number of elements allocated for line_vector currently. */
265 static int line_vector_length
;
267 /* Hash table of global symbols whose values are not known yet.
268 They are chained thru the SYMBOL_VALUE_CHAIN, since we don't
269 have the correct data for that slot yet. */
270 /* The use of the LOC_BLOCK code in this chain is nonstandard--
271 it refers to a FORTRAN common block rather than the usual meaning. */
274 static struct symbol
*global_sym_chain
[HASHSIZE
];
276 /* Record the symbols defined for each context in a list.
277 We don't create a struct block for the context until we
278 know how long to make it. */
280 #define PENDINGSIZE 100
284 struct pending
*next
;
286 struct symbol
*symbol
[PENDINGSIZE
];
289 /* List of free `struct pending' structures for reuse. */
290 struct pending
*free_pendings
;
292 /* Here are the three lists that symbols are put on. */
294 struct pending
*file_symbols
; /* static at top level, and types */
296 struct pending
*global_symbols
; /* global functions and variables */
298 struct pending
*local_symbols
; /* everything local to lexical context */
300 /* List of symbols declared since the last BCOMM. This list is a tail
301 of local_symbols. When ECOMM is seen, the symbols on the list
302 are noted so their proper addresses can be filled in later,
303 using the common block base address gotten from the assembler
306 struct pending
*common_block
;
309 /* Stack representing unclosed lexical contexts
310 (that will become blocks, eventually). */
314 struct pending
*locals
;
315 struct pending_block
*old_blocks
;
317 CORE_ADDR start_addr
;
318 CORE_ADDR end_addr
; /* Temp slot for exception handling. */
322 struct context_stack
*context_stack
;
324 /* Index of first unused entry in context stack. */
325 int context_stack_depth
;
327 /* Currently allocated size of context stack. */
329 int context_stack_size
;
331 /* Nonzero if within a function (so symbols should be local,
332 if nothing says specifically). */
336 /* List of blocks already made (lexical contexts already closed).
337 This is used at the end to make the blockvector. */
341 struct pending_block
*next
;
345 struct pending_block
*pending_blocks
;
347 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
348 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
350 /* Global variable which, when set, indicates that we are processing a
351 .o file compiled with gcc */
353 static unsigned char processing_gcc_compilation
;
355 /* Make a list of forward references which haven't been defined. */
356 static struct type
**undef_types
;
357 static int undef_types_allocated
, undef_types_length
;
359 /* String table for the main symbol file. It is kept in memory
360 permanently, to speed up symbol reading. Other files' symbol tables
361 are read in on demand. FIXME, this should be cleaner. */
363 static char *symfile_string_table
;
364 static int symfile_string_table_size
;
366 /* Setup a define to deal cleanly with the underscore problem */
368 #ifdef NAMES_HAVE_UNDERSCORE
369 #define HASH_OFFSET 1
371 #define HASH_OFFSET 0
374 /* Complaints about the symbols we have encountered. */
376 struct complaint innerblock_complaint
=
377 {"inner block not inside outer block in %s", 0, 0};
379 struct complaint blockvector_complaint
=
380 {"block at %x out of order", 0, 0};
382 struct complaint lbrac_complaint
=
383 {"bad block start address patched", 0, 0};
386 struct complaint dbx_class_complaint
=
387 {"encountered DBX-style class variable debugging information.\n\
388 You seem to have compiled your program with \
389 \"g++ -g0\" instead of \"g++ -g\".\n\
390 Therefore GDB will not know about your class variables", 0, 0};
393 struct complaint string_table_offset_complaint
=
394 {"bad string table offset in symbol %d", 0, 0};
396 struct complaint unknown_symtype_complaint
=
397 {"unknown symbol type 0x%x", 0, 0};
399 struct complaint lbrac_rbrac_complaint
=
400 {"block start larger than block end", 0, 0};
402 struct complaint const_vol_complaint
=
403 {"const/volatile indicator missing, got '%c'", 0, 0};
405 struct complaint error_type_complaint
=
406 {"C++ type mismatch between compiler and debugger", 0, 0};
408 struct complaint invalid_member_complaint
=
409 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
411 /* Support for Sun changes to dbx symbol format */
413 /* For each identified header file, we have a table of types defined
416 header_files maps header file names to their type tables.
417 It is a vector of n_header_files elements.
418 Each element describes one header file.
419 It contains a vector of types.
421 Sometimes it can happen that the same header file produces
422 different results when included in different places.
423 This can result from conditionals or from different
424 things done before including the file.
425 When this happens, there are multiple entries for the file in this table,
426 one entry for each distinct set of results.
427 The entries are distinguished by the INSTANCE field.
428 The INSTANCE field appears in the N_BINCL and N_EXCL symbol table and is
429 used to match header-file references to their corresponding data. */
433 char *name
; /* Name of header file */
434 int instance
; /* Numeric code distinguishing instances
435 of one header file that produced
436 different results when included.
437 It comes from the N_BINCL or N_EXCL. */
438 struct type
**vector
; /* Pointer to vector of types */
439 int length
; /* Allocated length (# elts) of that vector */
442 static struct header_file
*header_files
= 0;
444 static int n_header_files
;
446 static int n_allocated_header_files
;
448 /* During initial symbol readin, we need to have a structure to keep
449 track of which psymtabs have which bincls in them. This structure
450 is used during readin to setup the list of dependencies within each
451 partial symbol table. */
453 struct header_file_location
455 char *name
; /* Name of header file */
456 int instance
; /* See above */
457 struct partial_symtab
*pst
; /* Partial symtab that has the
458 BINCL/EINCL defs for this file */
461 /* The actual list and controling variables */
462 static struct header_file_location
*bincl_list
, *next_bincl
;
463 static int bincls_allocated
;
465 /* Within each object file, various header files are assigned numbers.
466 A type is defined or referred to with a pair of numbers
467 (FILENUM,TYPENUM) where FILENUM is the number of the header file
468 and TYPENUM is the number within that header file.
469 TYPENUM is the index within the vector of types for that header file.
471 FILENUM == 1 is special; it refers to the main source of the object file,
472 and not to any header file. FILENUM != 1 is interpreted by looking it up
473 in the following table, which contains indices in header_files. */
475 static int *this_object_header_files
= 0;
477 static int n_this_object_header_files
;
479 static int n_allocated_this_object_header_files
;
481 /* When a header file is getting special overriding definitions
482 for one source file, record here the header_files index
483 of its normal definition vector.
484 At other times, this is -1. */
486 static int header_file_prev_index
;
488 /* Free up old header file tables, and allocate new ones.
489 We're reading a new symbol file now. */
492 free_and_init_header_files ()
495 for (i
= 0; i
< n_header_files
; i
++)
496 free (header_files
[i
].name
);
497 if (header_files
) /* First time null */
499 if (this_object_header_files
) /* First time null */
500 free (this_object_header_files
);
502 n_allocated_header_files
= 10;
503 header_files
= (struct header_file
*) xmalloc (10 * sizeof (struct header_file
));
506 n_allocated_this_object_header_files
= 10;
507 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
510 /* Called at the start of each object file's symbols.
511 Clear out the mapping of header file numbers to header files. */
514 new_object_header_files ()
516 /* Leave FILENUM of 0 free for builtin types and this file's types. */
517 n_this_object_header_files
= 1;
518 header_file_prev_index
= -1;
521 /* Add header file number I for this object file
522 at the next successive FILENUM. */
525 add_this_object_header_file (i
)
528 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
530 n_allocated_this_object_header_files
*= 2;
531 this_object_header_files
532 = (int *) xrealloc (this_object_header_files
,
533 n_allocated_this_object_header_files
* sizeof (int));
536 this_object_header_files
[n_this_object_header_files
++] = i
;
539 /* Add to this file an "old" header file, one already seen in
540 a previous object file. NAME is the header file's name.
541 INSTANCE is its instance code, to select among multiple
542 symbol tables for the same header file. */
545 add_old_header_file (name
, instance
)
549 register struct header_file
*p
= header_files
;
552 for (i
= 0; i
< n_header_files
; i
++)
553 if (!strcmp (p
[i
].name
, name
) && instance
== p
[i
].instance
)
555 add_this_object_header_file (i
);
558 error ("Invalid symbol data: \"repeated\" header file that hasn't been seen before, at symtab pos %d.",
562 /* Add to this file a "new" header file: definitions for its types follow.
563 NAME is the header file's name.
564 Most often this happens only once for each distinct header file,
565 but not necessarily. If it happens more than once, INSTANCE has
566 a different value each time, and references to the header file
567 use INSTANCE values to select among them.
569 dbx output contains "begin" and "end" markers for each new header file,
570 but at this level we just need to know which files there have been;
571 so we record the file when its "begin" is seen and ignore the "end". */
574 add_new_header_file (name
, instance
)
579 header_file_prev_index
= -1;
581 /* Make sure there is room for one more header file. */
583 if (n_header_files
== n_allocated_header_files
)
585 n_allocated_header_files
*= 2;
586 header_files
= (struct header_file
*)
587 xrealloc (header_files
,
588 (n_allocated_header_files
589 * sizeof (struct header_file
)));
592 /* Create an entry for this header file. */
594 i
= n_header_files
++;
595 header_files
[i
].name
= savestring (name
, strlen(name
));
596 header_files
[i
].instance
= instance
;
597 header_files
[i
].length
= 10;
598 header_files
[i
].vector
599 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
600 bzero (header_files
[i
].vector
, 10 * sizeof (struct type
*));
602 add_this_object_header_file (i
);
605 /* Look up a dbx type-number pair. Return the address of the slot
606 where the type for that number-pair is stored.
607 The number-pair is in TYPENUMS.
609 This can be used for finding the type associated with that pair
610 or for associating a new type with the pair. */
612 static struct type
**
613 dbx_lookup_type (typenums
)
616 register int filenum
= typenums
[0], index
= typenums
[1];
618 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
619 error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
620 filenum
, index
, symnum
);
624 /* Type is defined outside of header files.
625 Find it in this object file's type vector. */
626 if (index
>= type_vector_length
)
628 type_vector_length
*= 2;
629 type_vector
= (struct typevector
*)
630 xrealloc (type_vector
,
631 (sizeof (struct typevector
)
632 + type_vector_length
* sizeof (struct type
*)));
633 bzero (&type_vector
->type
[type_vector_length
/ 2],
634 type_vector_length
* sizeof (struct type
*) / 2);
636 return &type_vector
->type
[index
];
640 register int real_filenum
= this_object_header_files
[filenum
];
641 register struct header_file
*f
;
644 if (real_filenum
>= n_header_files
)
647 f
= &header_files
[real_filenum
];
649 f_orig_length
= f
->length
;
650 if (index
>= f_orig_length
)
652 while (index
>= f
->length
)
654 f
->vector
= (struct type
**)
655 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
656 bzero (&f
->vector
[f_orig_length
],
657 (f
->length
- f_orig_length
) * sizeof (struct type
*));
659 return &f
->vector
[index
];
663 /* Create a type object. Occaisionally used when you need a type
664 which isn't going to be given a type number. */
669 register struct type
*type
=
670 (struct type
*) obstack_alloc (symbol_obstack
, sizeof (struct type
));
672 bzero (type
, sizeof (struct type
));
673 TYPE_VPTR_FIELDNO (type
) = -1;
674 TYPE_VPTR_BASETYPE (type
) = 0;
678 /* Make sure there is a type allocated for type numbers TYPENUMS
679 and return the type object.
680 This can create an empty (zeroed) type object.
681 TYPENUMS may be (-1, -1) to return a new type object that is not
682 put into the type vector, and so may not be referred to by number. */
685 dbx_alloc_type (typenums
)
688 register struct type
**type_addr
;
689 register struct type
*type
;
691 if (typenums
[1] != -1)
693 type_addr
= dbx_lookup_type (typenums
);
702 /* If we are referring to a type not known at all yet,
703 allocate an empty type for it.
704 We will fill it in later if we find out how. */
707 type
= dbx_create_type ();
716 static struct type
**
717 explicit_lookup_type (real_filenum
, index
)
718 int real_filenum
, index
;
720 register struct header_file
*f
= &header_files
[real_filenum
];
722 if (index
>= f
->length
)
725 f
->vector
= (struct type
**)
726 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
727 bzero (&f
->vector
[f
->length
/ 2],
728 f
->length
* sizeof (struct type
*) / 2);
730 return &f
->vector
[index
];
734 /* maintain the lists of symbols and blocks */
736 /* Add a symbol to one of the lists of symbols. */
738 add_symbol_to_list (symbol
, listhead
)
739 struct symbol
*symbol
;
740 struct pending
**listhead
;
742 /* We keep PENDINGSIZE symbols in each link of the list.
743 If we don't have a link with room in it, add a new link. */
744 if (*listhead
== 0 || (*listhead
)->nsyms
== PENDINGSIZE
)
746 register struct pending
*link
;
749 link
= free_pendings
;
750 free_pendings
= link
->next
;
753 link
= (struct pending
*) xmalloc (sizeof (struct pending
));
755 link
->next
= *listhead
;
760 (*listhead
)->symbol
[(*listhead
)->nsyms
++] = symbol
;
763 /* At end of reading syms, or in case of quit,
764 really free as many `struct pending's as we can easily find. */
768 really_free_pendings (foo
)
771 struct pending
*next
, *next1
;
772 struct pending_block
*bnext
, *bnext1
;
774 for (next
= free_pendings
; next
; next
= next1
)
781 #if 0 /* Now we make the links in the symbol_obstack, so don't free them. */
782 for (bnext
= pending_blocks
; bnext
; bnext
= bnext1
)
784 bnext1
= bnext
->next
;
790 for (next
= file_symbols
; next
; next
= next1
)
797 for (next
= global_symbols
; next
; next
= next1
)
805 /* Take one of the lists of symbols and make a block from it.
806 Keep the order the symbols have in the list (reversed from the input file).
807 Put the block on the list of pending blocks. */
810 finish_block (symbol
, listhead
, old_blocks
, start
, end
)
811 struct symbol
*symbol
;
812 struct pending
**listhead
;
813 struct pending_block
*old_blocks
;
814 CORE_ADDR start
, end
;
816 register struct pending
*next
, *next1
;
817 register struct block
*block
;
818 register struct pending_block
*pblock
;
819 struct pending_block
*opblock
;
822 /* Count the length of the list of symbols. */
824 for (next
= *listhead
, i
= 0; next
; i
+= next
->nsyms
, next
= next
->next
)
827 block
= (struct block
*) obstack_alloc (symbol_obstack
,
828 (sizeof (struct block
)
830 * sizeof (struct symbol
*))));
832 /* Copy the symbols into the block. */
834 BLOCK_NSYMS (block
) = i
;
835 for (next
= *listhead
; next
; next
= next
->next
)
838 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
839 BLOCK_SYM (block
, --i
) = next
->symbol
[j
];
842 BLOCK_START (block
) = start
;
843 BLOCK_END (block
) = end
;
844 BLOCK_SUPERBLOCK (block
) = 0; /* Filled in when containing block is made */
845 BLOCK_GCC_COMPILED (block
) = processing_gcc_compilation
;
847 /* Put the block in as the value of the symbol that names it. */
851 SYMBOL_BLOCK_VALUE (symbol
) = block
;
852 BLOCK_FUNCTION (block
) = symbol
;
855 BLOCK_FUNCTION (block
) = 0;
857 /* Now "free" the links of the list, and empty the list. */
859 for (next
= *listhead
; next
; next
= next1
)
862 next
->next
= free_pendings
;
863 free_pendings
= next
;
867 /* Install this block as the superblock
868 of all blocks made since the start of this scope
869 that don't have superblocks yet. */
872 for (pblock
= pending_blocks
; pblock
!= old_blocks
; pblock
= pblock
->next
)
874 if (BLOCK_SUPERBLOCK (pblock
->block
) == 0) {
876 /* Check to be sure the blocks are nested as we receive them.
877 If the compiler/assembler/linker work, this just burns a small
879 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
)
880 || BLOCK_END (pblock
->block
) > BLOCK_END (block
)) {
881 complain(&innerblock_complaint
, symbol
? SYMBOL_NAME (symbol
):
883 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
884 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
887 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
892 /* Record this block on the list of all blocks in the file.
893 Put it after opblock, or at the beginning if opblock is 0.
894 This puts the block in the list after all its subblocks. */
896 /* Allocate in the symbol_obstack to save time.
897 It wastes a little space. */
898 pblock
= (struct pending_block
*)
899 obstack_alloc (symbol_obstack
,
900 sizeof (struct pending_block
));
901 pblock
->block
= block
;
904 pblock
->next
= opblock
->next
;
905 opblock
->next
= pblock
;
909 pblock
->next
= pending_blocks
;
910 pending_blocks
= pblock
;
914 static struct blockvector
*
917 register struct pending_block
*next
;
918 register struct blockvector
*blockvector
;
921 /* Count the length of the list of blocks. */
923 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++);
925 blockvector
= (struct blockvector
*)
926 obstack_alloc (symbol_obstack
,
927 (sizeof (struct blockvector
)
928 + (i
- 1) * sizeof (struct block
*)));
930 /* Copy the blocks into the blockvector.
931 This is done in reverse order, which happens to put
932 the blocks into the proper order (ascending starting address).
933 finish_block has hair to insert each block into the list
934 after its subblocks in order to make sure this is true. */
936 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
937 for (next
= pending_blocks
; next
; next
= next
->next
) {
938 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
941 #if 0 /* Now we make the links in the obstack, so don't free them. */
942 /* Now free the links of the list, and empty the list. */
944 for (next
= pending_blocks
; next
; next
= next1
)
952 #if 1 /* FIXME, shut this off after a while to speed up symbol reading. */
953 /* Some compilers output blocks in the wrong order, but we depend
954 on their being in the right order so we can binary search.
955 Check the order and moan about it. FIXME. */
956 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
957 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++) {
958 if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
-1))
959 > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
))) {
960 complain (&blockvector_complaint
,
961 BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
)));
969 /* Manage the vector of line numbers. */
972 record_line (line
, pc
)
976 struct linetable_entry
*e
;
977 /* Ignore the dummy line number in libg.o */
982 /* Make sure line vector is big enough. */
984 if (line_vector_index
+ 1 >= line_vector_length
)
986 line_vector_length
*= 2;
987 line_vector
= (struct linetable
*)
988 xrealloc (line_vector
,
989 (sizeof (struct linetable
)
990 + line_vector_length
* sizeof (struct linetable_entry
)));
991 current_subfile
->line_vector
= line_vector
;
994 e
= line_vector
->item
+ line_vector_index
++;
995 e
->line
= line
; e
->pc
= pc
;
998 /* Start a new symtab for a new source file.
999 This is called when a dbx symbol of type N_SO is seen;
1000 it indicates the start of data for one original source file. */
1003 start_symtab (name
, dirname
, start_addr
)
1006 CORE_ADDR start_addr
;
1009 last_source_file
= name
;
1010 last_source_start_addr
= start_addr
;
1013 within_function
= 0;
1015 /* Context stack is initially empty, with room for 10 levels. */
1017 = (struct context_stack
*) xmalloc (10 * sizeof (struct context_stack
));
1018 context_stack_size
= 10;
1019 context_stack_depth
= 0;
1021 new_object_header_files ();
1023 type_vector_length
= 160;
1024 type_vector
= (struct typevector
*)
1025 xmalloc (sizeof (struct typevector
)
1026 + type_vector_length
* sizeof (struct type
*));
1027 bzero (type_vector
->type
, type_vector_length
* sizeof (struct type
*));
1029 /* Initialize the list of sub source files with one entry
1030 for this file (the top-level source file). */
1033 current_subfile
= 0;
1034 start_subfile (name
, dirname
);
1037 /* Handle an N_SOL symbol, which indicates the start of
1038 code that came from an included (or otherwise merged-in)
1039 source file with a different name. */
1042 start_subfile (name
, dirname
)
1046 register struct subfile
*subfile
;
1048 /* Save the current subfile's line vector data. */
1050 if (current_subfile
)
1052 current_subfile
->line_vector_index
= line_vector_index
;
1053 current_subfile
->line_vector_length
= line_vector_length
;
1054 current_subfile
->prev_line_number
= prev_line_number
;
1057 /* See if this subfile is already known as a subfile of the
1058 current main source file. */
1060 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
1062 if (!strcmp (subfile
->name
, name
))
1064 line_vector
= subfile
->line_vector
;
1065 line_vector_index
= subfile
->line_vector_index
;
1066 line_vector_length
= subfile
->line_vector_length
;
1067 prev_line_number
= subfile
->prev_line_number
;
1068 current_subfile
= subfile
;
1073 /* This subfile is not known. Add an entry for it. */
1075 line_vector_index
= 0;
1076 line_vector_length
= 1000;
1077 prev_line_number
= -2; /* Force first line number to be explicit */
1078 line_vector
= (struct linetable
*)
1079 xmalloc (sizeof (struct linetable
)
1080 + line_vector_length
* sizeof (struct linetable_entry
));
1082 /* Make an entry for this subfile in the list of all subfiles
1083 of the current main source file. */
1085 subfile
= (struct subfile
*) xmalloc (sizeof (struct subfile
));
1086 subfile
->next
= subfiles
;
1087 subfile
->name
= obsavestring (name
, strlen (name
));
1088 if (dirname
== NULL
)
1089 subfile
->dirname
= NULL
;
1091 subfile
->dirname
= obsavestring (dirname
, strlen (dirname
));
1093 subfile
->line_vector
= line_vector
;
1095 current_subfile
= subfile
;
1098 /* Finish the symbol definitions for one main source file,
1099 close off all the lexical contexts for that file
1100 (creating struct block's for them), then make the struct symtab
1101 for that file and put it in the list of all such.
1103 END_ADDR is the address of the end of the file's text. */
1106 end_symtab (end_addr
)
1109 register struct symtab
*symtab
;
1110 register struct blockvector
*blockvector
;
1111 register struct subfile
*subfile
;
1112 register struct linetable
*lv
;
1113 struct subfile
*nextsub
;
1115 /* Finish the lexical context of the last function in the file;
1116 pop the context stack. */
1118 if (context_stack_depth
> 0)
1120 register struct context_stack
*cstk
;
1121 context_stack_depth
--;
1122 cstk
= &context_stack
[context_stack_depth
];
1123 /* Make a block for the local symbols within. */
1124 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
1125 cstk
->start_addr
, end_addr
);
1128 /* Cleanup any undefined types that have been left hanging around
1129 (this needs to be done before the finish_blocks so that
1130 file_symbols is still good). */
1131 cleanup_undefined_types ();
1133 /* Define the STATIC_BLOCK and GLOBAL_BLOCK, and build the blockvector. */
1134 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
);
1135 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
);
1136 blockvector
= make_blockvector ();
1138 current_subfile
->line_vector_index
= line_vector_index
;
1140 /* Now create the symtab objects proper, one for each subfile. */
1141 /* (The main file is one of them.) */
1143 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
1145 symtab
= (struct symtab
*) xmalloc (sizeof (struct symtab
));
1147 /* Fill in its components. */
1148 symtab
->blockvector
= blockvector
;
1149 lv
= subfile
->line_vector
;
1150 lv
->nitems
= subfile
->line_vector_index
;
1151 symtab
->linetable
= (struct linetable
*)
1152 xrealloc (lv
, (sizeof (struct linetable
)
1153 + lv
->nitems
* sizeof (struct linetable_entry
)));
1154 type_vector
->length
= type_vector_length
;
1155 symtab
->typevector
= type_vector
;
1157 symtab
->filename
= subfile
->name
;
1158 symtab
->dirname
= subfile
->dirname
;
1160 symtab
->free_code
= free_linetable
;
1161 symtab
->free_ptr
= 0;
1162 if (subfile
->next
== 0)
1163 symtab
->free_ptr
= (char *) type_vector
;
1166 symtab
->line_charpos
= 0;
1168 symtab
->language
= language_unknown
;
1169 symtab
->fullname
= NULL
;
1171 /* There should never already be a symtab for this name, since
1172 any prev dups have been removed when the psymtab was read in.
1173 FIXME, there ought to be a way to check this here. */
1174 /* FIXME blewit |= free_named_symtabs (symtab->filename); */
1176 /* Link the new symtab into the list of such. */
1177 symtab
->next
= symtab_list
;
1178 symtab_list
= symtab
;
1180 nextsub
= subfile
->next
;
1185 type_vector_length
= -1;
1187 line_vector_length
= -1;
1188 last_source_file
= 0;
1191 /* Handle the N_BINCL and N_EINCL symbol types
1192 that act like N_SOL for switching source files
1193 (different subfiles, as we call them) within one object file,
1194 but using a stack rather than in an arbitrary order. */
1196 struct subfile_stack
1198 struct subfile_stack
*next
;
1203 struct subfile_stack
*subfile_stack
;
1208 register struct subfile_stack
*tem
1209 = (struct subfile_stack
*) xmalloc (sizeof (struct subfile_stack
));
1211 tem
->next
= subfile_stack
;
1212 subfile_stack
= tem
;
1213 if (current_subfile
== 0 || current_subfile
->name
== 0)
1215 tem
->name
= current_subfile
->name
;
1216 tem
->prev_index
= header_file_prev_index
;
1222 register char *name
;
1223 register struct subfile_stack
*link
= subfile_stack
;
1229 subfile_stack
= link
->next
;
1230 header_file_prev_index
= link
->prev_index
;
1237 record_misc_function (name
, address
, type
)
1242 enum misc_function_type misc_type
=
1243 (type
== (N_TEXT
| N_EXT
) ? mf_text
:
1244 (type
== (N_DATA
| N_EXT
)
1246 || type
== (N_SETV
| N_EXT
)
1248 type
== (N_BSS
| N_EXT
) ? mf_bss
:
1249 type
== (N_ABS
| N_EXT
) ? mf_abs
: mf_unknown
);
1251 prim_record_misc_function (obsavestring (name
, strlen (name
)),
1252 address
, misc_type
);
1255 /* Scan and build partial symbols for a symbol file.
1256 We have been initialized by a call to dbx_symfile_init, which
1257 put all the relevant info into a "struct dbx_symfile_info"
1258 hung off the struct sym_fns SF.
1260 ADDR is the address relative to which the symbols in it are (e.g.
1261 the base address of the text segment).
1262 MAINLINE is true if we are reading the main symbol
1263 table (as opposed to a shared lib or dynamically loaded file). */
1266 dbx_symfile_read (sf
, addr
, mainline
)
1269 int mainline
; /* FIXME comments above */
1271 struct dbx_symfile_info
*info
= (struct dbx_symfile_info
*) (sf
->sym_private
);
1272 bfd
*sym_bfd
= sf
->sym_bfd
;
1274 char *filename
= bfd_get_filename (sym_bfd
);
1276 val
= lseek (info
->desc
, info
->symtab_offset
, L_SET
);
1278 perror_with_name (filename
);
1280 /* If mainline, set global string table pointers, and reinitialize global
1281 partial symbol list. */
1283 symfile_string_table
= info
->stringtab
;
1284 symfile_string_table_size
= info
->stringtab_size
;
1287 /* If we are reinitializing, or if we have never loaded syms yet, init */
1288 if (mainline
|| global_psymbols
.size
== 0 || static_psymbols
.size
== 0)
1289 init_psymbol_list (info
->symcount
);
1291 symfile_bfd
= sym_bfd
; /* Kludge for SWAP_SYMBOL */
1294 make_cleanup (really_free_pendings
, 0);
1296 init_misc_bunches ();
1297 make_cleanup (discard_misc_bunches
, 0);
1299 /* Now that the symbol table data of the executable file are all in core,
1300 process them and define symbols accordingly. */
1302 read_dbx_symtab (filename
,
1303 addr
- bfd_section_vma (sym_bfd
, info
->text_sect
), /*offset*/
1304 info
->desc
, info
->stringtab
, info
->stringtab_size
,
1306 bfd_section_vma (sym_bfd
, info
->text_sect
),
1307 bfd_section_size (sym_bfd
, info
->text_sect
));
1309 /* Go over the misc symbol bunches and install them in vector. */
1311 condense_misc_bunches (!mainline
);
1313 /* Free up any memory we allocated for ourselves. */
1316 free (info
->stringtab
); /* Stringtab is only saved for mainline */
1319 sf
->sym_private
= 0; /* Zap pointer to our (now gone) info struct */
1321 /* Call to select_source_symtab used to be here; it was using too
1322 much time. I'll make sure that list_sources can handle the lack
1323 of current_source_symtab */
1325 if (!partial_symtab_list
)
1326 printf_filtered ("\n(no debugging symbols found)...");
1329 /* Discard any information we have cached during the reading of a
1330 single symbol file. This should not toss global information
1331 from previous symbol files that have been read. E.g. we might
1332 be discarding info from reading a shared library, and should not
1333 throw away the info from the main file. */
1336 dbx_symfile_discard ()
1339 /* Empty the hash table of global syms looking for values. */
1340 bzero (global_sym_chain
, sizeof global_sym_chain
);
1347 /* Initialize anything that needs initializing when a completely new
1348 symbol file is specified (not just adding some symbols from another
1349 file, e.g. a shared library). */
1354 dbx_symfile_discard ();
1355 /* Don't put these on the cleanup chain; they need to stick around
1356 until the next call to symbol_file_command. *Then* we'll free
1358 if (symfile_string_table
)
1360 free (symfile_string_table
);
1361 symfile_string_table
= 0;
1362 symfile_string_table_size
= 0;
1364 free_and_init_header_files ();
1368 /* dbx_symfile_init ()
1369 is the dbx-specific initialization routine for reading symbols.
1370 It is passed a struct sym_fns which contains, among other things,
1371 the BFD for the file whose symbols are being read, and a slot for a pointer
1372 to "private data" which we fill with goodies.
1374 We read the string table into malloc'd space and stash a pointer to it.
1376 Since BFD doesn't know how to read debug symbols in a format-independent
1377 way (and may never do so...), we have to do it ourselves. We will never
1378 be called unless this is an a.out (or very similar) file.
1379 FIXME, there should be a cleaner peephole into the BFD environment here. */
1382 dbx_symfile_init (sf
)
1387 struct stat statbuf
;
1388 bfd
*sym_bfd
= sf
->sym_bfd
;
1389 char *name
= bfd_get_filename (sym_bfd
);
1390 struct dbx_symfile_info
*info
;
1391 unsigned char size_temp
[4];
1393 /* Allocate struct to keep track of the symfile */
1394 sf
->sym_private
= xmalloc (sizeof (*info
)); /* FIXME storage leak */
1395 info
= (struct dbx_symfile_info
*)sf
->sym_private
;
1397 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
1398 desc
= fileno ((FILE *)(sym_bfd
->iostream
)); /* Raw file descriptor */
1399 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
1400 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
1401 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
1404 info
->text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
1405 if (!info
->text_sect
)
1407 info
->symcount
= bfd_get_symcount (sym_bfd
);
1409 /* Read the string table size and check it for bogosity. */
1410 val
= lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
1412 perror_with_name (name
);
1413 if (fstat (desc
, &statbuf
) == -1)
1414 perror_with_name (name
);
1416 val
= myread (desc
, size_temp
, sizeof (long));
1418 perror_with_name (name
);
1419 info
->stringtab_size
= bfd_h_getlong (sym_bfd
, size_temp
);
1421 if (info
->stringtab_size
>= 0 && info
->stringtab_size
< statbuf
.st_size
)
1423 info
->stringtab
= (char *) xmalloc (info
->stringtab_size
);
1424 /* Caller is responsible for freeing the string table. No cleanup. */
1427 info
->stringtab
= NULL
;
1428 if (info
->stringtab
== NULL
&& info
->stringtab_size
!= 0)
1429 error ("ridiculous string table size: %d bytes", info
->stringtab_size
);
1431 /* Now read in the string table in one big gulp. */
1433 val
= lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
1435 perror_with_name (name
);
1436 val
= myread (desc
, info
->stringtab
, info
->stringtab_size
);
1438 perror_with_name (name
);
1440 /* Record the position of the symbol table for later use. */
1442 info
->symtab_offset
= SYMBOL_TABLE_OFFSET
;
1445 /* Buffer for reading the symbol table entries. */
1446 static struct nlist symbuf
[4096];
1447 static int symbuf_idx
;
1448 static int symbuf_end
;
1450 /* I/O descriptor for reading the symbol table. */
1451 static int symtab_input_desc
;
1453 /* The address in memory of the string table of the object file we are
1454 reading (which might not be the "main" object file, but might be a
1455 shared library or some other dynamically loaded thing). This is set
1456 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
1457 when building symtabs, and is used only by next_symbol_text. */
1458 static char *stringtab_global
;
1460 /* Refill the symbol table input buffer
1461 and set the variables that control fetching entries from it.
1462 Reports an error if no data available.
1463 This function can read past the end of the symbol table
1464 (into the string table) but this does no harm. */
1469 int nbytes
= myread (symtab_input_desc
, symbuf
, sizeof (symbuf
));
1471 perror_with_name ("<symbol file>");
1472 else if (nbytes
== 0)
1473 error ("Premature end of file reading symbol table");
1474 symbuf_end
= nbytes
/ sizeof (struct nlist
);
1479 #define SWAP_SYMBOL(symp) \
1481 (symp)->n_un.n_strx = bfd_h_getlong(symfile_bfd, \
1482 (unsigned char *)&(symp)->n_un.n_strx); \
1483 (symp)->n_desc = bfd_h_getshort (symfile_bfd, \
1484 (unsigned char *)&(symp)->n_desc); \
1485 (symp)->n_value = bfd_h_getlong (symfile_bfd, \
1486 (unsigned char *)&(symp)->n_value); \
1489 /* Invariant: The symbol pointed to by symbuf_idx is the first one
1490 that hasn't been swapped. Swap the symbol at the same time
1491 that symbuf_idx is incremented. */
1493 /* dbx allows the text of a symbol name to be continued into the
1494 next symbol name! When such a continuation is encountered
1495 (a \ at the end of the text of a name)
1496 call this function to get the continuation. */
1501 if (symbuf_idx
== symbuf_end
)
1504 SWAP_SYMBOL(&symbuf
[symbuf_idx
]);
1505 return symbuf
[symbuf_idx
++].n_un
.n_strx
+ stringtab_global
;
1508 /* Initializes storage for all of the partial symbols that will be
1509 created by read_dbx_symtab and subsidiaries. */
1512 init_psymbol_list (total_symbols
)
1515 /* Free any previously allocated psymbol lists. */
1516 if (global_psymbols
.list
)
1517 free (global_psymbols
.list
);
1518 if (static_psymbols
.list
)
1519 free (static_psymbols
.list
);
1521 /* Current best guess is that there are approximately a twentieth
1522 of the total symbols (in a debugging file) are global or static
1524 global_psymbols
.size
= total_symbols
/ 10;
1525 static_psymbols
.size
= total_symbols
/ 10;
1526 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
1527 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
1528 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
1529 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
1532 /* Initialize the list of bincls to contain none and have some
1536 init_bincl_list (number
)
1539 bincls_allocated
= number
;
1540 next_bincl
= bincl_list
= (struct header_file_location
*)
1541 xmalloc (bincls_allocated
* sizeof(struct header_file_location
));
1544 /* Add a bincl to the list. */
1547 add_bincl_to_list (pst
, name
, instance
)
1548 struct partial_symtab
*pst
;
1552 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1554 int offset
= next_bincl
- bincl_list
;
1555 bincls_allocated
*= 2;
1556 bincl_list
= (struct header_file_location
*)
1557 xrealloc ((char *)bincl_list
,
1558 bincls_allocated
* sizeof (struct header_file_location
));
1559 next_bincl
= bincl_list
+ offset
;
1561 next_bincl
->pst
= pst
;
1562 next_bincl
->instance
= instance
;
1563 next_bincl
++->name
= name
;
1566 /* Given a name, value pair, find the corresponding
1567 bincl in the list. Return the partial symtab associated
1568 with that header_file_location. */
1570 struct partial_symtab
*
1571 find_corresponding_bincl_psymtab (name
, instance
)
1575 struct header_file_location
*bincl
;
1577 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1578 if (bincl
->instance
== instance
1579 && !strcmp (name
, bincl
->name
))
1582 return (struct partial_symtab
*) 0;
1585 /* Free the storage allocated for the bincl list. */
1591 bincls_allocated
= 0;
1594 static struct partial_symtab
*start_psymtab ();
1595 static void end_psymtab();
1598 /* This is normally a macro defined in read_dbx_symtab, but this
1599 is a lot easier to debug. */
1601 ADD_PSYMBOL_TO_PLIST(NAME
, NAMELENGTH
, NAMESPACE
, CLASS
, PLIST
, VALUE
)
1604 enum namespace NAMESPACE
;
1605 enum address_class CLASS
;
1606 struct psymbol_allocation_list
*PLIST
;
1607 unsigned long VALUE
;
1609 register struct partial_symbol
*psym
;
1614 (LIST
).list
+ (LIST
).size
)
1616 (LIST
).list
= (struct partial_symbol
*)
1617 xrealloc ((LIST
).list
,
1619 * sizeof (struct partial_symbol
)));
1620 /* Next assumes we only went one over. Should be good if
1621 program works correctly */
1623 (LIST
).list
+ (LIST
).size
;
1626 psym
= (LIST
).next
++;
1629 SYMBOL_NAME (psym
) = (char *) obstack_alloc (psymbol_obstack
,
1631 strncpy (SYMBOL_NAME (psym
), (NAME
), (NAMELENGTH
));
1632 SYMBOL_NAME (psym
)[(NAMELENGTH
)] = '\0';
1633 SYMBOL_NAMESPACE (psym
) = (NAMESPACE
);
1634 SYMBOL_CLASS (psym
) = (CLASS
);
1635 SYMBOL_VALUE (psym
) = (VALUE
);
1639 /* Since one arg is a struct, we have to pass in a ptr and deref it (sigh) */
1640 #define ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
1641 ADD_PSYMBOL_TO_PLIST(NAME, NAMELENGTH, NAMESPACE, CLASS, &LIST, VALUE)
1645 /* Given pointers to an a.out symbol table in core containing dbx
1646 style data, setup partial_symtab's describing each source file for
1647 which debugging information is available. NLISTLEN is the number
1648 of symbols in the symbol table. All symbol names are given as
1649 offsets relative to STRINGTAB. STRINGTAB_SIZE is the size of
1650 STRINGTAB. SYMFILE_NAME is the name of the file we are reading from
1651 and ADDR is its relocated address (if incremental) or 0 (if not). */
1654 read_dbx_symtab (symfile_name
, addr
,
1655 desc
, stringtab
, stringtab_size
, nlistlen
,
1656 text_addr
, text_size
)
1660 register char *stringtab
;
1661 register long stringtab_size
;
1662 register int nlistlen
;
1663 CORE_ADDR text_addr
;
1666 register struct nlist
*bufp
;
1667 register char *namestring
;
1668 register struct partial_symbol
*psym
;
1670 int past_first_source_file
= 0;
1671 CORE_ADDR last_o_file_start
= 0;
1672 struct cleanup
*old_chain
;
1675 /* End of the text segment of the executable file. */
1676 CORE_ADDR end_of_text_addr
;
1678 /* Current partial symtab */
1679 struct partial_symtab
*pst
;
1681 /* List of current psymtab's include files */
1682 char **psymtab_include_list
;
1683 int includes_allocated
;
1686 /* Index within current psymtab dependency list */
1687 struct partial_symtab
**dependency_list
;
1688 int dependencies_used
, dependencies_allocated
;
1690 stringtab_global
= stringtab
;
1692 pst
= (struct partial_symtab
*) 0;
1694 includes_allocated
= 30;
1696 psymtab_include_list
= (char **) alloca (includes_allocated
*
1699 dependencies_allocated
= 30;
1700 dependencies_used
= 0;
1702 (struct partial_symtab
**) alloca (dependencies_allocated
*
1703 sizeof (struct partial_symtab
*));
1705 /* FIXME!! If an error occurs, this blows away the whole symbol table!
1706 It should only blow away the psymtabs created herein. We could
1707 be reading a shared library or a dynloaded file! */
1708 old_chain
= make_cleanup (free_all_psymtabs
, 0);
1710 /* Init bincl list */
1711 init_bincl_list (20);
1712 make_cleanup (free_bincl_list
, 0);
1714 last_source_file
= 0;
1716 #ifdef END_OF_TEXT_DEFAULT
1717 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
1719 end_of_text_addr
= text_addr
+ text_size
;
1722 symtab_input_desc
= desc
; /* This is needed for fill_symbuf below */
1723 symbuf_end
= symbuf_idx
= 0;
1725 for (symnum
= 0; symnum
< nlistlen
; symnum
++)
1727 /* Get the symbol for this run and pull out some info */
1728 QUIT
; /* allow this to be interruptable */
1729 if (symbuf_idx
== symbuf_end
)
1731 bufp
= &symbuf
[symbuf_idx
++];
1734 * Special case to speed up readin.
1736 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1740 /* Ok. There is a lot of code duplicated in the rest of this
1741 switch statement (for efficiency reasons). Since I don't
1742 like duplicating code, I will do my penance here, and
1743 describe the code which is duplicated:
1745 *) The assignment to namestring.
1746 *) The call to strchr.
1747 *) The addition of a partial symbol the the two partial
1748 symbol lists. This last is a large section of code, so
1749 I've imbedded it in the following macro.
1752 /* Set namestring based on bufp. If the string table index is invalid,
1753 give a fake name, and print a single error message per symbol file read,
1754 rather than abort the symbol reading or flood the user with messages. */
1755 #define SET_NAMESTRING()\
1756 if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size) { \
1757 complain (&string_table_offset_complaint, symnum); \
1758 namestring = "foo"; \
1760 namestring = bufp->n_un.n_strx + stringtab
1762 /* Add a symbol with an integer value to a psymtab. */
1763 /* This is a macro unless we're debugging. See above this function. */
1765 # define ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
1766 ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, \
1770 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1771 #define ADD_PSYMBOL_ADDR_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
1772 ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, \
1773 SYMBOL_VALUE_ADDRESS)
1775 /* Add any kind of symbol to a psymtab. */
1776 #define ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, VT)\
1778 if ((LIST).next >= \
1779 (LIST).list + (LIST).size) \
1781 (LIST).list = (struct partial_symbol *) \
1782 xrealloc ((LIST).list, \
1784 * sizeof (struct partial_symbol))); \
1785 /* Next assumes we only went one over. Should be good if \
1786 program works correctly */ \
1788 (LIST).list + (LIST).size; \
1791 psym = (LIST).next++; \
1793 SYMBOL_NAME (psym) = (char *) obstack_alloc (psymbol_obstack, \
1794 (NAMELENGTH) + 1); \
1795 strncpy (SYMBOL_NAME (psym), (NAME), (NAMELENGTH)); \
1796 SYMBOL_NAME (psym)[(NAMELENGTH)] = '\0'; \
1797 SYMBOL_NAMESPACE (psym) = (NAMESPACE); \
1798 SYMBOL_CLASS (psym) = (CLASS); \
1799 VT (psym) = (VALUE); \
1802 /* End of macro definitions, now let's handle them symbols! */
1804 switch (bufp
->n_type
)
1807 * Standard, external, non-debugger, symbols
1810 case N_TEXT
| N_EXT
:
1811 case N_NBTEXT
| N_EXT
:
1812 case N_NBDATA
| N_EXT
:
1813 case N_NBBSS
| N_EXT
:
1814 case N_SETV
| N_EXT
:
1816 case N_DATA
| N_EXT
:
1819 bufp
->n_value
+= addr
; /* Relocate */
1824 record_misc_function (namestring
, bufp
->n_value
,
1825 bufp
->n_type
); /* Always */
1829 /* Standard, local, non-debugger, symbols */
1833 /* We need to be able to deal with both N_FN or N_TEXT,
1834 because we have no way of knowing whether the sys-supplied ld
1835 or GNU ld was used to make the executable. */
1836 #if ! (N_FN & N_EXT)
1841 bufp
->n_value
+= addr
; /* Relocate */
1843 if ((namestring
[0] == '-' && namestring
[1] == 'l')
1844 || (namestring
[(nsl
= strlen (namestring
)) - 1] == 'o'
1845 && namestring
[nsl
- 2] == '.'))
1847 if (entry_point
< bufp
->n_value
1848 && entry_point
>= last_o_file_start
1849 && addr
== 0) /* FIXME nogood nomore */
1851 startup_file_start
= last_o_file_start
;
1852 startup_file_end
= bufp
->n_value
;
1854 if (past_first_source_file
&& pst
1855 /* The gould NP1 uses low values for .o and -l symbols
1856 which are not the address. */
1857 && bufp
->n_value
> pst
->textlow
)
1859 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1860 symnum
* sizeof (struct nlist
), bufp
->n_value
,
1861 dependency_list
, dependencies_used
,
1862 global_psymbols
.next
, static_psymbols
.next
);
1863 pst
= (struct partial_symtab
*) 0;
1865 dependencies_used
= 0;
1868 past_first_source_file
= 1;
1869 last_o_file_start
= bufp
->n_value
;
1874 bufp
->n_value
+= addr
; /* Relocate */
1876 /* Check for __DYNAMIC, which is used by Sun shared libraries.
1877 Record it even if it's local, not global, so we can find it.
1878 Same with virtual function tables, both global and static. */
1879 if ((namestring
[8] == 'C' && (strcmp ("__DYNAMIC", namestring
) == 0))
1880 || VTBL_PREFIX_P ((namestring
+HASH_OFFSET
)))
1882 /* Not really a function here, but... */
1883 record_misc_function (namestring
, bufp
->n_value
,
1884 bufp
->n_type
); /* Always */
1888 case N_UNDF
| N_EXT
:
1889 if (bufp
->n_value
!= 0) {
1890 /* This is a "Fortran COMMON" symbol. See if the target
1891 environment knows where it has been relocated to. */
1896 if (target_lookup_symbol (namestring
, &reladdr
)) {
1897 continue; /* Error in lookup; ignore symbol for now. */
1899 bufp
->n_type
^= (N_BSS
^N_UNDF
); /* Define it as a bss-symbol */
1900 bufp
->n_value
= reladdr
;
1901 goto bss_ext_symbol
;
1903 continue; /* Just undefined, not COMMON */
1905 /* Lots of symbol types we can just ignore. */
1914 /* Keep going . . .*/
1917 * Special symbol types for GNU
1920 case N_INDR
| N_EXT
:
1922 case N_SETA
| N_EXT
:
1924 case N_SETT
| N_EXT
:
1926 case N_SETD
| N_EXT
:
1928 case N_SETB
| N_EXT
:
1937 unsigned long valu
= bufp
->n_value
;
1938 /* Symbol number of the first symbol of this file (i.e. the N_SO
1939 if there is just one, or the first if we have a pair). */
1940 int first_symnum
= symnum
;
1942 /* End the current partial symtab and start a new one */
1946 /* Peek at the next symbol. If it is also an N_SO, the
1947 first one just indicates the directory. */
1948 if (symbuf_idx
== symbuf_end
)
1950 bufp
= &symbuf
[symbuf_idx
];
1951 /* n_type is only a char, so swapping swapping is irrelevant. */
1952 if (bufp
->n_type
== (unsigned char)N_SO
)
1956 valu
= bufp
->n_value
;
1960 valu
+= addr
; /* Relocate */
1962 if (pst
&& past_first_source_file
)
1964 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1965 first_symnum
* sizeof (struct nlist
), valu
,
1966 dependency_list
, dependencies_used
,
1967 global_psymbols
.next
, static_psymbols
.next
);
1968 pst
= (struct partial_symtab
*) 0;
1970 dependencies_used
= 0;
1973 past_first_source_file
= 1;
1975 pst
= start_psymtab (symfile_name
, addr
,
1977 first_symnum
* sizeof (struct nlist
),
1978 global_psymbols
.next
, static_psymbols
.next
);
1984 /* Add this bincl to the bincl_list for future EXCLs. No
1985 need to save the string; it'll be around until
1986 read_dbx_symtab function returns */
1990 add_bincl_to_list (pst
, namestring
, bufp
->n_value
);
1992 /* Mark down an include file in the current psymtab */
1994 psymtab_include_list
[includes_used
++] = namestring
;
1995 if (includes_used
>= includes_allocated
)
1997 char **orig
= psymtab_include_list
;
1999 psymtab_include_list
= (char **)
2000 alloca ((includes_allocated
*= 2) *
2002 bcopy (orig
, psymtab_include_list
,
2003 includes_used
* sizeof (char *));
2009 /* Mark down an include file in the current psymtab */
2013 /* In C++, one may expect the same filename to come round many
2014 times, when code is coming alternately from the main file
2015 and from inline functions in other files. So I check to see
2016 if this is a file we've seen before -- either the main
2017 source file, or a previously included file.
2019 This seems to be a lot of time to be spending on N_SOL, but
2020 things like "break expread.y:435" need to work (I
2021 suppose the psymtab_include_list could be hashed or put
2022 in a binary tree, if profiling shows this is a major hog). */
2023 if (!strcmp (namestring
, pst
->filename
))
2027 for (i
= 0; i
< includes_used
; i
++)
2028 if (!strcmp (namestring
, psymtab_include_list
[i
]))
2037 psymtab_include_list
[includes_used
++] = namestring
;
2038 if (includes_used
>= includes_allocated
)
2040 char **orig
= psymtab_include_list
;
2042 psymtab_include_list
= (char **)
2043 alloca ((includes_allocated
*= 2) *
2045 bcopy (orig
, psymtab_include_list
,
2046 includes_used
* sizeof (char *));
2050 case N_LSYM
: /* Typedef or automatic variable. */
2053 p
= (char *) strchr (namestring
, ':');
2055 /* Skip if there is no :. */
2061 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2062 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2063 static_psymbols
, bufp
->n_value
);
2066 /* Also a typedef with the same name. */
2067 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2068 VAR_NAMESPACE
, LOC_TYPEDEF
,
2069 static_psymbols
, bufp
->n_value
);
2074 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2075 VAR_NAMESPACE
, LOC_TYPEDEF
,
2076 static_psymbols
, bufp
->n_value
);
2078 /* If this is an enumerated type, we need to
2079 add all the enum constants to the partial symbol
2080 table. This does not cover enums without names, e.g.
2081 "enum {a, b} c;" in C, but fortunately those are
2082 rare. There is no way for GDB to find those from the
2083 enum type without spending too much time on it. Thus
2084 to solve this problem, the compiler needs to put out separate
2085 constant symbols ('c' N_LSYMS) for enum constants in
2086 enums without names, or put out a dummy type. */
2088 /* We are looking for something of the form
2089 <name> ":" ("t" | "T") [<number> "="] "e"
2090 {<constant> ":" <value> ","} ";". */
2092 /* Skip over the colon and the 't' or 'T'. */
2094 /* This type may be given a number. Skip over it. */
2095 while ((*p
>= '0' && *p
<= '9')
2101 /* We have found an enumerated type. */
2102 /* According to comments in read_enum_type
2103 a comma could end it instead of a semicolon.
2104 I don't know where that happens.
2106 while (*p
&& *p
!= ';' && *p
!= ',')
2110 /* Check for and handle cretinous dbx symbol name
2113 p
= next_symbol_text ();
2115 /* Point to the character after the name
2116 of the enum constant. */
2117 for (q
= p
; *q
&& *q
!= ':'; q
++)
2119 /* Note that the value doesn't matter for
2120 enum constants in psymtabs, just in symtabs. */
2121 ADD_PSYMBOL_TO_LIST (p
, q
- p
,
2122 VAR_NAMESPACE
, LOC_CONST
,
2123 static_psymbols
, 0);
2124 /* Point past the name. */
2126 /* Skip over the value. */
2127 while (*p
&& *p
!= ',')
2129 /* Advance past the comma. */
2137 /* Constant, e.g. from "const" in Pascal. */
2138 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2139 VAR_NAMESPACE
, LOC_CONST
,
2140 static_psymbols
, bufp
->n_value
);
2143 /* Skip if the thing following the : is
2144 not a letter (which indicates declaration of a local
2145 variable, which we aren't interested in). */
2150 case N_GSYM
: /* Global (extern) variable; can be
2151 data or bss (sigh). */
2152 case N_STSYM
: /* Data seg var -- static */
2153 case N_LCSYM
: /* BSS " */
2155 case N_NBSTS
: /* Gould nobase. */
2156 case N_NBLCS
: /* symbols. */
2158 /* Following may probably be ignored; I'll leave them here
2159 for now (until I do Pascal and Modula 2 extensions). */
2161 case N_PC
: /* I may or may not need this; I
2163 case N_M2C
: /* I suspect that I can ignore this here. */
2164 case N_SCOPE
: /* Same. */
2168 p
= (char *) strchr (namestring
, ':');
2170 continue; /* Not a debugging symbol. */
2174 /* Main processing section for debugging symbols which
2175 the initial read through the symbol tables needs to worry
2176 about. If we reach this point, the symbol which we are
2177 considering is definitely one we are interested in.
2178 p must also contain the (valid) index into the namestring
2179 which indicates the debugging type symbol. */
2184 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2185 VAR_NAMESPACE
, LOC_CONST
,
2186 static_psymbols
, bufp
->n_value
);
2189 bufp
->n_value
+= addr
; /* Relocate */
2190 ADD_PSYMBOL_ADDR_TO_LIST (namestring
, p
- namestring
,
2191 VAR_NAMESPACE
, LOC_STATIC
,
2192 static_psymbols
, bufp
->n_value
);
2195 bufp
->n_value
+= addr
; /* Relocate */
2196 ADD_PSYMBOL_ADDR_TO_LIST (namestring
, p
- namestring
,
2197 VAR_NAMESPACE
, LOC_EXTERNAL
,
2198 global_psymbols
, bufp
->n_value
);
2202 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2203 VAR_NAMESPACE
, LOC_TYPEDEF
,
2204 global_psymbols
, bufp
->n_value
);
2208 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2209 VAR_NAMESPACE
, LOC_BLOCK
,
2210 static_psymbols
, bufp
->n_value
);
2213 /* Global functions were ignored here, but now they
2214 are put into the global psymtab like one would expect.
2215 They're also in the misc fn vector...
2216 FIXME, why did it used to ignore these? That broke
2217 "i fun" on these functions. */
2219 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2220 VAR_NAMESPACE
, LOC_BLOCK
,
2221 global_psymbols
, bufp
->n_value
);
2224 /* Two things show up here (hopefully); static symbols of
2225 local scope (static used inside braces) or extensions
2226 of structure symbols. We can ignore both. */
2242 /* Unexpected symbol. Ignore it; perhaps it is an extension
2243 that we don't know about.
2245 Someone says sun cc puts out symbols like
2246 /foo/baz/maclib::/usr/local/bin/maclib,
2247 which would get here with a symbol type of ':'. */
2255 /* Find the corresponding bincl and mark that psymtab on the
2256 psymtab dependency list */
2258 struct partial_symtab
*needed_pst
=
2259 find_corresponding_bincl_psymtab (namestring
, bufp
->n_value
);
2261 /* If this include file was defined earlier in this file,
2263 if (needed_pst
== pst
) continue;
2270 for (i
= 0; i
< dependencies_used
; i
++)
2271 if (dependency_list
[i
] == needed_pst
)
2277 /* If it's already in the list, skip the rest. */
2278 if (found
) continue;
2280 dependency_list
[dependencies_used
++] = needed_pst
;
2281 if (dependencies_used
>= dependencies_allocated
)
2283 struct partial_symtab
**orig
= dependency_list
;
2285 (struct partial_symtab
**)
2286 alloca ((dependencies_allocated
*= 2)
2287 * sizeof (struct partial_symtab
*));
2288 bcopy (orig
, dependency_list
,
2290 * sizeof (struct partial_symtab
*)));
2292 fprintf (stderr
, "Had to reallocate dependency list.\n");
2293 fprintf (stderr
, "New dependencies allocated: %d\n",
2294 dependencies_allocated
);
2299 error ("Invalid symbol data: \"repeated\" header file not previously seen, at symtab pos %d.",
2307 case N_SSYM
: /* Claim: Structure or union element.
2308 Hopefully, I can ignore this. */
2309 case N_ENTRY
: /* Alternate entry point; can ignore. */
2310 case N_MAIN
: /* Can definitely ignore this. */
2311 case N_CATCH
: /* These are GNU C++ extensions */
2312 case N_EHDECL
: /* that can safely be ignored here. */
2323 case N_NSYMS
: /* Ultrix 4.0: symbol count */
2324 /* These symbols aren't interesting; don't worry about them */
2329 /* If we haven't found it yet, ignore it. It's probably some
2330 new type we don't know about yet. */
2331 complain (&unknown_symtype_complaint
, bufp
->n_type
);
2336 /* If there's stuff to be cleaned up, clean it up. */
2337 if (nlistlen
> 0 /* We have some syms */
2338 && entry_point
< bufp
->n_value
2339 && entry_point
>= last_o_file_start
)
2341 startup_file_start
= last_o_file_start
;
2342 startup_file_end
= bufp
->n_value
;
2347 end_psymtab (pst
, psymtab_include_list
, includes_used
,
2348 symnum
* sizeof (struct nlist
), end_of_text_addr
,
2349 dependency_list
, dependencies_used
,
2350 global_psymbols
.next
, static_psymbols
.next
);
2352 dependencies_used
= 0;
2353 pst
= (struct partial_symtab
*) 0;
2357 discard_cleanups (old_chain
);
2361 * Allocate and partially fill a partial symtab. It will be
2362 * completely filled at the end of the symbol list.
2364 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2365 is the address relative to which its symbols are (incremental) or 0
2367 static struct partial_symtab
*
2368 start_psymtab (symfile_name
, addr
,
2369 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
2375 struct partial_symbol
*global_syms
;
2376 struct partial_symbol
*static_syms
;
2378 struct partial_symtab
*result
=
2379 (struct partial_symtab
*) obstack_alloc (psymbol_obstack
,
2380 sizeof (struct partial_symtab
));
2382 result
->addr
= addr
;
2384 result
->symfile_name
=
2385 (char *) obstack_alloc (psymbol_obstack
,
2386 strlen (symfile_name
) + 1);
2387 strcpy (result
->symfile_name
, symfile_name
);
2390 (char *) obstack_alloc (psymbol_obstack
,
2391 strlen (filename
) + 1);
2392 strcpy (result
->filename
, filename
);
2394 result
->textlow
= textlow
;
2395 result
->ldsymoff
= ldsymoff
;
2399 result
->read_symtab
= dbx_psymtab_to_symtab
;
2401 result
->globals_offset
= global_syms
- global_psymbols
.list
;
2402 result
->statics_offset
= static_syms
- static_psymbols
.list
;
2404 result
->n_global_syms
= 0;
2405 result
->n_static_syms
= 0;
2412 compare_psymbols (s1
, s2
)
2413 register struct partial_symbol
*s1
, *s2
;
2416 *st1
= SYMBOL_NAME (s1
),
2417 *st2
= SYMBOL_NAME (s2
);
2419 return (st1
[0] - st2
[0] ? st1
[0] - st2
[0] :
2420 strcmp (st1
+ 1, st2
+ 1));
2424 /* Close off the current usage of a partial_symbol table entry. This
2425 involves setting the correct number of includes (with a realloc),
2426 setting the high text mark, setting the symbol length in the
2427 executable, and setting the length of the global and static lists
2430 The global symbols and static symbols are then seperately sorted.
2432 Then the partial symtab is put on the global list.
2433 *** List variables and peculiarities of same. ***
2436 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
2437 capping_text
, dependency_list
, number_dependencies
,
2438 capping_global
, capping_static
)
2439 struct partial_symtab
*pst
;
2440 char **include_list
;
2442 int capping_symbol_offset
;
2443 CORE_ADDR capping_text
;
2444 struct partial_symtab
**dependency_list
;
2445 int number_dependencies
;
2446 struct partial_symbol
*capping_global
, *capping_static
;
2450 pst
->ldsymlen
= capping_symbol_offset
- pst
->ldsymoff
;
2451 pst
->texthigh
= capping_text
;
2453 pst
->n_global_syms
=
2454 capping_global
- (global_psymbols
.list
+ pst
->globals_offset
);
2455 pst
->n_static_syms
=
2456 capping_static
- (static_psymbols
.list
+ pst
->statics_offset
);
2458 pst
->number_of_dependencies
= number_dependencies
;
2459 if (number_dependencies
)
2461 pst
->dependencies
= (struct partial_symtab
**)
2462 obstack_alloc (psymbol_obstack
,
2463 number_dependencies
* sizeof (struct partial_symtab
*));
2464 bcopy (dependency_list
, pst
->dependencies
,
2465 number_dependencies
* sizeof (struct partial_symtab
*));
2468 pst
->dependencies
= 0;
2470 for (i
= 0; i
< num_includes
; i
++)
2472 /* Eventually, put this on obstack */
2473 struct partial_symtab
*subpst
=
2474 (struct partial_symtab
*)
2475 obstack_alloc (psymbol_obstack
,
2476 sizeof (struct partial_symtab
));
2479 (char *) obstack_alloc (psymbol_obstack
,
2480 strlen (include_list
[i
]) + 1);
2481 strcpy (subpst
->filename
, include_list
[i
]);
2483 subpst
->symfile_name
= pst
->symfile_name
;
2484 subpst
->addr
= pst
->addr
;
2488 subpst
->texthigh
= 0;
2490 /* We could save slight bits of space by only making one of these,
2491 shared by the entire set of include files. FIXME-someday. */
2492 subpst
->dependencies
= (struct partial_symtab
**)
2493 obstack_alloc (psymbol_obstack
,
2494 sizeof (struct partial_symtab
*));
2495 subpst
->dependencies
[0] = pst
;
2496 subpst
->number_of_dependencies
= 1;
2498 subpst
->globals_offset
=
2499 subpst
->n_global_syms
=
2500 subpst
->statics_offset
=
2501 subpst
->n_static_syms
= 0;
2505 subpst
->read_symtab
= dbx_psymtab_to_symtab
;
2507 subpst
->next
= partial_symtab_list
;
2508 partial_symtab_list
= subpst
;
2511 /* Sort the global list; don't sort the static list */
2512 qsort (global_psymbols
.list
+ pst
->globals_offset
, pst
->n_global_syms
,
2513 sizeof (struct partial_symbol
), compare_psymbols
);
2515 /* If there is already a psymtab or symtab for a file of this name, remove it.
2516 (If there is a symtab, more drastic things also happen.)
2517 This happens in VxWorks. */
2518 free_named_symtabs (pst
->filename
);
2520 /* Put the psymtab on the psymtab list */
2521 pst
->next
= partial_symtab_list
;
2522 partial_symtab_list
= pst
;
2526 psymtab_to_symtab_1 (pst
, desc
, stringtab
, stringtab_size
, sym_offset
)
2527 struct partial_symtab
*pst
;
2533 struct cleanup
*old_chain
;
2541 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2546 /* Read in all partial symbtabs on which this one is dependent */
2547 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2548 if (!pst
->dependencies
[i
]->readin
)
2550 /* Inform about additional files that need to be read in. */
2553 fputs_filtered (" ", stdout
);
2555 fputs_filtered ("and ", stdout
);
2557 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2558 wrap_here (""); /* Flush output */
2561 psymtab_to_symtab_1 (pst
->dependencies
[i
], desc
,
2562 stringtab
, stringtab_size
, sym_offset
);
2565 if (pst
->ldsymlen
) /* Otherwise it's a dummy */
2567 /* Init stuff necessary for reading in symbols */
2572 old_chain
= make_cleanup (really_free_pendings
, 0);
2574 /* Read in this files symbols */
2575 lseek (desc
, sym_offset
, L_SET
);
2576 read_ofile_symtab (desc
, stringtab
, stringtab_size
,
2578 pst
->ldsymlen
, pst
->textlow
,
2579 pst
->texthigh
- pst
->textlow
, pst
->addr
);
2580 sort_symtab_syms (symtab_list
); /* At beginning since just added */
2582 do_cleanups (old_chain
);
2589 * Read in all of the symbols for a given psymtab for real.
2590 * Be verbose about it if the user wants that.
2593 dbx_psymtab_to_symtab (pst
)
2594 struct partial_symtab
*pst
;
2599 struct stat statbuf
;
2600 struct cleanup
*old_chain
;
2609 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2614 if (pst
->ldsymlen
|| pst
->number_of_dependencies
)
2616 /* Print the message now, before reading the string table,
2617 to avoid disconcerting pauses. */
2620 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
2624 /* Open symbol file and read in string table. Symbol_file_command
2625 guarantees that the symbol file name will be absolute, so there is
2626 no need for openp. */
2627 desc
= open(pst
->symfile_name
, O_RDONLY
, 0);
2630 perror_with_name (pst
->symfile_name
);
2632 sym_bfd
= bfd_fdopenr (pst
->symfile_name
, NULL
, desc
);
2636 error ("Could not open `%s' to read symbols: %s",
2637 pst
->symfile_name
, bfd_errmsg (bfd_error
));
2639 old_chain
= make_cleanup (bfd_close
, sym_bfd
);
2640 if (!bfd_check_format (sym_bfd
, bfd_object
))
2641 error ("\"%s\": can't read symbols: %s.",
2642 pst
->symfile_name
, bfd_errmsg (bfd_error
));
2644 /* We keep the string table for symfile resident in memory, but
2645 not the string table for any other symbol files. */
2646 if ((symfile
== 0) || 0 != strcmp(pst
->symfile_name
, symfile
))
2648 /* Read in the string table */
2650 /* FIXME, this uses internal BFD variables. See above in
2651 dbx_symbol_file_open where the macro is defined! */
2652 lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
2654 val
= myread (desc
, &st_temp
, sizeof st_temp
);
2656 perror_with_name (pst
->symfile_name
);
2657 stsize
= bfd_h_getlong (sym_bfd
, (unsigned char *)&st_temp
);
2658 if (fstat (desc
, &statbuf
) < 0)
2659 perror_with_name (pst
->symfile_name
);
2661 if (stsize
>= 0 && stsize
< statbuf
.st_size
)
2663 #ifdef BROKEN_LARGE_ALLOCA
2664 stringtab
= (char *) xmalloc (stsize
);
2665 make_cleanup (free
, stringtab
);
2667 stringtab
= (char *) alloca (stsize
);
2672 if (stringtab
== NULL
&& stsize
!= 0)
2673 error ("ridiculous string table size: %d bytes", stsize
);
2675 /* FIXME, this uses internal BFD variables. See above in
2676 dbx_symbol_file_open where the macro is defined! */
2677 val
= lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
2679 perror_with_name (pst
->symfile_name
);
2680 val
= myread (desc
, stringtab
, stsize
);
2682 perror_with_name (pst
->symfile_name
);
2686 stringtab
= symfile_string_table
;
2687 stsize
= symfile_string_table_size
;
2690 symfile_bfd
= sym_bfd
; /* Kludge for SWAP_SYMBOL */
2692 /* FIXME, this uses internal BFD variables. See above in
2693 dbx_symbol_file_open where the macro is defined! */
2694 psymtab_to_symtab_1 (pst
, desc
, stringtab
, stsize
,
2695 SYMBOL_TABLE_OFFSET
);
2697 /* Match with global symbols. This only needs to be done once,
2698 after all of the symtabs and dependencies have been read in. */
2699 scan_file_globals ();
2701 do_cleanups (old_chain
);
2703 /* Finish up the debug error message. */
2705 printf_filtered ("done.\n");
2710 * Scan through all of the global symbols defined in the object file,
2711 * assigning values to the debugging symbols that need to be assigned
2712 * to. Get these symbols from the misc function list.
2715 scan_file_globals ()
2720 for (mf
= 0; mf
< misc_function_count
; mf
++)
2722 char *namestring
= misc_function_vector
[mf
].name
;
2723 struct symbol
*sym
, *prev
;
2727 prev
= (struct symbol
*) 0;
2729 /* Get the hash index and check all the symbols
2730 under that hash index. */
2732 hash
= hashname (namestring
);
2734 for (sym
= global_sym_chain
[hash
]; sym
;)
2736 if (*namestring
== SYMBOL_NAME (sym
)[0]
2737 && !strcmp(namestring
+ 1, SYMBOL_NAME (sym
) + 1))
2739 /* Splice this symbol out of the hash chain and
2740 assign the value we have to it. */
2742 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
2744 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
2746 /* Check to see whether we need to fix up a common block. */
2747 /* Note: this code might be executed several times for
2748 the same symbol if there are multiple references. */
2749 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2750 fix_common_block (sym
, misc_function_vector
[mf
].address
);
2752 SYMBOL_VALUE_ADDRESS (sym
) = misc_function_vector
[mf
].address
;
2755 sym
= SYMBOL_VALUE_CHAIN (prev
);
2757 sym
= global_sym_chain
[hash
];
2762 sym
= SYMBOL_VALUE_CHAIN (sym
);
2768 /* Process a pair of symbols. Currently they must both be N_SO's. */
2770 process_symbol_pair (type1
, desc1
, value1
, name1
,
2771 type2
, desc2
, value2
, name2
)
2781 /* No need to check PCC_SOL_BROKEN, on the assumption that such
2782 broken PCC's don't put out N_SO pairs. */
2783 if (last_source_file
)
2784 end_symtab (value2
);
2785 start_symtab (name2
, name1
, value2
);
2789 * Read in a defined section of a specific object file's symbols.
2791 * DESC is the file descriptor for the file, positioned at the
2792 * beginning of the symtab
2793 * STRINGTAB is a pointer to the files string
2794 * table, already read in
2795 * SYM_OFFSET is the offset within the file of
2796 * the beginning of the symbols we want to read, NUM_SUMBOLS is the
2797 * number of symbols to read
2798 * TEXT_OFFSET is the beginning of the text segment we are reading symbols for
2799 * TEXT_SIZE is the size of the text segment read in.
2800 * OFFSET is a relocation offset which gets added to each symbol
2804 read_ofile_symtab (desc
, stringtab
, stringtab_size
, sym_offset
,
2805 sym_size
, text_offset
, text_size
, offset
)
2807 register char *stringtab
;
2808 unsigned int stringtab_size
;
2811 CORE_ADDR text_offset
;
2815 register char *namestring
;
2820 stringtab_global
= stringtab
;
2821 last_source_file
= 0;
2823 symtab_input_desc
= desc
;
2824 symbuf_end
= symbuf_idx
= 0;
2826 /* It is necessary to actually read one symbol *before* the start
2827 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
2828 occurs before the N_SO symbol.
2830 Detecting this in read_dbx_symtab
2831 would slow down initial readin, so we look for it here instead. */
2832 if (sym_offset
>= (int)sizeof (struct nlist
))
2834 lseek (desc
, sym_offset
- sizeof (struct nlist
), L_INCR
);
2836 bufp
= &symbuf
[symbuf_idx
++];
2839 if (bufp
->n_un
.n_strx
< 0 || bufp
->n_un
.n_strx
>= stringtab_size
)
2840 error ("Invalid symbol data: bad string table offset: %d",
2842 namestring
= bufp
->n_un
.n_strx
+ stringtab
;
2844 processing_gcc_compilation
=
2845 (bufp
->n_type
== N_TEXT
2846 && !strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
));
2850 /* The N_SO starting this symtab is the first symbol, so we
2851 better not check the symbol before it. I'm not this can
2852 happen, but it doesn't hurt to check for it. */
2853 lseek(desc
, sym_offset
, L_INCR
);
2854 processing_gcc_compilation
= 0;
2857 if (symbuf_idx
== symbuf_end
)
2859 bufp
= &symbuf
[symbuf_idx
];
2860 if (bufp
->n_type
!= (unsigned char)N_SO
)
2861 error("First symbol in segment of executable not a source symbol");
2864 symnum
< sym_size
/ sizeof(struct nlist
);
2867 QUIT
; /* Allow this to be interruptable */
2868 if (symbuf_idx
== symbuf_end
)
2870 bufp
= &symbuf
[symbuf_idx
++];
2873 type
= bufp
->n_type
& N_TYPE
;
2874 if (type
== (unsigned char)N_CATCH
)
2876 /* N_CATCH is not fixed up by the linker, and unfortunately,
2877 there's no other place to put it in the .stab map. */
2878 bufp
->n_value
+= text_offset
+ offset
;
2880 else if (type
== N_TEXT
|| type
== N_DATA
|| type
== N_BSS
)
2881 bufp
->n_value
+= offset
;
2883 type
= bufp
->n_type
;
2884 if (bufp
->n_un
.n_strx
< 0 || bufp
->n_un
.n_strx
>= stringtab_size
)
2885 error ("Invalid symbol data: bad string table offset: %d",
2887 namestring
= bufp
->n_un
.n_strx
+ stringtab
;
2891 short desc
= bufp
->n_desc
;
2892 unsigned long valu
= bufp
->n_value
;
2894 /* Check for a pair of N_SO symbols. */
2895 if (type
== (unsigned char)N_SO
)
2897 if (symbuf_idx
== symbuf_end
)
2899 bufp
= &symbuf
[symbuf_idx
];
2900 if (bufp
->n_type
== (unsigned char)N_SO
)
2905 bufp
->n_value
+= offset
; /* Relocate */
2909 if (bufp
->n_un
.n_strx
< 0
2910 || bufp
->n_un
.n_strx
>= stringtab_size
)
2911 error ("Invalid symbol data: bad string table offset: %d",
2913 namestring2
= bufp
->n_un
.n_strx
+ stringtab
;
2915 process_symbol_pair (N_SO
, desc
, valu
, namestring
,
2916 N_SO
, bufp
->n_desc
, bufp
->n_value
,
2920 process_one_symbol(type
, desc
, valu
, namestring
);
2923 process_one_symbol (type
, desc
, valu
, namestring
);
2925 /* We skip checking for a new .o or -l file; that should never
2926 happen in this routine. */
2927 else if (type
== N_TEXT
2928 && !strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
2929 /* I don't think this code will ever be executed, because
2930 the GCC_COMPILED_FLAG_SYMBOL usually is right before
2931 the N_SO symbol which starts this source file.
2932 However, there is no reason not to accept
2933 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
2934 processing_gcc_compilation
= 1;
2935 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
2936 || type
== (unsigned char)N_NBTEXT
2938 /* Global symbol: see if we came across a dbx defintion for
2939 a corresponding symbol. If so, store the value. Remove
2940 syms from the chain when their values are stored, but
2941 search the whole chain, as there may be several syms from
2942 different files with the same name. */
2943 /* This is probably not true. Since the files will be read
2944 in one at a time, each reference to a global symbol will
2945 be satisfied in each file as it appears. So we skip this
2949 end_symtab (text_offset
+ text_size
);
2956 register char *p
= name
;
2957 register int total
= p
[0];
2970 /* Ensure result is positive. */
2971 if (total
< 0) total
+= (1000 << 6);
2972 return total
% HASHSIZE
;
2977 process_one_symbol (type
, desc
, valu
, name
)
2982 #ifndef SUN_FIXED_LBRAC_BUG
2983 /* This records the last pc address we've seen. We depend on their being
2984 an SLINE or FUN or SO before the first LBRAC, since the variable does
2985 not get reset in between reads of different symbol files. */
2986 static CORE_ADDR last_pc_address
;
2988 register struct context_stack
*new;
2991 /* Something is wrong if we see real data before
2992 seeing a source file name. */
2994 if (last_source_file
== 0 && type
!= (unsigned char)N_SO
)
2996 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
2997 where that code is defined. */
2998 if (IGNORE_SYMBOL (type
))
3001 /* FIXME, this should not be an error, since it precludes extending
3002 the symbol table information in this way... */
3003 error ("Invalid symbol data: does not start by identifying a source file.");
3010 /* Either of these types of symbols indicates the start of
3011 a new function. We must process its "name" normally for dbx,
3012 but also record the start of a new lexical context, and possibly
3013 also the end of the lexical context for the previous function. */
3014 /* This is not always true. This type of symbol may indicate a
3015 text segment variable. */
3017 #ifndef SUN_FIXED_LBRAC_BUG
3018 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
3021 colon_pos
= strchr (name
, ':');
3023 || (*colon_pos
!= 'f' && *colon_pos
!= 'F'))
3025 define_symbol (valu
, name
, desc
, type
);
3029 within_function
= 1;
3030 if (context_stack_depth
> 0)
3032 new = &context_stack
[--context_stack_depth
];
3033 /* Make a block for the local symbols within. */
3034 finish_block (new->name
, &local_symbols
, new->old_blocks
,
3035 new->start_addr
, valu
);
3037 /* Stack must be empty now. */
3038 if (context_stack_depth
!= 0)
3039 error ("Invalid symbol data: unmatched N_LBRAC before symtab pos %d.",
3042 new = &context_stack
[context_stack_depth
++];
3043 new->old_blocks
= pending_blocks
;
3044 new->start_addr
= valu
;
3045 new->name
= define_symbol (valu
, name
, desc
, type
);
3050 /* Record the address at which this catch takes place. */
3051 define_symbol (valu
, name
, desc
, type
);
3055 /* Don't know what to do with these yet. */
3056 error ("action uncertain for eh extensions");
3060 /* This "symbol" just indicates the start of an inner lexical
3061 context within a function. */
3063 #if !defined (BLOCK_ADDRESS_ABSOLUTE)
3064 /* On most machines, the block addresses are relative to the
3065 N_SO, the linker did not relocate them (sigh). */
3066 valu
+= last_source_start_addr
;
3069 #ifndef SUN_FIXED_LBRAC_BUG
3070 if (valu
< last_pc_address
) {
3071 /* Patch current LBRAC pc value to match last handy pc value */
3072 complain (&lbrac_complaint
, 0);
3073 valu
= last_pc_address
;
3076 if (context_stack_depth
== context_stack_size
)
3078 context_stack_size
*= 2;
3079 context_stack
= (struct context_stack
*)
3080 xrealloc (context_stack
,
3082 * sizeof (struct context_stack
)));
3085 new = &context_stack
[context_stack_depth
++];
3087 new->locals
= local_symbols
;
3088 new->old_blocks
= pending_blocks
;
3089 new->start_addr
= valu
;
3095 /* This "symbol" just indicates the end of an inner lexical
3096 context that was started with N_LBRAC. */
3098 #if !defined (BLOCK_ADDRESS_ABSOLUTE)
3099 /* On most machines, the block addresses are relative to the
3100 N_SO, the linker did not relocate them (sigh). */
3101 valu
+= last_source_start_addr
;
3104 new = &context_stack
[--context_stack_depth
];
3105 if (desc
!= new->depth
)
3106 error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum
);
3108 /* Some compilers put the variable decls inside of an
3109 LBRAC/RBRAC block. This macro should be nonzero if this
3110 is true. DESC is N_DESC from the N_RBRAC symbol.
3111 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL. */
3112 #if !defined (VARIABLES_INSIDE_BLOCK)
3113 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
3116 /* Can only use new->locals as local symbols here if we're in
3117 gcc or on a machine that puts them before the lbrack. */
3118 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
3119 local_symbols
= new->locals
;
3121 /* If this is not the outermost LBRAC...RBRAC pair in the
3122 function, its local symbols preceded it, and are the ones
3123 just recovered from the context stack. Defined the block for them.
3125 If this is the outermost LBRAC...RBRAC pair, there is no
3126 need to do anything; leave the symbols that preceded it
3127 to be attached to the function's own block. However, if
3128 it is so, we need to indicate that we just moved outside
3131 && (context_stack_depth
3132 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
3134 /* FIXME Muzzle a compiler bug that makes end < start. */
3135 if (new->start_addr
> valu
)
3137 complain(&lbrac_rbrac_complaint
, 0);
3138 new->start_addr
= valu
;
3140 /* Make a block for the local symbols within. */
3141 finish_block (0, &local_symbols
, new->old_blocks
,
3142 new->start_addr
, valu
);
3146 within_function
= 0;
3148 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
3149 /* Now pop locals of block just finished. */
3150 local_symbols
= new->locals
;
3154 /* This kind of symbol supposedly indicates the start
3155 of an object file. In fact this type does not appear. */
3159 /* This type of symbol indicates the start of data
3160 for one source file.
3161 Finish the symbol table of the previous source file
3162 (if any) and start accumulating a new symbol table. */
3163 #ifndef SUN_FIXED_LBRAC_BUG
3164 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
3167 #ifdef PCC_SOL_BROKEN
3168 /* pcc bug, occasionally puts out SO for SOL. */
3169 if (context_stack_depth
> 0)
3171 start_subfile (name
, NULL
);
3175 if (last_source_file
)
3177 start_symtab (name
, NULL
, valu
);
3181 /* This type of symbol indicates the start of data for
3182 a sub-source-file, one whose contents were copied or
3183 included in the compilation of the main source file
3184 (whose name was given in the N_SO symbol.) */
3185 start_subfile (name
, NULL
);
3190 add_new_header_file (name
, valu
);
3191 start_subfile (name
, NULL
);
3195 start_subfile (pop_subfile (), NULL
);
3199 add_old_header_file (name
, valu
);
3203 /* This type of "symbol" really just records
3204 one line-number -- core-address correspondence.
3205 Enter it in the line list for this symbol table. */
3206 #ifndef SUN_FIXED_LBRAC_BUG
3207 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
3209 record_line (desc
, valu
);
3214 error ("Invalid symbol data: common within common at symtab pos %d",
3216 common_block
= local_symbols
;
3217 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
3221 /* Symbols declared since the BCOMM are to have the common block
3222 start address added in when we know it. common_block points to
3223 the first symbol after the BCOMM in the local_symbols list;
3224 copy the list and hang it off the symbol for the common block name
3228 struct symbol
*sym
=
3229 (struct symbol
*) xmalloc (sizeof (struct symbol
));
3230 bzero (sym
, sizeof *sym
);
3231 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
3232 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3233 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
3234 copy_pending (local_symbols
, common_block_i
, common_block
));
3235 i
= hashname (SYMBOL_NAME (sym
));
3236 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
3237 global_sym_chain
[i
] = sym
;
3248 define_symbol (valu
, name
, desc
, type
);
3252 /* Read a number by which a type is referred to in dbx data,
3253 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
3254 Just a single number N is equivalent to (0,N).
3255 Return the two numbers by storing them in the vector TYPENUMS.
3256 TYPENUMS will then be used as an argument to dbx_lookup_type. */
3259 read_type_number (pp
, typenums
)
3261 register int *typenums
;
3266 typenums
[0] = read_number (pp
, ',');
3267 typenums
[1] = read_number (pp
, ')');
3272 typenums
[1] = read_number (pp
, 0);
3276 /* To handle GNU C++ typename abbreviation, we need to be able to
3277 fill in a type's name as soon as space for that type is allocated.
3278 `type_synonym_name' is the name of the type being allocated.
3279 It is cleared as soon as it is used (lest all allocated types
3281 static char *type_synonym_name
;
3283 static struct symbol
*
3284 define_symbol (valu
, string
, desc
, type
)
3290 register struct symbol
*sym
;
3291 char *p
= (char *) strchr (string
, ':');
3296 /* Ignore syms with empty names. */
3300 /* Ignore old-style symbols from cc -go */
3304 sym
= (struct symbol
*)obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
3306 if (processing_gcc_compilation
) {
3307 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
3308 number of bytes occupied by a type or object, which we ignore. */
3309 SYMBOL_LINE(sym
) = desc
;
3311 SYMBOL_LINE(sym
) = 0; /* unknown */
3314 if (string
[0] == CPLUS_MARKER
)
3316 /* Special GNU C++ names. */
3320 SYMBOL_NAME (sym
) = "this";
3322 case 'v': /* $vtbl_ptr_type */
3323 /* Was: SYMBOL_NAME (sym) = "vptr"; */
3326 SYMBOL_NAME (sym
) = "eh_throw";
3330 /* This was an anonymous type that was never fixed up. */
3341 = (char *) obstack_alloc (symbol_obstack
, ((p
- string
) + 1));
3342 /* Open-coded bcopy--saves function call time. */
3344 register char *p1
= string
;
3345 register char *p2
= SYMBOL_NAME (sym
);
3352 /* Determine the type of name being defined. */
3353 /* The Acorn RISC machine's compiler can put out locals that don't
3354 start with "234=" or "(3,4)=", so assume anything other than the
3355 deftypes we know how to handle is a local. */
3356 /* (Peter Watkins @ Computervision)
3357 Handle Sun-style local fortran array types 'ar...' .
3358 (gnu@cygnus.com) -- this strchr() handles them properly?
3359 (tiemann@cygnus.com) -- 'C' is for catch. */
3360 if (!strchr ("cfFGpPrStTvVXC", *p
))
3365 /* c is a special case, not followed by a type-number.
3366 SYMBOL:c=iVALUE for an integer constant symbol.
3367 SYMBOL:c=rVALUE for a floating constant symbol.
3368 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
3369 e.g. "b:c=e6,0" for "const b = blob1"
3370 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
3374 error ("Invalid symbol data at symtab pos %d.", symnum
);
3379 double d
= atof (p
);
3382 SYMBOL_TYPE (sym
) = builtin_type_double
;
3383 valu
= (char *) obstack_alloc (symbol_obstack
, sizeof (double));
3384 bcopy (&d
, valu
, sizeof (double));
3385 SWAP_TARGET_AND_HOST (valu
, sizeof (double));
3386 SYMBOL_VALUE_BYTES (sym
) = valu
;
3387 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
3392 SYMBOL_TYPE (sym
) = builtin_type_int
;
3393 SYMBOL_VALUE (sym
) = atoi (p
);
3394 SYMBOL_CLASS (sym
) = LOC_CONST
;
3398 /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
3399 e.g. "b:c=e6,0" for "const b = blob1"
3400 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
3404 read_type_number (&p
, typenums
);
3406 error ("Invalid symbol data: no comma in enum const symbol");
3408 SYMBOL_TYPE (sym
) = *dbx_lookup_type (typenums
);
3409 SYMBOL_VALUE (sym
) = atoi (p
);
3410 SYMBOL_CLASS (sym
) = LOC_CONST
;
3414 error ("Invalid symbol data at symtab pos %d.", symnum
);
3416 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3417 add_symbol_to_list (sym
, &file_symbols
);
3421 /* Now usually comes a number that says which data type,
3422 and possibly more stuff to define the type
3423 (all of which is handled by read_type) */
3425 if (deftype
== 'p' && *p
== 'F')
3426 /* pF is a two-letter code that means a function parameter in Fortran.
3427 The type-number specifies the type of the return value.
3428 Translate it into a pointer-to-function type. */
3432 = lookup_pointer_type (lookup_function_type (read_type (&p
)));
3437 synonym
= *p
== 't';
3442 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
3443 strlen (SYMBOL_NAME (sym
)));
3446 type
= read_type (&p
);
3448 if ((deftype
== 'F' || deftype
== 'f')
3449 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
3450 SYMBOL_TYPE (sym
) = lookup_function_type (type
);
3452 SYMBOL_TYPE (sym
) = type
;
3458 /* The name of a caught exception. */
3459 SYMBOL_CLASS (sym
) = LOC_LABEL
;
3460 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3461 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
3462 add_symbol_to_list (sym
, &local_symbols
);
3466 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3467 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3468 add_symbol_to_list (sym
, &file_symbols
);
3472 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3473 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3474 add_symbol_to_list (sym
, &global_symbols
);
3478 /* For a class G (global) symbol, it appears that the
3479 value is not correct. It is necessary to search for the
3480 corresponding linker definition to find the value.
3481 These definitions appear at the end of the namelist. */
3482 i
= hashname (SYMBOL_NAME (sym
));
3483 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
3484 global_sym_chain
[i
] = sym
;
3485 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3486 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3487 add_symbol_to_list (sym
, &global_symbols
);
3490 /* This case is faked by a conditional above,
3491 when there is no code letter in the dbx data.
3492 Dbx data never actually contains 'l'. */
3494 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3495 SYMBOL_VALUE (sym
) = valu
;
3496 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3497 add_symbol_to_list (sym
, &local_symbols
);
3501 /* Normally this is a parameter, a LOC_ARG. On the i960, it
3502 can also be a LOC_LOCAL_ARG depending on symbol type. */
3503 #ifndef DBX_PARM_SYMBOL_CLASS
3504 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
3506 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
3507 SYMBOL_VALUE (sym
) = valu
;
3508 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3509 add_symbol_to_list (sym
, &local_symbols
);
3511 /* If it's gcc-compiled, if it says `short', believe it. */
3512 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
3515 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
3516 /* This macro is defined on machines (e.g. sparc) where
3517 we should believe the type of a PCC 'short' argument,
3518 but shouldn't believe the address (the address is
3519 the address of the corresponding int). Note that
3520 this is only different from the BELIEVE_PCC_PROMOTION
3521 case on big-endian machines.
3523 My guess is that this correction, as opposed to changing
3524 the parameter to an 'int' (as done below, for PCC
3525 on most machines), is the right thing to do
3526 on all machines, but I don't want to risk breaking
3527 something that already works. On most PCC machines,
3528 the sparc problem doesn't come up because the calling
3529 function has to zero the top bytes (not knowing whether
3530 the called function wants an int or a short), so there
3531 is no practical difference between an int and a short
3532 (except perhaps what happens when the GDB user types
3533 "print short_arg = 0x10000;").
3535 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
3536 actually produces the correct address (we don't need to fix it
3537 up). I made this code adapt so that it will offset the symbol
3538 if it was pointing at an int-aligned location and not
3539 otherwise. This way you can use the same gdb for 4.0.x and
3542 if (0 == SYMBOL_VALUE (sym
) % sizeof (int))
3544 if (SYMBOL_TYPE (sym
) == builtin_type_char
3545 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
)
3546 SYMBOL_VALUE (sym
) += 3;
3547 else if (SYMBOL_TYPE (sym
) == builtin_type_short
3548 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
3549 SYMBOL_VALUE (sym
) += 2;
3553 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
3555 /* If PCC says a parameter is a short or a char,
3556 it is really an int. */
3557 if (SYMBOL_TYPE (sym
) == builtin_type_char
3558 || SYMBOL_TYPE (sym
) == builtin_type_short
)
3559 SYMBOL_TYPE (sym
) = builtin_type_int
;
3560 else if (SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
3561 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
3562 SYMBOL_TYPE (sym
) = builtin_type_unsigned_int
;
3565 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
3568 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3569 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
3570 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3571 add_symbol_to_list (sym
, &local_symbols
);
3575 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
3576 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
3577 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3578 add_symbol_to_list (sym
, &local_symbols
);
3582 /* Static symbol at top level of file */
3583 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3584 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
3585 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3586 add_symbol_to_list (sym
, &file_symbols
);
3590 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3591 SYMBOL_VALUE (sym
) = valu
;
3592 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3593 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0
3594 && (TYPE_FLAGS (SYMBOL_TYPE (sym
)) & TYPE_FLAG_PERM
) == 0)
3595 TYPE_NAME (SYMBOL_TYPE (sym
)) =
3596 obsavestring (SYMBOL_NAME (sym
),
3597 strlen (SYMBOL_NAME (sym
)));
3598 /* C++ vagaries: we may have a type which is derived from
3599 a base type which did not have its name defined when the
3600 derived class was output. We fill in the derived class's
3601 base part member's name here in that case. */
3602 else if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
3603 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
3604 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
3607 for (i
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; i
>= 0; i
--)
3608 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), i
) == 0)
3609 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), i
) =
3610 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), i
));
3613 add_symbol_to_list (sym
, &file_symbols
);
3617 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3618 SYMBOL_VALUE (sym
) = valu
;
3619 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
3620 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0
3621 && (TYPE_FLAGS (SYMBOL_TYPE (sym
)) & TYPE_FLAG_PERM
) == 0)
3622 TYPE_NAME (SYMBOL_TYPE (sym
))
3624 (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_ENUM
3626 : (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
3627 ? "struct " : "union ")),
3629 add_symbol_to_list (sym
, &file_symbols
);
3633 register struct symbol
*typedef_sym
3634 = (struct symbol
*) obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
3635 SYMBOL_NAME (typedef_sym
) = SYMBOL_NAME (sym
);
3636 SYMBOL_TYPE (typedef_sym
) = SYMBOL_TYPE (sym
);
3638 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
3639 SYMBOL_VALUE (typedef_sym
) = valu
;
3640 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
3641 add_symbol_to_list (typedef_sym
, &file_symbols
);
3646 /* Static symbol of local scope */
3647 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3648 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
3649 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3650 add_symbol_to_list (sym
, &local_symbols
);
3654 /* Reference parameter */
3655 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
3656 SYMBOL_VALUE (sym
) = valu
;
3657 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3658 add_symbol_to_list (sym
, &local_symbols
);
3662 /* This is used by Sun FORTRAN for "function result value".
3663 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
3664 that Pascal uses it too, but when I tried it Pascal used
3665 "x:3" (local symbol) instead. */
3666 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3667 SYMBOL_VALUE (sym
) = valu
;
3668 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3669 add_symbol_to_list (sym
, &local_symbols
);
3673 error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype
, symnum
);
3678 /* What about types defined as forward references inside of a small lexical
3680 /* Add a type to the list of undefined types to be checked through
3681 once this file has been read in. */
3683 add_undefined_type (type
)
3686 if (undef_types_length
== undef_types_allocated
)
3688 undef_types_allocated
*= 2;
3689 undef_types
= (struct type
**)
3690 xrealloc (undef_types
,
3691 undef_types_allocated
* sizeof (struct type
*));
3693 undef_types
[undef_types_length
++] = type
;
3696 /* Add here something to go through each undefined type, see if it's
3697 still undefined, and do a full lookup if so. */
3699 cleanup_undefined_types ()
3703 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
3705 /* Reasonable test to see if it's been defined since. */
3706 if (TYPE_NFIELDS (*type
) == 0)
3708 struct pending
*ppt
;
3710 /* Name of the type, without "struct" or "union" */
3711 char *typename
= TYPE_NAME (*type
);
3713 if (!strncmp (typename
, "struct ", 7))
3715 if (!strncmp (typename
, "union ", 6))
3718 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
3719 for (i
= 0; i
< ppt
->nsyms
; i
++)
3721 struct symbol
*sym
= ppt
->symbol
[i
];
3723 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3724 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
3725 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
3727 && !strcmp (SYMBOL_NAME (sym
), typename
))
3728 bcopy (SYMBOL_TYPE (sym
), *type
, sizeof (struct type
));
3732 /* It has been defined; don't mark it as a stub. */
3733 TYPE_FLAGS (*type
) &= ~TYPE_FLAG_STUB
;
3735 undef_types_length
= 0;
3738 /* Skip rest of this symbol and return an error type.
3740 General notes on error recovery: error_type always skips to the
3741 end of the symbol (modulo cretinous dbx symbol name continuation).
3742 Thus code like this:
3744 if (*(*pp)++ != ';')
3745 return error_type (pp);
3747 is wrong because if *pp starts out pointing at '\0' (typically as the
3748 result of an earlier error), it will be incremented to point to the
3749 start of the next symbol, which might produce strange results, at least
3750 if you run off the end of the string table. Instead use
3753 return error_type (pp);
3759 foo = error_type (pp);
3763 And in case it isn't obvious, the point of all this hair is so the compiler
3764 can define new types and new syntaxes, and old versions of the
3765 debugger will be able to read the new symbol tables. */
3767 static struct type
*
3771 complain (&error_type_complaint
, 0);
3774 /* Skip to end of symbol. */
3775 while (**pp
!= '\0')
3778 /* Check for and handle cretinous dbx symbol name continuation! */
3779 if ((*pp
)[-1] == '\\')
3780 *pp
= next_symbol_text ();
3784 return builtin_type_error
;
3787 /* Read a dbx type reference or definition;
3788 return the type that is meant.
3789 This can be just a number, in which case it references
3790 a type already defined and placed in type_vector.
3791 Or the number can be followed by an =, in which case
3792 it means to define a new type according to the text that
3800 register struct type
*type
= 0;
3805 /* Read type number if present. The type number may be omitted.
3806 for instance in a two-dimensional array declared with type
3807 "ar1;1;10;ar1;1;10;4". */
3808 if ((**pp
>= '0' && **pp
<= '9')
3811 read_type_number (pp
, typenums
);
3813 /* Detect random reference to type not yet defined.
3814 Allocate a type object but leave it zeroed. */
3816 return dbx_alloc_type (typenums
);
3822 /* 'typenums=' not present, type is anonymous. Read and return
3823 the definition, but don't put it in the type vector. */
3824 typenums
[0] = typenums
[1] = -1;
3832 enum type_code code
;
3834 /* Used to index through file_symbols. */
3835 struct pending
*ppt
;
3838 /* Name including "struct", etc. */
3841 /* Name without "struct", etc. */
3842 char *type_name_only
;
3848 /* Set the type code according to the following letter. */
3852 code
= TYPE_CODE_STRUCT
;
3856 code
= TYPE_CODE_UNION
;
3860 code
= TYPE_CODE_ENUM
;
3864 return error_type (pp
);
3867 to
= type_name
= (char *)
3868 obstack_alloc (symbol_obstack
,
3870 ((char *) strchr (*pp
, ':') - (*pp
)) + 1));
3872 /* Copy the prefix. */
3874 while (*to
++ = *from
++)
3878 type_name_only
= to
;
3880 /* Copy the name. */
3882 while ((*to
++ = *from
++) != ':')
3886 /* Set the pointer ahead of the name which we just read. */
3890 /* The following hack is clearly wrong, because it doesn't
3891 check whether we are in a baseclass. I tried to reproduce
3892 the case that it is trying to fix, but I couldn't get
3893 g++ to put out a cross reference to a basetype. Perhaps
3894 it doesn't do it anymore. */
3895 /* Note: for C++, the cross reference may be to a base type which
3896 has not yet been seen. In this case, we skip to the comma,
3897 which will mark the end of the base class name. (The ':'
3898 at the end of the base class name will be skipped as well.)
3899 But sometimes (ie. when the cross ref is the last thing on
3900 the line) there will be no ','. */
3901 from
= (char *) strchr (*pp
, ',');
3907 /* Now check to see whether the type has already been declared. */
3908 /* This is necessary at least in the case where the
3909 program says something like
3911 The compiler puts out a cross-reference; we better find
3912 set the length of the structure correctly so we can
3913 set the length of the array. */
3914 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
3915 for (i
= 0; i
< ppt
->nsyms
; i
++)
3917 struct symbol
*sym
= ppt
->symbol
[i
];
3919 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3920 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
3921 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
3922 && !strcmp (SYMBOL_NAME (sym
), type_name_only
))
3924 obstack_free (symbol_obstack
, type_name
);
3925 type
= SYMBOL_TYPE (sym
);
3930 /* Didn't find the type to which this refers, so we must
3931 be dealing with a forward reference. Allocate a type
3932 structure for it, and keep track of it so we can
3933 fill in the rest of the fields when we get the full
3935 type
= dbx_alloc_type (typenums
);
3936 TYPE_CODE (type
) = code
;
3937 TYPE_NAME (type
) = type_name
;
3939 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3941 add_undefined_type (type
);
3957 read_type_number (pp
, xtypenums
);
3958 type
= *dbx_lookup_type (xtypenums
);
3960 type
= builtin_type_void
;
3961 if (typenums
[0] != -1)
3962 *dbx_lookup_type (typenums
) = type
;
3966 type1
= read_type (pp
);
3967 type
= lookup_pointer_type (type1
);
3968 if (typenums
[0] != -1)
3969 *dbx_lookup_type (typenums
) = type
;
3974 struct type
*domain
= read_type (pp
);
3975 struct type
*memtype
;
3978 /* Invalid member type data format. */
3979 return error_type (pp
);
3982 memtype
= read_type (pp
);
3983 type
= dbx_alloc_type (typenums
);
3984 smash_to_member_type (type
, domain
, memtype
);
3989 if ((*pp
)[0] == '#')
3991 /* We'll get the parameter types from the name. */
3992 struct type
*return_type
;
3995 return_type
= read_type (pp
);
3996 if (*(*pp
)++ != ';')
3997 complain (&invalid_member_complaint
, symnum
);
3998 type
= allocate_stub_method (return_type
);
3999 if (typenums
[0] != -1)
4000 *dbx_lookup_type (typenums
) = type
;
4004 struct type
*domain
= read_type (pp
);
4005 struct type
*return_type
;
4008 if (*(*pp
)++ != ',')
4009 error ("invalid member type data format, at symtab pos %d.",
4012 return_type
= read_type (pp
);
4013 args
= read_args (pp
, ';');
4014 type
= dbx_alloc_type (typenums
);
4015 smash_to_method_type (type
, domain
, return_type
, args
);
4020 type1
= read_type (pp
);
4021 type
= lookup_reference_type (type1
);
4022 if (typenums
[0] != -1)
4023 *dbx_lookup_type (typenums
) = type
;
4027 type1
= read_type (pp
);
4028 type
= lookup_function_type (type1
);
4029 if (typenums
[0] != -1)
4030 *dbx_lookup_type (typenums
) = type
;
4034 type
= read_range_type (pp
, typenums
);
4035 if (typenums
[0] != -1)
4036 *dbx_lookup_type (typenums
) = type
;
4040 type
= dbx_alloc_type (typenums
);
4041 type
= read_enum_type (pp
, type
);
4042 *dbx_lookup_type (typenums
) = 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
);
4053 type
= dbx_alloc_type (typenums
);
4054 TYPE_NAME (type
) = type_synonym_name
;
4055 type_synonym_name
= 0;
4056 type
= read_struct_type (pp
, type
);
4057 TYPE_CODE (type
) = TYPE_CODE_UNION
;
4062 return error_type (pp
);
4065 type
= dbx_alloc_type (typenums
);
4066 type
= read_array_type (pp
, type
);
4070 return error_type (pp
);
4077 /* If this is an overriding temporary alteration for a header file's
4078 contents, and this type number is unknown in the global definition,
4079 put this type into the global definition at this type number. */
4080 if (header_file_prev_index
>= 0)
4082 register struct type
**tp
4083 = explicit_lookup_type (header_file_prev_index
, typenums
[1]);
4092 /* This would be a good idea, but it doesn't really work. The problem
4093 is that in order to get the virtual context for a particular type,
4094 you need to know the virtual info from all of its basetypes,
4095 and you need to have processed its methods. Since GDB reads
4096 symbols on a file-by-file basis, this means processing the symbols
4097 of all the files that are needed for each baseclass, which
4098 means potentially reading in all the debugging info just to fill
4099 in information we may never need. */
4101 /* This page contains subroutines of read_type. */
4103 /* FOR_TYPE is a struct type defining a virtual function NAME with type
4104 FN_TYPE. The `virtual context' for this virtual function is the
4105 first base class of FOR_TYPE in which NAME is defined with signature
4106 matching FN_TYPE. OFFSET serves as a hash on matches here.
4108 TYPE is the current type in which we are searching. */
4110 static struct type
*
4111 virtual_context (for_type
, type
, name
, fn_type
, offset
)
4112 struct type
*for_type
, *type
;
4114 struct type
*fn_type
;
4117 struct type
*basetype
= 0;
4120 if (for_type
!= type
)
4122 /* Check the methods of TYPE. */
4123 /* Need to do a check_stub_type here, but that breaks
4124 things because we can get infinite regress. */
4125 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
4126 if (!strcmp (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
4130 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
4131 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
4134 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == offset
-1)
4135 return TYPE_FN_FIELD_FCONTEXT (f
, j
);
4138 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
4140 basetype
= virtual_context (for_type
, TYPE_BASECLASS (type
, i
), name
,
4142 if (basetype
!= for_type
)
4149 /* Read the description of a structure (or union type)
4150 and return an object describing the type. */
4152 static struct type
*
4153 read_struct_type (pp
, type
)
4155 register struct type
*type
;
4157 /* Total number of methods defined in this class.
4158 If the class defines two `f' methods, and one `g' method,
4159 then this will have the value 3. */
4160 int total_length
= 0;
4164 struct nextfield
*next
;
4165 int visibility
; /* 0=public, 1=protected, 2=public */
4171 struct next_fnfield
*next
;
4172 int visibility
; /* 0=public, 1=protected, 2=public */
4173 struct fn_field fn_field
;
4176 struct next_fnfieldlist
4178 struct next_fnfieldlist
*next
;
4179 struct fn_fieldlist fn_fieldlist
;
4182 register struct nextfield
*list
= 0;
4183 struct nextfield
*new;
4188 register struct next_fnfieldlist
*mainlist
= 0;
4191 if (TYPE_MAIN_VARIANT (type
) == 0)
4193 TYPE_MAIN_VARIANT (type
) = type
;
4196 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
4198 /* First comes the total size in bytes. */
4200 TYPE_LENGTH (type
) = read_number (pp
, 0);
4202 /* C++: Now, if the class is a derived class, then the next character
4203 will be a '!', followed by the number of base classes derived from.
4204 Each element in the list contains visibility information,
4205 the offset of this base class in the derived structure,
4206 and then the base type. */
4209 int i
, n_baseclasses
, offset
;
4210 struct type
*baseclass
;
4213 /* Nonzero if it is a virtual baseclass, i.e.,
4217 struct C : public B, public virtual A {};
4219 B is a baseclass of C; A is a virtual baseclass for C. This is a C++
4220 2.0 language feature. */
4225 n_baseclasses
= read_number (pp
, ',');
4226 TYPE_FIELD_VIRTUAL_BITS (type
) =
4227 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (n_baseclasses
));
4228 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), n_baseclasses
);
4230 for (i
= 0; i
< n_baseclasses
; i
++)
4233 *pp
= next_symbol_text ();
4244 /* Bad visibility format. */
4245 return error_type (pp
);
4258 /* Bad visibility format. */
4259 return error_type (pp
);
4262 SET_TYPE_FIELD_VIRTUAL (type
, i
);
4265 /* Offset of the portion of the object corresponding to
4266 this baseclass. Always zero in the absence of
4267 multiple inheritance. */
4268 offset
= read_number (pp
, ',');
4269 baseclass
= read_type (pp
);
4270 *pp
+= 1; /* skip trailing ';' */
4273 /* One's understanding improves, grasshopper... */
4276 static int error_printed
= 0;
4281 "\nWarning: GDB has limited understanding of multiple inheritance...");
4283 fprintf(stderr
, "\n");
4289 /* Make this baseclass visible for structure-printing purposes. */
4290 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4293 list
->visibility
= via_public
;
4294 list
->field
.type
= baseclass
;
4295 list
->field
.name
= type_name_no_tag (baseclass
);
4296 list
->field
.bitpos
= offset
;
4297 list
->field
.bitsize
= 0; /* this should be an unpacked field! */
4300 TYPE_N_BASECLASSES (type
) = n_baseclasses
;
4303 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
4304 At the end, we see a semicolon instead of a field.
4306 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
4309 The `?' is a placeholder for one of '/2' (public visibility),
4310 '/1' (protected visibility), '/0' (private visibility), or nothing
4311 (C style symbol table, public visibility). */
4313 /* We better set p right now, in case there are no fields at all... */
4318 /* Check for and handle cretinous dbx symbol name continuation! */
4319 if (**pp
== '\\') *pp
= next_symbol_text ();
4321 /* Get space to record the next field's data. */
4322 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4326 /* Get the field name. */
4328 if (*p
== CPLUS_MARKER
)
4330 /* Special GNU C++ name. */
4333 char *prefix
, *name
= 0;
4334 struct type
*context
;
4345 error ("invalid abbreviation at symtab pos %d.", symnum
);
4348 context
= read_type (pp
);
4349 if (type_name_no_tag (context
) == 0)
4352 error ("type name unknown at symtab pos %d.", symnum
);
4353 /* FIXME-tiemann: when is `name' ever non-0? */
4354 TYPE_NAME (context
) = obsavestring (name
, p
- name
- 1);
4356 list
->field
.name
= obconcat (prefix
, type_name_no_tag (context
), "");
4359 error ("invalid abbreviation at symtab pos %d.", symnum
);
4360 list
->field
.type
= read_type (pp
);
4361 (*pp
)++; /* Skip the comma. */
4362 list
->field
.bitpos
= read_number (pp
, ';');
4363 /* This field is unpacked. */
4364 list
->field
.bitsize
= 0;
4367 error ("invalid abbreviation at symtab pos %d.", symnum
);
4373 while (*p
!= ':') p
++;
4374 list
->field
.name
= obsavestring (*pp
, p
- *pp
);
4376 /* C++: Check to see if we have hit the methods yet. */
4382 /* This means we have a visibility for a field coming. */
4388 list
->visibility
= 0; /* private */
4393 list
->visibility
= 1; /* protected */
4398 list
->visibility
= 2; /* public */
4403 else /* normal dbx-style format. */
4404 list
->visibility
= 2; /* public */
4406 list
->field
.type
= read_type (pp
);
4409 /* Static class member. */
4410 list
->field
.bitpos
= (long)-1;
4412 while (*p
!= ';') p
++;
4413 list
->field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
4418 else if (**pp
!= ',')
4419 /* Bad structure-type format. */
4420 return error_type (pp
);
4422 (*pp
)++; /* Skip the comma. */
4423 list
->field
.bitpos
= read_number (pp
, ',');
4424 list
->field
.bitsize
= read_number (pp
, ';');
4427 /* FIXME-tiemann: Can't the compiler put out something which
4428 lets us distinguish these? (or maybe just not put out anything
4429 for the field). What is the story here? What does the compiler
4430 really do? Also, patch gdb.texinfo for this case; I document
4431 it as a possible problem there. Search for "DBX-style". */
4433 /* This is wrong because this is identical to the symbols
4434 produced for GCC 0-size arrays. For example:
4439 The code which dumped core in such circumstances should be
4440 fixed not to dump core. */
4442 /* g++ -g0 can put out bitpos & bitsize zero for a static
4443 field. This does not give us any way of getting its
4444 class, so we can't know its name. But we can just
4445 ignore the field so we don't dump core and other nasty
4447 if (list
->field
.bitpos
== 0
4448 && list
->field
.bitsize
== 0)
4450 complain (&dbx_class_complaint
, 0);
4451 /* Ignore this field. */
4457 /* Detect an unpacked field and mark it as such.
4458 dbx gives a bit size for all fields.
4459 Note that forward refs cannot be packed,
4460 and treat enums as if they had the width of ints. */
4461 if (TYPE_CODE (list
->field
.type
) != TYPE_CODE_INT
4462 && TYPE_CODE (list
->field
.type
) != TYPE_CODE_ENUM
)
4463 list
->field
.bitsize
= 0;
4464 if ((list
->field
.bitsize
== 8 * TYPE_LENGTH (list
->field
.type
)
4465 || (TYPE_CODE (list
->field
.type
) == TYPE_CODE_ENUM
4466 && (list
->field
.bitsize
4467 == 8 * TYPE_LENGTH (builtin_type_int
))
4471 list
->field
.bitpos
% 8 == 0)
4472 list
->field
.bitsize
= 0;
4478 /* chill the list of fields: the last entry (at the head)
4479 is a partially constructed entry which we now scrub. */
4482 /* Now create the vector of fields, and record how big it is.
4483 We need this info to record proper virtual function table information
4484 for this class's virtual functions. */
4486 TYPE_NFIELDS (type
) = nfields
;
4487 TYPE_FIELDS (type
) = (struct field
*) obstack_alloc (symbol_obstack
,
4488 sizeof (struct field
) * nfields
);
4490 TYPE_FIELD_PRIVATE_BITS (type
) =
4491 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (nfields
));
4492 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4494 TYPE_FIELD_PROTECTED_BITS (type
) =
4495 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (nfields
));
4496 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4498 /* Copy the saved-up fields into the field vector. */
4500 for (n
= nfields
; list
; list
= list
->next
)
4503 TYPE_FIELD (type
, n
) = list
->field
;
4504 if (list
->visibility
== 0)
4505 SET_TYPE_FIELD_PRIVATE (type
, n
);
4506 else if (list
->visibility
== 1)
4507 SET_TYPE_FIELD_PROTECTED (type
, n
);
4510 /* Now come the method fields, as NAME::methods
4511 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
4512 At the end, we see a semicolon instead of a field.
4514 For the case of overloaded operators, the format is
4515 OPERATOR::*.methods, where OPERATOR is the string "operator",
4516 `*' holds the place for an operator name (such as `+=')
4517 and `.' marks the end of the operator name. */
4520 /* Now, read in the methods. To simplify matters, we
4521 "unread" the name that has been read, so that we can
4522 start from the top. */
4524 /* For each list of method lists... */
4528 struct next_fnfield
*sublist
= 0;
4530 struct next_fnfieldlist
*new_mainlist
=
4531 (struct next_fnfieldlist
*)alloca (sizeof (struct next_fnfieldlist
));
4536 /* read in the name. */
4537 while (*p
!= ':') p
++;
4538 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
4540 /* This lets the user type "break operator+".
4541 We could just put in "+" as the name, but that wouldn't
4543 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
4544 char *o
= opname
+ 3;
4546 /* Skip past '::'. */
4550 main_fn_name
= savestring (opname
, o
- opname
);
4557 main_fn_name
= savestring (*pp
, p
- *pp
);
4558 /* Skip past '::'. */
4561 new_mainlist
->fn_fieldlist
.name
= main_fn_name
;
4565 struct next_fnfield
*new_sublist
=
4566 (struct next_fnfield
*)alloca (sizeof (struct next_fnfield
));
4568 /* Check for and handle cretinous dbx symbol name continuation! */
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
);
4578 while (*p
!= ';') p
++;
4579 /* If this is just a stub, then we don't have the
4581 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
4583 new_sublist
->visibility
= *(*pp
)++ - '0';
4584 if (**pp
== '\\') *pp
= next_symbol_text ();
4585 /* FIXME-tiemann: need to add const/volatile info
4586 to the methods. For now, just skip the char.
4587 In future, here's what we need to implement:
4589 A for normal functions.
4590 B for `const' member functions.
4591 C for `volatile' member functions.
4592 D for `const volatile' member functions. */
4593 if (**pp
== 'A' || **pp
== 'B' || **pp
== 'C' || **pp
== 'D')
4596 /* This probably just means we're processing a file compiled
4597 with g++ version 1. */
4599 complain(&const_vol_complaint
, **pp
);
4605 /* virtual member function, followed by index. */
4606 /* The sign bit is set to distinguish pointers-to-methods
4607 from virtual function indicies. Since the array is
4608 in words, the quantity must be shifted left by 1
4609 on 16 bit machine, and by 2 on 32 bit machine, forcing
4610 the sign bit out, and usable as a valid index into
4611 the array. Remove the sign bit here. */
4612 new_sublist
->fn_field
.voffset
=
4613 (0x7fffffff & read_number (pp
, ';')) + 1;
4615 if (**pp
== ';' || **pp
== '\0')
4616 /* Must be g++ version 1. */
4617 new_sublist
->fn_field
.fcontext
= 0;
4620 /* Figure out from whence this virtual function came.
4621 It may belong to virtual function table of
4622 one of its baseclasses. */
4623 new_sublist
->fn_field
.fcontext
= read_type (pp
);
4625 return error_type (pp
);
4632 /* static member function. */
4633 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
4637 /* normal member function. */
4638 new_sublist
->fn_field
.voffset
= 0;
4639 new_sublist
->fn_field
.fcontext
= 0;
4643 new_sublist
->next
= sublist
;
4644 sublist
= new_sublist
;
4647 while (**pp
!= ';' && **pp
!= '\0');
4651 new_mainlist
->fn_fieldlist
.fn_fields
=
4652 (struct fn_field
*) obstack_alloc (symbol_obstack
,
4653 sizeof (struct fn_field
) * length
);
4654 TYPE_FN_PRIVATE_BITS (new_mainlist
->fn_fieldlist
) =
4655 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (length
));
4656 B_CLRALL (TYPE_FN_PRIVATE_BITS (new_mainlist
->fn_fieldlist
), length
);
4658 TYPE_FN_PROTECTED_BITS (new_mainlist
->fn_fieldlist
) =
4659 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (length
));
4660 B_CLRALL (TYPE_FN_PROTECTED_BITS (new_mainlist
->fn_fieldlist
), length
);
4662 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
4664 new_mainlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
4665 if (sublist
->visibility
== 0)
4666 B_SET (new_mainlist
->fn_fieldlist
.private_fn_field_bits
, i
);
4667 else if (sublist
->visibility
== 1)
4668 B_SET (new_mainlist
->fn_fieldlist
.protected_fn_field_bits
, i
);
4671 new_mainlist
->fn_fieldlist
.length
= length
;
4672 new_mainlist
->next
= mainlist
;
4673 mainlist
= new_mainlist
;
4675 total_length
+= length
;
4677 while (**pp
!= ';');
4682 TYPE_FN_FIELDLISTS (type
) =
4683 (struct fn_fieldlist
*) obstack_alloc (symbol_obstack
,
4684 sizeof (struct fn_fieldlist
) * nfn_fields
);
4686 TYPE_NFN_FIELDS (type
) = nfn_fields
;
4687 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
4691 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
4692 TYPE_NFN_FIELDS_TOTAL (type
) +=
4693 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, i
));
4696 for (n
= nfn_fields
; mainlist
; mainlist
= mainlist
->next
)
4697 TYPE_FN_FIELDLISTS (type
)[--n
] = mainlist
->fn_fieldlist
;
4706 |= TYPE_FLAG_HAS_CONSTRUCTOR
| TYPE_FLAG_HAS_DESTRUCTOR
;
4709 else if (**pp
== '+')
4711 TYPE_FLAGS (type
) |= TYPE_FLAG_HAS_CONSTRUCTOR
;
4714 else if (**pp
== '-')
4716 TYPE_FLAGS (type
) |= TYPE_FLAG_HAS_DESTRUCTOR
;
4720 /* Read either a '%' or the final ';'. */
4721 if (*(*pp
)++ == '%')
4723 /* Now we must record the virtual function table pointer's
4724 field information. */
4731 while (*p
!= '\0' && *p
!= ';')
4734 /* Premature end of symbol. */
4735 return error_type (pp
);
4737 TYPE_VPTR_BASETYPE (type
) = t
;
4740 if (TYPE_FIELD_NAME (t
, TYPE_N_BASECLASSES (t
)) == 0)
4742 /* FIXME-tiemann: what's this? */
4744 TYPE_VPTR_FIELDNO (type
) = i
= TYPE_N_BASECLASSES (t
);
4749 else for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); --i
)
4750 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
4751 sizeof (vptr_name
) -1))
4753 TYPE_VPTR_FIELDNO (type
) = i
;
4757 /* Virtual function table field not found. */
4758 return error_type (pp
);
4761 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
4769 /* Read a definition of an array type,
4770 and create and return a suitable type object.
4771 Also creates a range type which represents the bounds of that
4773 static struct type
*
4774 read_array_type (pp
, type
)
4776 register struct type
*type
;
4778 struct type
*index_type
, *element_type
, *range_type
;
4782 /* Format of an array type:
4783 "ar<index type>;lower;upper;<array_contents_type>". Put code in
4786 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
4787 for these, produce a type like float[][]. */
4789 index_type
= read_type (pp
);
4791 /* Improper format of array type decl. */
4792 return error_type (pp
);
4795 if (!(**pp
>= '0' && **pp
<= '9'))
4800 lower
= read_number (pp
, ';');
4802 if (!(**pp
>= '0' && **pp
<= '9'))
4807 upper
= read_number (pp
, ';');
4809 element_type
= read_type (pp
);
4818 /* Create range type. */
4819 range_type
= (struct type
*) obstack_alloc (symbol_obstack
,
4820 sizeof (struct type
));
4821 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
4822 TYPE_TARGET_TYPE (range_type
) = index_type
;
4824 /* This should never be needed. */
4825 TYPE_LENGTH (range_type
) = sizeof (int);
4827 TYPE_NFIELDS (range_type
) = 2;
4828 TYPE_FIELDS (range_type
) =
4829 (struct field
*) obstack_alloc (symbol_obstack
,
4830 2 * sizeof (struct field
));
4831 TYPE_FIELD_BITPOS (range_type
, 0) = lower
;
4832 TYPE_FIELD_BITPOS (range_type
, 1) = upper
;
4835 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
4836 TYPE_TARGET_TYPE (type
) = element_type
;
4837 TYPE_LENGTH (type
) = (upper
- lower
+ 1) * TYPE_LENGTH (element_type
);
4838 TYPE_NFIELDS (type
) = 1;
4839 TYPE_FIELDS (type
) =
4840 (struct field
*) obstack_alloc (symbol_obstack
,
4841 sizeof (struct field
));
4842 TYPE_FIELD_TYPE (type
, 0) = range_type
;
4848 /* Read a definition of an enumeration type,
4849 and create and return a suitable type object.
4850 Also defines the symbols that represent the values of the type. */
4852 static struct type
*
4853 read_enum_type (pp
, type
)
4855 register struct type
*type
;
4860 register struct symbol
*sym
;
4862 struct pending
**symlist
;
4863 struct pending
*osyms
, *syms
;
4866 if (within_function
)
4867 symlist
= &local_symbols
;
4869 symlist
= &file_symbols
;
4871 o_nsyms
= osyms
? osyms
->nsyms
: 0;
4873 /* Read the value-names and their values.
4874 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
4875 A semicolon or comman instead of a NAME means the end. */
4876 while (**pp
&& **pp
!= ';' && **pp
!= ',')
4878 /* Check for and handle cretinous dbx symbol name continuation! */
4879 if (**pp
== '\\') *pp
= next_symbol_text ();
4882 while (*p
!= ':') p
++;
4883 name
= obsavestring (*pp
, p
- *pp
);
4885 n
= read_number (pp
, ',');
4887 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
4888 bzero (sym
, sizeof (struct symbol
));
4889 SYMBOL_NAME (sym
) = name
;
4890 SYMBOL_CLASS (sym
) = LOC_CONST
;
4891 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4892 SYMBOL_VALUE (sym
) = n
;
4893 add_symbol_to_list (sym
, symlist
);
4898 (*pp
)++; /* Skip the semicolon. */
4900 /* Now fill in the fields of the type-structure. */
4902 TYPE_LENGTH (type
) = sizeof (int);
4903 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4904 TYPE_NFIELDS (type
) = nsyms
;
4905 TYPE_FIELDS (type
) = (struct field
*) obstack_alloc (symbol_obstack
, sizeof (struct field
) * nsyms
);
4907 /* Find the symbols for the values and put them into the type.
4908 The symbols can be found in the symlist that we put them on
4909 to cause them to be defined. osyms contains the old value
4910 of that symlist; everything up to there was defined by us. */
4911 /* Note that we preserve the order of the enum constants, so
4912 that in something like "enum {FOO, LAST_THING=FOO}" we print
4913 FOO, not LAST_THING. */
4915 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
4920 for (; j
< syms
->nsyms
; j
++,n
++)
4922 struct symbol
*sym
= syms
->symbol
[j
];
4923 SYMBOL_TYPE (sym
) = type
;
4924 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (sym
);
4925 TYPE_FIELD_VALUE (type
, n
) = 0;
4926 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (sym
);
4927 TYPE_FIELD_BITSIZE (type
, n
) = 0;
4936 /* Read a number from the string pointed to by *PP.
4937 The value of *PP is advanced over the number.
4938 If END is nonzero, the character that ends the
4939 number must match END, or an error happens;
4940 and that character is skipped if it does match.
4941 If END is zero, *PP is left pointing to that character.
4943 If the number fits in a long, set *VALUE and set *BITS to 0.
4944 If not, set *BITS to be the number of bits in the number.
4946 If encounter garbage, set *BITS to -1. */
4949 read_huge_number (pp
, end
, valu
, bits
)
4969 /* Leading zero means octal. GCC uses this to output values larger
4970 than an int (because that would be hard in decimal). */
4977 while ((c
= *p
++) >= '0' && c
<= ('0' + radix
))
4979 if (n
<= LONG_MAX
/ radix
)
4982 n
+= c
- '0'; /* FIXME this overflows anyway */
4987 /* This depends on large values being output in octal, which is
4994 /* Ignore leading zeroes. */
4998 else if (c
== '2' || c
== '3')
5024 /* Large decimal constants are an error (because it is hard to
5025 count how many bits are in them). */
5031 /* -0x7f is the same as 0x80. So deal with it by adding one to
5032 the number of bits. */
5047 #define MAX_OF_TYPE(t) ((1 << (sizeof (t)*8 - 1)) - 1)
5048 #define MIN_OF_TYPE(t) (-(1 << (sizeof (t)*8 - 1)))
5050 static struct type
*
5051 read_range_type (pp
, typenums
)
5059 struct type
*result_type
;
5061 /* First comes a type we are a subrange of.
5062 In C it is usually 0, 1 or the type being defined. */
5063 read_type_number (pp
, rangenums
);
5064 self_subrange
= (rangenums
[0] == typenums
[0] &&
5065 rangenums
[1] == typenums
[1]);
5067 /* A semicolon should now follow; skip it. */
5071 /* The remaining two operands are usually lower and upper bounds
5072 of the range. But in some special cases they mean something else. */
5073 read_huge_number (pp
, ';', &n2
, &n2bits
);
5074 read_huge_number (pp
, ';', &n3
, &n3bits
);
5076 if (n2bits
== -1 || n3bits
== -1)
5077 return error_type (pp
);
5079 /* If limits are huge, must be large integral type. */
5080 if (n2bits
!= 0 || n3bits
!= 0)
5082 char got_signed
= 0;
5083 char got_unsigned
= 0;
5084 /* Number of bits in the type. */
5087 /* Range from 0 to <large number> is an unsigned large integral type. */
5088 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
5093 /* Range from <large number> to <large number>-1 is a large signed
5095 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
5101 /* Check for "long long". */
5102 if (got_signed
&& nbits
== TARGET_LONG_LONG_BIT
)
5103 return builtin_type_long_long
;
5104 if (got_unsigned
&& nbits
== TARGET_LONG_LONG_BIT
)
5105 return builtin_type_unsigned_long_long
;
5107 if (got_signed
|| got_unsigned
)
5109 result_type
= (struct type
*) obstack_alloc (symbol_obstack
,
5110 sizeof (struct type
));
5111 bzero (result_type
, sizeof (struct type
));
5112 TYPE_LENGTH (result_type
) = nbits
/ TARGET_CHAR_BIT
;
5113 TYPE_MAIN_VARIANT (result_type
) = result_type
;
5114 TYPE_CODE (result_type
) = TYPE_CODE_INT
;
5116 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
5120 return error_type (pp
);
5123 /* A type defined as a subrange of itself, with bounds both 0, is void. */
5124 if (self_subrange
&& n2
== 0 && n3
== 0)
5125 return builtin_type_void
;
5127 /* If n3 is zero and n2 is not, we want a floating type,
5128 and n2 is the width in bytes.
5130 Fortran programs appear to use this for complex types also,
5131 and they give no way to distinguish between double and single-complex!
5132 We don't have complex types, so we would lose on all fortran files!
5133 So return type `double' for all of those. It won't work right
5134 for the complex values, but at least it makes the file loadable. */
5136 if (n3
== 0 && n2
> 0)
5138 if (n2
== sizeof (float))
5139 return builtin_type_float
;
5140 return builtin_type_double
;
5143 /* If the upper bound is -1, it must really be an unsigned int. */
5145 else if (n2
== 0 && n3
== -1)
5147 if (sizeof (int) == sizeof (long))
5148 return builtin_type_unsigned_int
;
5150 return builtin_type_unsigned_long
;
5153 /* Special case: char is defined (Who knows why) as a subrange of
5154 itself with range 0-127. */
5155 else if (self_subrange
&& n2
== 0 && n3
== 127)
5156 return builtin_type_char
;
5158 /* Assumptions made here: Subrange of self is equivalent to subrange
5161 && (self_subrange
||
5162 *dbx_lookup_type (rangenums
) == builtin_type_int
))
5164 /* an unsigned type */
5166 if (n3
== - sizeof (long long))
5167 return builtin_type_unsigned_long_long
;
5169 if (n3
== (unsigned int)~0L)
5170 return builtin_type_unsigned_int
;
5171 if (n3
== (unsigned long)~0L)
5172 return builtin_type_unsigned_long
;
5173 if (n3
== (unsigned short)~0L)
5174 return builtin_type_unsigned_short
;
5175 if (n3
== (unsigned char)~0L)
5176 return builtin_type_unsigned_char
;
5179 else if (n3
== 0 && n2
== -sizeof (long long))
5180 return builtin_type_long_long
;
5182 else if (n2
== -n3
-1)
5185 if (n3
== (1 << (8 * sizeof (int) - 1)) - 1)
5186 return builtin_type_int
;
5187 if (n3
== (1 << (8 * sizeof (long) - 1)) - 1)
5188 return builtin_type_long
;
5189 if (n3
== (1 << (8 * sizeof (short) - 1)) - 1)
5190 return builtin_type_short
;
5191 if (n3
== (1 << (8 * sizeof (char) - 1)) - 1)
5192 return builtin_type_char
;
5195 /* We have a real range type on our hands. Allocate space and
5196 return a real pointer. */
5198 /* At this point I don't have the faintest idea how to deal with
5199 a self_subrange type; I'm going to assume that this is used
5200 as an idiom, and that all of them are special cases. So . . . */
5202 return error_type (pp
);
5204 result_type
= (struct type
*) obstack_alloc (symbol_obstack
,
5205 sizeof (struct type
));
5206 bzero (result_type
, sizeof (struct type
));
5208 TYPE_TARGET_TYPE (result_type
) = (self_subrange
?
5210 *dbx_lookup_type(rangenums
));
5212 /* We have to figure out how many bytes it takes to hold this
5213 range type. I'm going to assume that anything that is pushing
5214 the bounds of a long was taken care of above. */
5215 if (n2
>= MIN_OF_TYPE(char) && n3
<= MAX_OF_TYPE(char))
5216 TYPE_LENGTH (result_type
) = 1;
5217 else if (n2
>= MIN_OF_TYPE(short) && n3
<= MAX_OF_TYPE(short))
5218 TYPE_LENGTH (result_type
) = sizeof (short);
5219 else if (n2
>= MIN_OF_TYPE(int) && n3
<= MAX_OF_TYPE(int))
5220 TYPE_LENGTH (result_type
) = sizeof (int);
5221 else if (n2
>= MIN_OF_TYPE(long) && n3
<= MAX_OF_TYPE(long))
5222 TYPE_LENGTH (result_type
) = sizeof (long);
5224 /* Ranged type doesn't fit within known sizes. */
5225 return error_type (pp
);
5227 TYPE_LENGTH (result_type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type
));
5228 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
5229 TYPE_NFIELDS (result_type
) = 2;
5230 TYPE_FIELDS (result_type
) =
5231 (struct field
*) obstack_alloc (symbol_obstack
,
5232 2 * sizeof (struct field
));
5233 bzero (TYPE_FIELDS (result_type
), 2 * sizeof (struct field
));
5234 TYPE_FIELD_BITPOS (result_type
, 0) = n2
;
5235 TYPE_FIELD_BITPOS (result_type
, 1) = n3
;
5240 /* Read a number from the string pointed to by *PP.
5241 The value of *PP is advanced over the number.
5242 If END is nonzero, the character that ends the
5243 number must match END, or an error happens;
5244 and that character is skipped if it does match.
5245 If END is zero, *PP is left pointing to that character. */
5248 read_number (pp
, end
)
5252 register char *p
= *pp
;
5253 register long n
= 0;
5257 /* Handle an optional leading minus sign. */
5265 /* Read the digits, as far as they go. */
5267 while ((c
= *p
++) >= '0' && c
<= '9')
5275 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c
, symnum
);
5284 /* Read in an argument list. This is a list of types, separated by commas
5285 and terminated with END. Return the list of types read in, or (struct type
5286 **)-1 if there is an error. */
5287 static struct type
**
5292 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
5298 /* Invalid argument list: no ','. */
5299 return (struct type
**)-1;
5302 /* Check for and handle cretinous dbx symbol name continuation! */
5304 *pp
= next_symbol_text ();
5306 types
[n
++] = read_type (pp
);
5308 *pp
+= 1; /* get past `end' (the ':' character) */
5312 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
5314 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
5316 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
5317 bzero (rval
+ n
, sizeof (struct type
*));
5321 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
5323 bcopy (types
, rval
, n
* sizeof (struct type
*));
5327 /* Copy a pending list, used to record the contents of a common
5328 block for later fixup. */
5329 static struct pending
*
5330 copy_pending (beg
, begi
, end
)
5331 struct pending
*beg
, *end
;
5334 struct pending
*new = 0;
5335 struct pending
*next
;
5337 for (next
= beg
; next
!= 0 && (next
!= end
|| begi
< end
->nsyms
);
5338 next
= next
->next
, begi
= 0)
5341 for (j
= begi
; j
< next
->nsyms
; j
++)
5342 add_symbol_to_list (next
->symbol
[j
], &new);
5347 /* Add a common block's start address to the offset of each symbol
5348 declared to be in it (by being between a BCOMM/ECOMM pair that uses
5349 the common block name). */
5352 fix_common_block (sym
, valu
)
5356 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
5357 for ( ; next
; next
= next
->next
)
5360 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
5361 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
5365 /* Register our willingness to decode symbols for SunOS and a.out and
5366 b.out files handled by BFD... */
5367 static struct sym_fns sunos_sym_fns
= {"sunOs", 6,
5368 dbx_new_init
, dbx_symfile_init
,
5369 dbx_symfile_read
, dbx_symfile_discard
};
5371 static struct sym_fns aout_sym_fns
= {"a.out", 5,
5372 dbx_new_init
, dbx_symfile_init
,
5373 dbx_symfile_read
, dbx_symfile_discard
};
5375 static struct sym_fns bout_sym_fns
= {"b.out", 5,
5376 dbx_new_init
, dbx_symfile_init
,
5377 dbx_symfile_read
, dbx_symfile_discard
};
5380 _initialize_dbxread ()
5382 add_symtab_fns(&sunos_sym_fns
);
5383 add_symtab_fns(&aout_sym_fns
);
5384 add_symtab_fns(&bout_sym_fns
);
5386 undef_types_allocated
= 20;
5387 undef_types_length
= 0;
5388 undef_types
= (struct type
**) xmalloc (undef_types_allocated
*
5389 sizeof (struct type
*));