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;
677 /* Make sure there is a type allocated for type numbers TYPENUMS
678 and return the type object.
679 This can create an empty (zeroed) type object.
680 TYPENUMS may be (-1, -1) to return a new type object that is not
681 put into the type vector, and so may not be referred to by number. */
684 dbx_alloc_type (typenums
)
687 register struct type
**type_addr
;
688 register struct type
*type
;
690 if (typenums
[1] != -1)
692 type_addr
= dbx_lookup_type (typenums
);
701 /* If we are referring to a type not known at all yet,
702 allocate an empty type for it.
703 We will fill it in later if we find out how. */
706 type
= dbx_create_type ();
715 static struct type
**
716 explicit_lookup_type (real_filenum
, index
)
717 int real_filenum
, index
;
719 register struct header_file
*f
= &header_files
[real_filenum
];
721 if (index
>= f
->length
)
724 f
->vector
= (struct type
**)
725 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
726 bzero (&f
->vector
[f
->length
/ 2],
727 f
->length
* sizeof (struct type
*) / 2);
729 return &f
->vector
[index
];
733 /* maintain the lists of symbols and blocks */
735 /* Add a symbol to one of the lists of symbols. */
737 add_symbol_to_list (symbol
, listhead
)
738 struct symbol
*symbol
;
739 struct pending
**listhead
;
741 /* We keep PENDINGSIZE symbols in each link of the list.
742 If we don't have a link with room in it, add a new link. */
743 if (*listhead
== 0 || (*listhead
)->nsyms
== PENDINGSIZE
)
745 register struct pending
*link
;
748 link
= free_pendings
;
749 free_pendings
= link
->next
;
752 link
= (struct pending
*) xmalloc (sizeof (struct pending
));
754 link
->next
= *listhead
;
759 (*listhead
)->symbol
[(*listhead
)->nsyms
++] = symbol
;
762 /* At end of reading syms, or in case of quit,
763 really free as many `struct pending's as we can easily find. */
767 really_free_pendings (foo
)
770 struct pending
*next
, *next1
;
771 struct pending_block
*bnext
, *bnext1
;
773 for (next
= free_pendings
; next
; next
= next1
)
780 #if 0 /* Now we make the links in the symbol_obstack, so don't free them. */
781 for (bnext
= pending_blocks
; bnext
; bnext
= bnext1
)
783 bnext1
= bnext
->next
;
789 for (next
= file_symbols
; next
; next
= next1
)
794 for (next
= global_symbols
; next
; next
= next1
)
801 /* Take one of the lists of symbols and make a block from it.
802 Keep the order the symbols have in the list (reversed from the input file).
803 Put the block on the list of pending blocks. */
806 finish_block (symbol
, listhead
, old_blocks
, start
, end
)
807 struct symbol
*symbol
;
808 struct pending
**listhead
;
809 struct pending_block
*old_blocks
;
810 CORE_ADDR start
, end
;
812 register struct pending
*next
, *next1
;
813 register struct block
*block
;
814 register struct pending_block
*pblock
;
815 struct pending_block
*opblock
;
818 /* Count the length of the list of symbols. */
820 for (next
= *listhead
, i
= 0; next
; i
+= next
->nsyms
, next
= next
->next
)
823 block
= (struct block
*) obstack_alloc (symbol_obstack
,
824 (sizeof (struct block
)
826 * sizeof (struct symbol
*))));
828 /* Copy the symbols into the block. */
830 BLOCK_NSYMS (block
) = i
;
831 for (next
= *listhead
; next
; next
= next
->next
)
834 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
835 BLOCK_SYM (block
, --i
) = next
->symbol
[j
];
838 BLOCK_START (block
) = start
;
839 BLOCK_END (block
) = end
;
840 BLOCK_SUPERBLOCK (block
) = 0; /* Filled in when containing block is made */
841 BLOCK_GCC_COMPILED (block
) = processing_gcc_compilation
;
843 /* Put the block in as the value of the symbol that names it. */
847 SYMBOL_BLOCK_VALUE (symbol
) = block
;
848 BLOCK_FUNCTION (block
) = symbol
;
851 BLOCK_FUNCTION (block
) = 0;
853 /* Now "free" the links of the list, and empty the list. */
855 for (next
= *listhead
; next
; next
= next1
)
858 next
->next
= free_pendings
;
859 free_pendings
= next
;
863 /* Install this block as the superblock
864 of all blocks made since the start of this scope
865 that don't have superblocks yet. */
868 for (pblock
= pending_blocks
; pblock
!= old_blocks
; pblock
= pblock
->next
)
870 if (BLOCK_SUPERBLOCK (pblock
->block
) == 0) {
872 /* Check to be sure the blocks are nested as we receive them.
873 If the compiler/assembler/linker work, this just burns a small
875 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
)
876 || BLOCK_END (pblock
->block
) > BLOCK_END (block
)) {
877 complain(&innerblock_complaint
, symbol
? SYMBOL_NAME (symbol
):
879 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
880 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
883 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
888 /* Record this block on the list of all blocks in the file.
889 Put it after opblock, or at the beginning if opblock is 0.
890 This puts the block in the list after all its subblocks. */
892 /* Allocate in the symbol_obstack to save time.
893 It wastes a little space. */
894 pblock
= (struct pending_block
*)
895 obstack_alloc (symbol_obstack
,
896 sizeof (struct pending_block
));
897 pblock
->block
= block
;
900 pblock
->next
= opblock
->next
;
901 opblock
->next
= pblock
;
905 pblock
->next
= pending_blocks
;
906 pending_blocks
= pblock
;
910 static struct blockvector
*
913 register struct pending_block
*next
;
914 register struct blockvector
*blockvector
;
917 /* Count the length of the list of blocks. */
919 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++);
921 blockvector
= (struct blockvector
*)
922 obstack_alloc (symbol_obstack
,
923 (sizeof (struct blockvector
)
924 + (i
- 1) * sizeof (struct block
*)));
926 /* Copy the blocks into the blockvector.
927 This is done in reverse order, which happens to put
928 the blocks into the proper order (ascending starting address).
929 finish_block has hair to insert each block into the list
930 after its subblocks in order to make sure this is true. */
932 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
933 for (next
= pending_blocks
; next
; next
= next
->next
) {
934 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
937 #if 0 /* Now we make the links in the obstack, so don't free them. */
938 /* Now free the links of the list, and empty the list. */
940 for (next
= pending_blocks
; next
; next
= next1
)
948 #if 1 /* FIXME, shut this off after a while to speed up symbol reading. */
949 /* Some compilers output blocks in the wrong order, but we depend
950 on their being in the right order so we can binary search.
951 Check the order and moan about it. FIXME. */
952 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
953 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++) {
954 if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
-1))
955 > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
))) {
956 complain (&blockvector_complaint
,
957 BLOCK_START(BLOCKVECTOR_BLOCK (blockvector
, i
)));
965 /* Manage the vector of line numbers. */
968 record_line (line
, pc
)
972 struct linetable_entry
*e
;
973 /* Ignore the dummy line number in libg.o */
978 /* Make sure line vector is big enough. */
980 if (line_vector_index
+ 1 >= line_vector_length
)
982 line_vector_length
*= 2;
983 line_vector
= (struct linetable
*)
984 xrealloc (line_vector
,
985 (sizeof (struct linetable
)
986 + line_vector_length
* sizeof (struct linetable_entry
)));
987 current_subfile
->line_vector
= line_vector
;
990 e
= line_vector
->item
+ line_vector_index
++;
991 e
->line
= line
; e
->pc
= pc
;
994 /* Start a new symtab for a new source file.
995 This is called when a dbx symbol of type N_SO is seen;
996 it indicates the start of data for one original source file. */
999 start_symtab (name
, dirname
, start_addr
)
1002 CORE_ADDR start_addr
;
1005 last_source_file
= name
;
1006 last_source_start_addr
= start_addr
;
1009 within_function
= 0;
1011 /* Context stack is initially empty, with room for 10 levels. */
1013 = (struct context_stack
*) xmalloc (10 * sizeof (struct context_stack
));
1014 context_stack_size
= 10;
1015 context_stack_depth
= 0;
1017 new_object_header_files ();
1019 type_vector_length
= 160;
1020 type_vector
= (struct typevector
*)
1021 xmalloc (sizeof (struct typevector
)
1022 + type_vector_length
* sizeof (struct type
*));
1023 bzero (type_vector
->type
, type_vector_length
* sizeof (struct type
*));
1025 /* Initialize the list of sub source files with one entry
1026 for this file (the top-level source file). */
1029 current_subfile
= 0;
1030 start_subfile (name
, dirname
);
1033 /* Handle an N_SOL symbol, which indicates the start of
1034 code that came from an included (or otherwise merged-in)
1035 source file with a different name. */
1038 start_subfile (name
, dirname
)
1042 register struct subfile
*subfile
;
1044 /* Save the current subfile's line vector data. */
1046 if (current_subfile
)
1048 current_subfile
->line_vector_index
= line_vector_index
;
1049 current_subfile
->line_vector_length
= line_vector_length
;
1050 current_subfile
->prev_line_number
= prev_line_number
;
1053 /* See if this subfile is already known as a subfile of the
1054 current main source file. */
1056 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
1058 if (!strcmp (subfile
->name
, name
))
1060 line_vector
= subfile
->line_vector
;
1061 line_vector_index
= subfile
->line_vector_index
;
1062 line_vector_length
= subfile
->line_vector_length
;
1063 prev_line_number
= subfile
->prev_line_number
;
1064 current_subfile
= subfile
;
1069 /* This subfile is not known. Add an entry for it. */
1071 line_vector_index
= 0;
1072 line_vector_length
= 1000;
1073 prev_line_number
= -2; /* Force first line number to be explicit */
1074 line_vector
= (struct linetable
*)
1075 xmalloc (sizeof (struct linetable
)
1076 + line_vector_length
* sizeof (struct linetable_entry
));
1078 /* Make an entry for this subfile in the list of all subfiles
1079 of the current main source file. */
1081 subfile
= (struct subfile
*) xmalloc (sizeof (struct subfile
));
1082 subfile
->next
= subfiles
;
1083 subfile
->name
= obsavestring (name
, strlen (name
));
1084 if (dirname
== NULL
)
1085 subfile
->dirname
= NULL
;
1087 subfile
->dirname
= obsavestring (dirname
, strlen (dirname
));
1089 subfile
->line_vector
= line_vector
;
1091 current_subfile
= subfile
;
1094 /* Finish the symbol definitions for one main source file,
1095 close off all the lexical contexts for that file
1096 (creating struct block's for them), then make the struct symtab
1097 for that file and put it in the list of all such.
1099 END_ADDR is the address of the end of the file's text. */
1102 end_symtab (end_addr
)
1105 register struct symtab
*symtab
;
1106 register struct blockvector
*blockvector
;
1107 register struct subfile
*subfile
;
1108 register struct linetable
*lv
;
1109 struct subfile
*nextsub
;
1111 /* Finish the lexical context of the last function in the file;
1112 pop the context stack. */
1114 if (context_stack_depth
> 0)
1116 register struct context_stack
*cstk
;
1117 context_stack_depth
--;
1118 cstk
= &context_stack
[context_stack_depth
];
1119 /* Make a block for the local symbols within. */
1120 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
,
1121 cstk
->start_addr
, end_addr
);
1124 /* Cleanup any undefined types that have been left hanging around
1125 (this needs to be done before the finish_blocks so that
1126 file_symbols is still good). */
1127 cleanup_undefined_types ();
1129 /* Finish defining all the blocks of this symtab. */
1130 finish_block (0, &file_symbols
, 0, last_source_start_addr
, end_addr
);
1131 finish_block (0, &global_symbols
, 0, last_source_start_addr
, end_addr
);
1132 blockvector
= make_blockvector ();
1134 current_subfile
->line_vector_index
= line_vector_index
;
1136 /* Now create the symtab objects proper, one for each subfile. */
1137 /* (The main file is one of them.) */
1139 for (subfile
= subfiles
; subfile
; subfile
= nextsub
)
1141 symtab
= (struct symtab
*) xmalloc (sizeof (struct symtab
));
1143 /* Fill in its components. */
1144 symtab
->blockvector
= blockvector
;
1145 lv
= subfile
->line_vector
;
1146 lv
->nitems
= subfile
->line_vector_index
;
1147 symtab
->linetable
= (struct linetable
*)
1148 xrealloc (lv
, (sizeof (struct linetable
)
1149 + lv
->nitems
* sizeof (struct linetable_entry
)));
1150 type_vector
->length
= type_vector_length
;
1151 symtab
->typevector
= type_vector
;
1153 symtab
->filename
= subfile
->name
;
1154 symtab
->dirname
= subfile
->dirname
;
1156 symtab
->free_code
= free_linetable
;
1157 symtab
->free_ptr
= 0;
1158 if (subfile
->next
== 0)
1159 symtab
->free_ptr
= (char *) type_vector
;
1162 symtab
->line_charpos
= 0;
1164 symtab
->language
= language_unknown
;
1165 symtab
->fullname
= NULL
;
1167 /* If there is already a symtab for a file of this name, remove it,
1168 and clear out other dependent data structures such as
1169 breakpoints. This happens in VxWorks maybe? -gnu@cygnus */
1170 free_named_symtab (symtab
->filename
);
1172 /* Link the new symtab into the list of such. */
1173 symtab
->next
= symtab_list
;
1174 symtab_list
= symtab
;
1176 nextsub
= subfile
->next
;
1181 type_vector_length
= -1;
1183 line_vector_length
= -1;
1184 last_source_file
= 0;
1187 /* Handle the N_BINCL and N_EINCL symbol types
1188 that act like N_SOL for switching source files
1189 (different subfiles, as we call them) within one object file,
1190 but using a stack rather than in an arbitrary order. */
1192 struct subfile_stack
1194 struct subfile_stack
*next
;
1199 struct subfile_stack
*subfile_stack
;
1204 register struct subfile_stack
*tem
1205 = (struct subfile_stack
*) xmalloc (sizeof (struct subfile_stack
));
1207 tem
->next
= subfile_stack
;
1208 subfile_stack
= tem
;
1209 if (current_subfile
== 0 || current_subfile
->name
== 0)
1211 tem
->name
= current_subfile
->name
;
1212 tem
->prev_index
= header_file_prev_index
;
1218 register char *name
;
1219 register struct subfile_stack
*link
= subfile_stack
;
1225 subfile_stack
= link
->next
;
1226 header_file_prev_index
= link
->prev_index
;
1233 record_misc_function (name
, address
, type
)
1238 enum misc_function_type misc_type
=
1239 (type
== (N_TEXT
| N_EXT
) ? mf_text
:
1240 (type
== (N_DATA
| N_EXT
)
1242 || type
== (N_SETV
| N_EXT
)
1244 type
== (N_BSS
| N_EXT
) ? mf_bss
:
1245 type
== (N_ABS
| N_EXT
) ? mf_abs
: mf_unknown
);
1247 prim_record_misc_function (obsavestring (name
, strlen (name
)),
1248 address
, misc_type
);
1251 /* Scan and build partial symbols for a symbol file.
1252 We have been initialized by a call to dbx_symfile_init, which
1253 put all the relevant info into a "struct dbx_symfile_info"
1254 hung off the struct sym_fns SF.
1256 ADDR is the address relative to which the symbols in it are (e.g.
1257 the base address of the text segment).
1258 MAINLINE is true if we are reading the main symbol
1259 table (as opposed to a shared lib or dynamically loaded file). */
1262 dbx_symfile_read (sf
, addr
, mainline
)
1265 int mainline
; /* FIXME comments above */
1267 struct dbx_symfile_info
*info
= (struct dbx_symfile_info
*) (sf
->sym_private
);
1268 bfd
*sym_bfd
= sf
->sym_bfd
;
1270 char *filename
= bfd_get_filename (sym_bfd
);
1272 val
= lseek (info
->desc
, info
->symtab_offset
, L_SET
);
1274 perror_with_name (filename
);
1276 /* If mainline, set global string table pointers, and reinitialize global
1277 partial symbol list. */
1279 symfile_string_table
= info
->stringtab
;
1280 symfile_string_table_size
= info
->stringtab_size
;
1281 init_psymbol_list (info
->symcount
);
1284 symfile_bfd
= sym_bfd
; /* Kludge for SWAP_SYMBOL */
1287 make_cleanup (really_free_pendings
, 0);
1289 init_misc_bunches ();
1290 make_cleanup (discard_misc_bunches
, 0);
1292 /* Now that the symbol table data of the executable file are all in core,
1293 process them and define symbols accordingly. */
1295 read_dbx_symtab (filename
,
1296 addr
- bfd_section_vma (sym_bfd
, info
->text_sect
), /*offset*/
1297 info
->desc
, info
->stringtab
, info
->stringtab_size
,
1299 bfd_section_vma (sym_bfd
, info
->text_sect
),
1300 bfd_section_size (sym_bfd
, info
->text_sect
));
1302 /* Go over the misc symbol bunches and install them in vector. */
1304 condense_misc_bunches (!mainline
);
1306 /* Free up any memory we allocated for ourselves. */
1309 free (info
->stringtab
); /* Stringtab is only saved for mainline */
1312 sf
->sym_private
= 0; /* Zap pointer to our (now gone) info struct */
1314 /* Call to select_source_symtab used to be here; it was using too
1315 much time. I'll make sure that list_sources can handle the lack
1316 of current_source_symtab */
1318 if (!partial_symtab_list
)
1319 printf_filtered ("\n(no debugging symbols found)...");
1322 /* Discard any information we have cached during the reading of a
1323 single symbol file. This should not toss global information
1324 from previous symbol files that have been read. E.g. we might
1325 be discarding info from reading a shared library, and should not
1326 throw away the info from the main file. */
1329 dbx_symfile_discard ()
1332 /* Empty the hash table of global syms looking for values. */
1333 bzero (global_sym_chain
, sizeof global_sym_chain
);
1340 /* Initialize anything that needs initializing when a completely new
1341 symbol file is specified (not just adding some symbols from another
1342 file, e.g. a shared library). */
1347 dbx_symfile_discard ();
1348 /* Don't put these on the cleanup chain; they need to stick around
1349 until the next call to symbol_file_command. *Then* we'll free
1351 if (symfile_string_table
)
1353 free (symfile_string_table
);
1354 symfile_string_table
= 0;
1355 symfile_string_table_size
= 0;
1357 free_and_init_header_files ();
1361 /* dbx_symfile_init ()
1362 is the dbx-specific initialization routine for reading symbols.
1363 It is passed a struct sym_fns which contains, among other things,
1364 the BFD for the file whose symbols are being read, and a slot for a pointer
1365 to "private data" which we fill with goodies.
1367 We read the string table into malloc'd space and stash a pointer to it.
1369 Since BFD doesn't know how to read debug symbols in a format-independent
1370 way (and may never do so...), we have to do it ourselves. We will never
1371 be called unless this is an a.out (or very similar) file.
1372 FIXME, there should be a cleaner peephole into the BFD environment here. */
1375 dbx_symfile_init (sf
)
1380 struct stat statbuf
;
1381 bfd
*sym_bfd
= sf
->sym_bfd
;
1382 char *name
= bfd_get_filename (sym_bfd
);
1383 struct dbx_symfile_info
*info
;
1384 unsigned char size_temp
[4];
1386 /* Allocate struct to keep track of the symfile */
1387 sf
->sym_private
= xmalloc (sizeof (*info
)); /* FIXME storage leak */
1388 info
= (struct dbx_symfile_info
*)sf
->sym_private
;
1390 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
1391 desc
= fileno ((FILE *)(sym_bfd
->iostream
)); /* Raw file descriptor */
1392 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
1393 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
1394 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
1397 info
->text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
1398 if (!info
->text_sect
)
1400 info
->symcount
= bfd_get_symcount_upper_bound(sym_bfd
); /* It's exact for a.out */
1402 /* Read the string table size and check it for bogosity. */
1403 val
= lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
1405 perror_with_name (name
);
1406 if (fstat (desc
, &statbuf
) == -1)
1407 perror_with_name (name
);
1409 val
= myread (desc
, size_temp
, sizeof (long));
1411 perror_with_name (name
);
1412 info
->stringtab_size
= bfd_h_getlong (sym_bfd
, size_temp
);
1414 if (info
->stringtab_size
>= 0 && info
->stringtab_size
< statbuf
.st_size
)
1416 info
->stringtab
= (char *) xmalloc (info
->stringtab_size
);
1417 /* Caller is responsible for freeing the string table. No cleanup. */
1420 info
->stringtab
= NULL
;
1421 if (info
->stringtab
== NULL
&& info
->stringtab_size
!= 0)
1422 error ("ridiculous string table size: %d bytes", info
->stringtab_size
);
1424 /* Now read in the string table in one big gulp. */
1426 val
= lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
1428 perror_with_name (name
);
1429 val
= myread (desc
, info
->stringtab
, info
->stringtab_size
);
1431 perror_with_name (name
);
1433 /* Record the position of the symbol table for later use. */
1435 info
->symtab_offset
= SYMBOL_TABLE_OFFSET
;
1438 /* Buffer for reading the symbol table entries. */
1439 static struct nlist symbuf
[4096];
1440 static int symbuf_idx
;
1441 static int symbuf_end
;
1443 /* I/O descriptor for reading the symbol table. */
1444 static int symtab_input_desc
;
1446 /* The address in memory of the string table of the object file we are
1447 reading (which might not be the "main" object file, but might be a
1448 shared library or some other dynamically loaded thing). This is set
1449 by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
1450 when building symtabs, and is used only by next_symbol_text. */
1451 static char *stringtab_global
;
1453 /* Refill the symbol table input buffer
1454 and set the variables that control fetching entries from it.
1455 Reports an error if no data available.
1456 This function can read past the end of the symbol table
1457 (into the string table) but this does no harm. */
1462 int nbytes
= myread (symtab_input_desc
, symbuf
, sizeof (symbuf
));
1464 perror_with_name ("<symbol file>");
1465 else if (nbytes
== 0)
1466 error ("Premature end of file reading symbol table");
1467 symbuf_end
= nbytes
/ sizeof (struct nlist
);
1472 #define SWAP_SYMBOL(symp) \
1474 (symp)->n_un.n_strx = bfd_h_getlong(symfile_bfd, \
1475 (unsigned char *)&(symp)->n_un.n_strx); \
1476 (symp)->n_desc = bfd_h_getshort (symfile_bfd, \
1477 (unsigned char *)&(symp)->n_desc); \
1478 (symp)->n_value = bfd_h_getlong (symfile_bfd, \
1479 (unsigned char *)&(symp)->n_value); \
1482 /* Invariant: The symbol pointed to by symbuf_idx is the first one
1483 that hasn't been swapped. Swap the symbol at the same time
1484 that symbuf_idx is incremented. */
1486 /* dbx allows the text of a symbol name to be continued into the
1487 next symbol name! When such a continuation is encountered
1488 (a \ at the end of the text of a name)
1489 call this function to get the continuation. */
1494 if (symbuf_idx
== symbuf_end
)
1497 SWAP_SYMBOL(&symbuf
[symbuf_idx
]);
1498 return symbuf
[symbuf_idx
++].n_un
.n_strx
+ stringtab_global
;
1501 /* Initializes storage for all of the partial symbols that will be
1502 created by read_dbx_symtab and subsidiaries. */
1505 init_psymbol_list (total_symbols
)
1508 /* Free any previously allocated psymbol lists. */
1509 if (global_psymbols
.list
)
1510 free (global_psymbols
.list
);
1511 if (static_psymbols
.list
)
1512 free (static_psymbols
.list
);
1514 /* Current best guess is that there are approximately a twentieth
1515 of the total symbols (in a debugging file) are global or static
1517 global_psymbols
.size
= total_symbols
/ 10;
1518 static_psymbols
.size
= total_symbols
/ 10;
1519 global_psymbols
.next
= global_psymbols
.list
= (struct partial_symbol
*)
1520 xmalloc (global_psymbols
.size
* sizeof (struct partial_symbol
));
1521 static_psymbols
.next
= static_psymbols
.list
= (struct partial_symbol
*)
1522 xmalloc (static_psymbols
.size
* sizeof (struct partial_symbol
));
1525 /* Initialize the list of bincls to contain none and have some
1529 init_bincl_list (number
)
1532 bincls_allocated
= number
;
1533 next_bincl
= bincl_list
= (struct header_file_location
*)
1534 xmalloc (bincls_allocated
* sizeof(struct header_file_location
));
1537 /* Add a bincl to the list. */
1540 add_bincl_to_list (pst
, name
, instance
)
1541 struct partial_symtab
*pst
;
1545 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1547 int offset
= next_bincl
- bincl_list
;
1548 bincls_allocated
*= 2;
1549 bincl_list
= (struct header_file_location
*)
1550 xrealloc ((char *)bincl_list
,
1551 bincls_allocated
* sizeof (struct header_file_location
));
1552 next_bincl
= bincl_list
+ offset
;
1554 next_bincl
->pst
= pst
;
1555 next_bincl
->instance
= instance
;
1556 next_bincl
++->name
= name
;
1559 /* Given a name, value pair, find the corresponding
1560 bincl in the list. Return the partial symtab associated
1561 with that header_file_location. */
1563 struct partial_symtab
*
1564 find_corresponding_bincl_psymtab (name
, instance
)
1568 struct header_file_location
*bincl
;
1570 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1571 if (bincl
->instance
== instance
1572 && !strcmp (name
, bincl
->name
))
1575 return (struct partial_symtab
*) 0;
1578 /* Free the storage allocated for the bincl list. */
1584 bincls_allocated
= 0;
1587 static struct partial_symtab
*start_psymtab ();
1588 static void end_psymtab();
1591 /* This is normally a macro defined in read_dbx_symtab, but this
1592 is a lot easier to debug. */
1594 ADD_PSYMBOL_TO_PLIST(NAME
, NAMELENGTH
, NAMESPACE
, CLASS
, PLIST
, VALUE
)
1597 enum namespace NAMESPACE
;
1598 enum address_class CLASS
;
1599 struct psymbol_allocation_list
*PLIST
;
1600 unsigned long VALUE
;
1602 register struct partial_symbol
*psym
;
1607 (LIST
).list
+ (LIST
).size
)
1609 (LIST
).list
= (struct partial_symbol
*)
1610 xrealloc ((LIST
).list
,
1612 * sizeof (struct partial_symbol
)));
1613 /* Next assumes we only went one over. Should be good if
1614 program works correctly */
1616 (LIST
).list
+ (LIST
).size
;
1619 psym
= (LIST
).next
++;
1622 SYMBOL_NAME (psym
) = (char *) obstack_alloc (psymbol_obstack
,
1624 strncpy (SYMBOL_NAME (psym
), (NAME
), (NAMELENGTH
));
1625 SYMBOL_NAME (psym
)[(NAMELENGTH
)] = '\0';
1626 SYMBOL_NAMESPACE (psym
) = (NAMESPACE
);
1627 SYMBOL_CLASS (psym
) = (CLASS
);
1628 SYMBOL_VALUE (psym
) = (VALUE
);
1632 /* Since one arg is a struct, we have to pass in a ptr and deref it (sigh) */
1633 #define ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
1634 ADD_PSYMBOL_TO_PLIST(NAME, NAMELENGTH, NAMESPACE, CLASS, &LIST, VALUE)
1638 /* Given pointers to an a.out symbol table in core containing dbx
1639 style data, setup partial_symtab's describing each source file for
1640 which debugging information is available. NLISTLEN is the number
1641 of symbols in the symbol table. All symbol names are given as
1642 offsets relative to STRINGTAB. STRINGTAB_SIZE is the size of
1643 STRINGTAB. SYMFILE_NAME is the name of the file we are reading from
1644 and ADDR is its relocated address (if incremental) or 0 (if not). */
1647 read_dbx_symtab (symfile_name
, addr
,
1648 desc
, stringtab
, stringtab_size
, nlistlen
,
1649 text_addr
, text_size
)
1653 register char *stringtab
;
1654 register long stringtab_size
;
1655 register int nlistlen
;
1656 CORE_ADDR text_addr
;
1659 register struct nlist
*bufp
;
1660 register char *namestring
;
1661 register struct partial_symbol
*psym
;
1663 int past_first_source_file
= 0;
1664 CORE_ADDR last_o_file_start
= 0;
1665 struct cleanup
*old_chain
;
1668 /* End of the text segment of the executable file. */
1669 CORE_ADDR end_of_text_addr
;
1671 /* Current partial symtab */
1672 struct partial_symtab
*pst
;
1674 /* List of current psymtab's include files */
1675 char **psymtab_include_list
;
1676 int includes_allocated
;
1679 /* Index within current psymtab dependency list */
1680 struct partial_symtab
**dependency_list
;
1681 int dependencies_used
, dependencies_allocated
;
1683 stringtab_global
= stringtab
;
1685 pst
= (struct partial_symtab
*) 0;
1687 includes_allocated
= 30;
1689 psymtab_include_list
= (char **) alloca (includes_allocated
*
1692 dependencies_allocated
= 30;
1693 dependencies_used
= 0;
1695 (struct partial_symtab
**) alloca (dependencies_allocated
*
1696 sizeof (struct partial_symtab
*));
1698 /* FIXME!! If an error occurs, this blows away the whole symbol table!
1699 It should only blow away the psymtabs created herein. We could
1700 be reading a shared library or a dynloaded file! */
1701 old_chain
= make_cleanup (free_all_psymtabs
, 0);
1703 /* Init bincl list */
1704 init_bincl_list (20);
1705 make_cleanup (free_bincl_list
, 0);
1707 last_source_file
= 0;
1709 #ifdef END_OF_TEXT_DEFAULT
1710 end_of_text_addr
= END_OF_TEXT_DEFAULT
;
1712 end_of_text_addr
= addr
+ text_size
;
1715 symtab_input_desc
= desc
; /* This is needed for fill_symbuf below */
1716 symbuf_end
= symbuf_idx
= 0;
1718 for (symnum
= 0; symnum
< nlistlen
; symnum
++)
1720 /* Get the symbol for this run and pull out some info */
1721 QUIT
; /* allow this to be interruptable */
1722 if (symbuf_idx
== symbuf_end
)
1724 bufp
= &symbuf
[symbuf_idx
++];
1727 * Special case to speed up readin.
1729 if (bufp
->n_type
== (unsigned char)N_SLINE
) continue;
1733 /* Ok. There is a lot of code duplicated in the rest of this
1734 switch statement (for efficiency reasons). Since I don't
1735 like duplicating code, I will do my penance here, and
1736 describe the code which is duplicated:
1738 *) The assignment to namestring.
1739 *) The call to strchr.
1740 *) The addition of a partial symbol the the two partial
1741 symbol lists. This last is a large section of code, so
1742 I've imbedded it in the following macro.
1745 /* Set namestring based on bufp. If the string table index is invalid,
1746 give a fake name, and print a single error message per symbol file read,
1747 rather than abort the symbol reading or flood the user with messages. */
1748 #define SET_NAMESTRING()\
1749 if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size) { \
1750 complain (&string_table_offset_complaint, symnum); \
1751 namestring = "foo"; \
1753 namestring = bufp->n_un.n_strx + stringtab
1755 /* Add a symbol with an integer value to a psymtab. */
1756 /* This is a macro unless we're debugging. See above this function. */
1758 # define ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
1759 ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, \
1763 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1764 #define ADD_PSYMBOL_ADDR_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
1765 ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, \
1766 SYMBOL_VALUE_ADDRESS)
1768 /* Add any kind of symbol to a psymtab. */
1769 #define ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, VT)\
1771 if ((LIST).next >= \
1772 (LIST).list + (LIST).size) \
1774 (LIST).list = (struct partial_symbol *) \
1775 xrealloc ((LIST).list, \
1777 * sizeof (struct partial_symbol))); \
1778 /* Next assumes we only went one over. Should be good if \
1779 program works correctly */ \
1781 (LIST).list + (LIST).size; \
1784 psym = (LIST).next++; \
1786 SYMBOL_NAME (psym) = (char *) obstack_alloc (psymbol_obstack, \
1787 (NAMELENGTH) + 1); \
1788 strncpy (SYMBOL_NAME (psym), (NAME), (NAMELENGTH)); \
1789 SYMBOL_NAME (psym)[(NAMELENGTH)] = '\0'; \
1790 SYMBOL_NAMESPACE (psym) = (NAMESPACE); \
1791 SYMBOL_CLASS (psym) = (CLASS); \
1792 VT (psym) = (VALUE); \
1795 /* End of macro definitions, now let's handle them symbols! */
1797 switch (bufp
->n_type
)
1800 * Standard, external, non-debugger, symbols
1803 case N_TEXT
| N_EXT
:
1804 case N_NBTEXT
| N_EXT
:
1805 case N_NBDATA
| N_EXT
:
1806 case N_NBBSS
| N_EXT
:
1807 case N_SETV
| N_EXT
:
1809 case N_DATA
| N_EXT
:
1812 bufp
->n_value
+= addr
; /* Relocate */
1817 record_misc_function (namestring
, bufp
->n_value
,
1818 bufp
->n_type
); /* Always */
1822 /* Standard, local, non-debugger, symbols */
1826 /* We need to be able to deal with both N_FN or N_TEXT,
1827 because we have no way of knowing whether the sys-supplied ld
1828 or GNU ld was used to make the executable. */
1829 #if ! (N_FN & N_EXT)
1834 bufp
->n_value
+= addr
; /* Relocate */
1836 if ((namestring
[0] == '-' && namestring
[1] == 'l')
1837 || (namestring
[(nsl
= strlen (namestring
)) - 1] == 'o'
1838 && namestring
[nsl
- 2] == '.'))
1840 if (entry_point
< bufp
->n_value
1841 && entry_point
>= last_o_file_start
1842 && addr
== 0) /* FIXME nogood nomore */
1844 startup_file_start
= last_o_file_start
;
1845 startup_file_end
= bufp
->n_value
;
1847 if (past_first_source_file
&& pst
1848 /* The gould NP1 uses low values for .o and -l symbols
1849 which are not the address. */
1850 && bufp
->n_value
> pst
->textlow
)
1852 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1853 symnum
* sizeof (struct nlist
), bufp
->n_value
,
1854 dependency_list
, dependencies_used
,
1855 global_psymbols
.next
, static_psymbols
.next
);
1856 pst
= (struct partial_symtab
*) 0;
1858 dependencies_used
= 0;
1861 past_first_source_file
= 1;
1862 last_o_file_start
= bufp
->n_value
;
1867 bufp
->n_value
+= addr
; /* Relocate */
1869 /* Check for __DYNAMIC, which is used by Sun shared libraries.
1870 Record it even if it's local, not global, so we can find it. */
1871 if (namestring
[8] == 'C' && (strcmp ("__DYNAMIC", namestring
) == 0))
1873 /* Not really a function here, but... */
1874 record_misc_function (namestring
, bufp
->n_value
,
1875 bufp
->n_type
); /* Always */
1879 case N_UNDF
| N_EXT
:
1880 if (bufp
->n_value
!= 0) {
1881 /* This is a "Fortran COMMON" symbol. See if the target
1882 environment knows where it has been relocated to. */
1887 if (target_lookup_symbol (namestring
, &reladdr
)) {
1888 continue; /* Error in lookup; ignore symbol for now. */
1890 bufp
->n_type
^= (N_BSS
^N_UNDF
); /* Define it as a bss-symbol */
1891 bufp
->n_value
= reladdr
;
1892 goto bss_ext_symbol
;
1894 continue; /* Just undefined, not COMMON */
1896 /* Lots of symbol types we can just ignore. */
1905 /* Keep going . . .*/
1908 * Special symbol types for GNU
1911 case N_INDR
| N_EXT
:
1913 case N_SETA
| N_EXT
:
1915 case N_SETT
| N_EXT
:
1917 case N_SETD
| N_EXT
:
1919 case N_SETB
| N_EXT
:
1928 unsigned long valu
= bufp
->n_value
;
1929 /* Symbol number of the first symbol of this file (i.e. the N_SO
1930 if there is just one, or the first if we have a pair). */
1931 int first_symnum
= symnum
;
1933 /* End the current partial symtab and start a new one */
1937 /* Peek at the next symbol. If it is also an N_SO, the
1938 first one just indicates the directory. */
1939 if (symbuf_idx
== symbuf_end
)
1941 bufp
= &symbuf
[symbuf_idx
];
1942 /* n_type is only a char, so swapping swapping is irrelevant. */
1943 if (bufp
->n_type
== (unsigned char)N_SO
)
1947 valu
= bufp
->n_value
;
1951 valu
+= addr
; /* Relocate */
1953 if (pst
&& past_first_source_file
)
1955 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1956 first_symnum
* sizeof (struct nlist
), valu
,
1957 dependency_list
, dependencies_used
,
1958 global_psymbols
.next
, static_psymbols
.next
);
1959 pst
= (struct partial_symtab
*) 0;
1961 dependencies_used
= 0;
1964 past_first_source_file
= 1;
1966 pst
= start_psymtab (symfile_name
, addr
,
1968 first_symnum
* sizeof (struct nlist
),
1969 global_psymbols
.next
, static_psymbols
.next
);
1975 /* Add this bincl to the bincl_list for future EXCLs. No
1976 need to save the string; it'll be around until
1977 read_dbx_symtab function returns */
1981 add_bincl_to_list (pst
, namestring
, bufp
->n_value
);
1983 /* Mark down an include file in the current psymtab */
1985 psymtab_include_list
[includes_used
++] = namestring
;
1986 if (includes_used
>= includes_allocated
)
1988 char **orig
= psymtab_include_list
;
1990 psymtab_include_list
= (char **)
1991 alloca ((includes_allocated
*= 2) *
1993 bcopy (orig
, psymtab_include_list
,
1994 includes_used
* sizeof (char *));
2000 /* Mark down an include file in the current psymtab */
2004 /* In C++, one may expect the same filename to come round many
2005 times, when code is coming alternately from the main file
2006 and from inline functions in other files. So I check to see
2007 if this is a file we've seen before.
2009 This seems to be a lot of time to be spending on N_SOL, but
2010 things like "break expread.y:435" need to work (I
2011 suppose the psymtab_include_list could be hashed or put
2012 in a binary tree, if profiling shows this is a major hog). */
2015 for (i
= 0; i
< includes_used
; i
++)
2016 if (!strcmp (namestring
, psymtab_include_list
[i
]))
2025 psymtab_include_list
[includes_used
++] = namestring
;
2026 if (includes_used
>= includes_allocated
)
2028 char **orig
= psymtab_include_list
;
2030 psymtab_include_list
= (char **)
2031 alloca ((includes_allocated
*= 2) *
2033 bcopy (orig
, psymtab_include_list
,
2034 includes_used
* sizeof (char *));
2038 case N_LSYM
: /* Typedef or automatic variable. */
2041 p
= (char *) strchr (namestring
, ':');
2043 /* Skip if there is no :. */
2049 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2050 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2051 static_psymbols
, bufp
->n_value
);
2054 /* Also a typedef with the same name. */
2055 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2056 VAR_NAMESPACE
, LOC_TYPEDEF
,
2057 static_psymbols
, bufp
->n_value
);
2062 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2063 VAR_NAMESPACE
, LOC_TYPEDEF
,
2064 static_psymbols
, bufp
->n_value
);
2066 /* If this is an enumerated type, we need to
2067 add all the enum constants to the partial symbol
2068 table. This does not cover enums without names, e.g.
2069 "enum {a, b} c;" in C, but fortunately those are
2070 rare. There is no way for GDB to find those from the
2071 enum type without spending too much time on it. Thus
2072 to solve this problem, the compiler needs to put out separate
2073 constant symbols ('c' N_LSYMS) for enum constants in
2074 enums without names, or put out a dummy type. */
2076 /* We are looking for something of the form
2077 <name> ":" ("t" | "T") [<number> "="] "e"
2078 {<constant> ":" <value> ","} ";". */
2080 /* Skip over the colon and the 't' or 'T'. */
2082 /* This type may be given a number. Skip over it. */
2083 while ((*p
>= '0' && *p
<= '9')
2089 /* We have found an enumerated type. */
2090 /* According to comments in read_enum_type
2091 a comma could end it instead of a semicolon.
2092 I don't know where that happens.
2094 while (*p
&& *p
!= ';' && *p
!= ',')
2098 /* Check for and handle cretinous dbx symbol name
2101 p
= next_symbol_text ();
2103 /* Point to the character after the name
2104 of the enum constant. */
2105 for (q
= p
; *q
&& *q
!= ':'; q
++)
2107 /* Note that the value doesn't matter for
2108 enum constants in psymtabs, just in symtabs. */
2109 ADD_PSYMBOL_TO_LIST (p
, q
- p
,
2110 VAR_NAMESPACE
, LOC_CONST
,
2111 static_psymbols
, 0);
2112 /* Point past the name. */
2114 /* Skip over the value. */
2115 while (*p
&& *p
!= ',')
2117 /* Advance past the comma. */
2125 /* Constant, e.g. from "const" in Pascal. */
2126 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2127 VAR_NAMESPACE
, LOC_CONST
,
2128 static_psymbols
, bufp
->n_value
);
2131 /* Skip if the thing following the : is
2132 not a letter (which indicates declaration of a local
2133 variable, which we aren't interested in). */
2138 case N_GSYM
: /* Global (extern) variable; can be
2139 data or bss (sigh). */
2140 case N_STSYM
: /* Data seg var -- static */
2141 case N_LCSYM
: /* BSS " */
2143 case N_NBSTS
: /* Gould nobase. */
2144 case N_NBLCS
: /* symbols. */
2146 /* Following may probably be ignored; I'll leave them here
2147 for now (until I do Pascal and Modula 2 extensions). */
2149 case N_PC
: /* I may or may not need this; I
2151 case N_M2C
: /* I suspect that I can ignore this here. */
2152 case N_SCOPE
: /* Same. */
2156 p
= (char *) strchr (namestring
, ':');
2158 continue; /* Not a debugging symbol. */
2162 /* Main processing section for debugging symbols which
2163 the initial read through the symbol tables needs to worry
2164 about. If we reach this point, the symbol which we are
2165 considering is definitely one we are interested in.
2166 p must also contain the (valid) index into the namestring
2167 which indicates the debugging type symbol. */
2172 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2173 VAR_NAMESPACE
, LOC_CONST
,
2174 static_psymbols
, bufp
->n_value
);
2177 bufp
->n_value
+= addr
; /* Relocate */
2178 ADD_PSYMBOL_ADDR_TO_LIST (namestring
, p
- namestring
,
2179 VAR_NAMESPACE
, LOC_STATIC
,
2180 static_psymbols
, bufp
->n_value
);
2183 bufp
->n_value
+= addr
; /* Relocate */
2184 ADD_PSYMBOL_ADDR_TO_LIST (namestring
, p
- namestring
,
2185 VAR_NAMESPACE
, LOC_EXTERNAL
,
2186 global_psymbols
, bufp
->n_value
);
2190 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2191 VAR_NAMESPACE
, LOC_TYPEDEF
,
2192 global_psymbols
, bufp
->n_value
);
2196 ADD_PSYMBOL_TO_LIST (namestring
, p
- namestring
,
2197 VAR_NAMESPACE
, LOC_BLOCK
,
2198 static_psymbols
, bufp
->n_value
);
2201 /* Two things show up here (hopefully); static symbols of
2202 local scope (static used inside braces) or extensions
2203 of structure symbols. We can ignore both. */
2216 /* Global functions are ignored here. I'm not
2217 sure what psymtab they go into (or just the misc
2218 function vector). */
2223 /* Unexpected symbol. Ignore it; perhaps it is an extension
2224 that we don't know about.
2226 Someone says sun cc puts out symbols like
2227 /foo/baz/maclib::/usr/local/bin/maclib,
2228 which would get here with a symbol type of ':'. */
2236 /* Find the corresponding bincl and mark that psymtab on the
2237 psymtab dependency list */
2239 struct partial_symtab
*needed_pst
=
2240 find_corresponding_bincl_psymtab (namestring
, bufp
->n_value
);
2242 /* If this include file was defined earlier in this file,
2244 if (needed_pst
== pst
) continue;
2251 for (i
= 0; i
< dependencies_used
; i
++)
2252 if (dependency_list
[i
] == needed_pst
)
2258 /* If it's already in the list, skip the rest. */
2259 if (found
) continue;
2261 dependency_list
[dependencies_used
++] = needed_pst
;
2262 if (dependencies_used
>= dependencies_allocated
)
2264 struct partial_symtab
**orig
= dependency_list
;
2266 (struct partial_symtab
**)
2267 alloca ((dependencies_allocated
*= 2)
2268 * sizeof (struct partial_symtab
*));
2269 bcopy (orig
, dependency_list
,
2271 * sizeof (struct partial_symtab
*)));
2273 fprintf (stderr
, "Had to reallocate dependency list.\n");
2274 fprintf (stderr
, "New dependencies allocated: %d\n",
2275 dependencies_allocated
);
2280 error ("Invalid symbol data: \"repeated\" header file not previously seen, at symtab pos %d.",
2288 case N_SSYM
: /* Claim: Structure or union element.
2289 Hopefully, I can ignore this. */
2290 case N_ENTRY
: /* Alternate entry point; can ignore. */
2291 case N_MAIN
: /* Can definitely ignore this. */
2292 case N_CATCH
: /* These are GNU C++ extensions */
2293 case N_EHDECL
: /* that can safely be ignored here. */
2304 case N_NSYMS
: /* Ultrix 4.0: symbol count */
2305 /* These symbols aren't interesting; don't worry about them */
2310 /* If we haven't found it yet, ignore it. It's probably some
2311 new type we don't know about yet. */
2312 complain (&unknown_symtype_complaint
, bufp
->n_type
);
2317 /* If there's stuff to be cleaned up, clean it up. */
2318 if (entry_point
< bufp
->n_value
2319 && entry_point
>= last_o_file_start
)
2321 startup_file_start
= last_o_file_start
;
2322 startup_file_end
= bufp
->n_value
;
2327 end_psymtab (pst
, psymtab_include_list
, includes_used
,
2328 symnum
* sizeof (struct nlist
), end_of_text_addr
,
2329 dependency_list
, dependencies_used
,
2330 global_psymbols
.next
, static_psymbols
.next
);
2332 dependencies_used
= 0;
2333 pst
= (struct partial_symtab
*) 0;
2337 discard_cleanups (old_chain
);
2341 * Allocate and partially fill a partial symtab. It will be
2342 * completely filled at the end of the symbol list.
2344 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2345 is the address relative to which its symbols are (incremental) or 0
2347 static struct partial_symtab
*
2348 start_psymtab (symfile_name
, addr
,
2349 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
2355 struct partial_symbol
*global_syms
;
2356 struct partial_symbol
*static_syms
;
2358 struct partial_symtab
*result
=
2359 (struct partial_symtab
*) obstack_alloc (psymbol_obstack
,
2360 sizeof (struct partial_symtab
));
2362 result
->addr
= addr
;
2364 result
->symfile_name
=
2365 (char *) obstack_alloc (psymbol_obstack
,
2366 strlen (symfile_name
) + 1);
2367 strcpy (result
->symfile_name
, symfile_name
);
2370 (char *) obstack_alloc (psymbol_obstack
,
2371 strlen (filename
) + 1);
2372 strcpy (result
->filename
, filename
);
2374 result
->textlow
= textlow
;
2375 result
->ldsymoff
= ldsymoff
;
2379 result
->read_symtab
= dbx_psymtab_to_symtab
;
2381 result
->globals_offset
= global_syms
- global_psymbols
.list
;
2382 result
->statics_offset
= static_syms
- static_psymbols
.list
;
2384 result
->n_global_syms
= 0;
2385 result
->n_static_syms
= 0;
2392 compare_psymbols (s1
, s2
)
2393 register struct partial_symbol
*s1
, *s2
;
2396 *st1
= SYMBOL_NAME (s1
),
2397 *st2
= SYMBOL_NAME (s2
);
2399 return (st1
[0] - st2
[0] ? st1
[0] - st2
[0] :
2400 strcmp (st1
+ 1, st2
+ 1));
2404 /* Close off the current usage of a partial_symbol table entry. This
2405 involves setting the correct number of includes (with a realloc),
2406 setting the high text mark, setting the symbol length in the
2407 executable, and setting the length of the global and static lists
2410 The global symbols and static symbols are then seperately sorted.
2412 Then the partial symtab is put on the global list.
2413 *** List variables and peculiarities of same. ***
2416 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
2417 capping_text
, dependency_list
, number_dependencies
,
2418 capping_global
, capping_static
)
2419 struct partial_symtab
*pst
;
2420 char **include_list
;
2422 int capping_symbol_offset
;
2423 CORE_ADDR capping_text
;
2424 struct partial_symtab
**dependency_list
;
2425 int number_dependencies
;
2426 struct partial_symbol
*capping_global
, *capping_static
;
2430 pst
->ldsymlen
= capping_symbol_offset
- pst
->ldsymoff
;
2431 pst
->texthigh
= capping_text
;
2433 pst
->n_global_syms
=
2434 capping_global
- (global_psymbols
.list
+ pst
->globals_offset
);
2435 pst
->n_static_syms
=
2436 capping_static
- (static_psymbols
.list
+ pst
->statics_offset
);
2438 pst
->number_of_dependencies
= number_dependencies
;
2439 if (number_dependencies
)
2441 pst
->dependencies
= (struct partial_symtab
**)
2442 obstack_alloc (psymbol_obstack
,
2443 number_dependencies
* sizeof (struct partial_symtab
*));
2444 bcopy (dependency_list
, pst
->dependencies
,
2445 number_dependencies
* sizeof (struct partial_symtab
*));
2448 pst
->dependencies
= 0;
2450 for (i
= 0; i
< num_includes
; i
++)
2452 /* Eventually, put this on obstack */
2453 struct partial_symtab
*subpst
=
2454 (struct partial_symtab
*)
2455 obstack_alloc (psymbol_obstack
,
2456 sizeof (struct partial_symtab
));
2459 (char *) obstack_alloc (psymbol_obstack
,
2460 strlen (include_list
[i
]) + 1);
2461 strcpy (subpst
->filename
, include_list
[i
]);
2463 subpst
->symfile_name
= pst
->symfile_name
;
2464 subpst
->addr
= pst
->addr
;
2468 subpst
->texthigh
= 0;
2470 subpst
->dependencies
= (struct partial_symtab
**)
2471 obstack_alloc (psymbol_obstack
,
2472 sizeof (struct partial_symtab
*));
2473 subpst
->dependencies
[0] = pst
;
2474 subpst
->number_of_dependencies
= 1;
2476 subpst
->globals_offset
=
2477 subpst
->n_global_syms
=
2478 subpst
->statics_offset
=
2479 subpst
->n_static_syms
= 0;
2482 subpst
->read_symtab
= dbx_psymtab_to_symtab
;
2484 subpst
->next
= partial_symtab_list
;
2485 partial_symtab_list
= subpst
;
2488 /* Sort the global list; don't sort the static list */
2489 qsort (global_psymbols
.list
+ pst
->globals_offset
, pst
->n_global_syms
,
2490 sizeof (struct partial_symbol
), compare_psymbols
);
2492 /* Put the psymtab on the psymtab list */
2493 pst
->next
= partial_symtab_list
;
2494 partial_symtab_list
= pst
;
2498 psymtab_to_symtab_1 (pst
, desc
, stringtab
, stringtab_size
, sym_offset
)
2499 struct partial_symtab
*pst
;
2505 struct cleanup
*old_chain
;
2513 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2518 /* Read in all partial symbtabs on which this one is dependent */
2519 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2520 if (!pst
->dependencies
[i
]->readin
)
2522 /* Inform about additional files that need to be read in. */
2525 fputs_filtered (" ", stdout
);
2527 fputs_filtered ("and ", stdout
);
2529 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2530 wrap_here (""); /* Flush output */
2533 psymtab_to_symtab_1 (pst
->dependencies
[i
], desc
,
2534 stringtab
, stringtab_size
, sym_offset
);
2537 if (pst
->ldsymlen
) /* Otherwise it's a dummy */
2539 /* Init stuff necessary for reading in symbols */
2544 old_chain
= make_cleanup (really_free_pendings
, 0);
2546 /* Read in this files symbols */
2547 lseek (desc
, sym_offset
, L_SET
);
2548 read_ofile_symtab (desc
, stringtab
, stringtab_size
,
2550 pst
->ldsymlen
, pst
->textlow
,
2551 pst
->texthigh
- pst
->textlow
, pst
->addr
);
2552 sort_symtab_syms (symtab_list
); /* At beginning since just added */
2554 do_cleanups (old_chain
);
2561 * Read in all of the symbols for a given psymtab for real.
2562 * Be verbose about it if the user wants that.
2565 dbx_psymtab_to_symtab (pst
)
2566 struct partial_symtab
*pst
;
2571 struct stat statbuf
;
2572 struct cleanup
*old_chain
;
2581 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
2586 if (pst
->ldsymlen
|| pst
->number_of_dependencies
)
2588 /* Print the message now, before reading the string table,
2589 to avoid disconcerting pauses. */
2592 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
2596 /* Open symbol file and read in string table. Symbol_file_command
2597 guarantees that the symbol file name will be absolute, so there is
2598 no need for openp. */
2599 desc
= open(pst
->symfile_name
, O_RDONLY
, 0);
2602 perror_with_name (pst
->symfile_name
);
2604 sym_bfd
= bfd_fdopenr (pst
->symfile_name
, NULL
, desc
);
2608 error ("Could not open `%s' to read symbols: %s",
2609 pst
->symfile_name
, bfd_errmsg (bfd_error
));
2611 old_chain
= make_cleanup (bfd_close
, sym_bfd
);
2612 if (!bfd_check_format (sym_bfd
, bfd_object
))
2613 error ("\"%s\": can't read symbols: %s.",
2614 pst
->symfile_name
, bfd_errmsg (bfd_error
));
2616 /* We keep the string table for symfile resident in memory, but
2617 not the string table for any other symbol files. */
2618 if (0 != strcmp(pst
->symfile_name
, symfile
))
2620 /* Read in the string table */
2622 /* FIXME, this uses internal BFD variables. See above in
2623 dbx_symbol_file_open where the macro is defined! */
2624 lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
2626 val
= myread (desc
, &st_temp
, sizeof st_temp
);
2628 perror_with_name (pst
->symfile_name
);
2629 stsize
= bfd_h_getlong (sym_bfd
, (unsigned char *)&st_temp
);
2630 if (fstat (desc
, &statbuf
) < 0)
2631 perror_with_name (pst
->symfile_name
);
2633 if (stsize
>= 0 && stsize
< statbuf
.st_size
)
2635 #ifdef BROKEN_LARGE_ALLOCA
2636 stringtab
= (char *) xmalloc (stsize
);
2637 make_cleanup (free
, stringtab
);
2639 stringtab
= (char *) alloca (stsize
);
2644 if (stringtab
== NULL
&& stsize
!= 0)
2645 error ("ridiculous string table size: %d bytes", stsize
);
2647 /* FIXME, this uses internal BFD variables. See above in
2648 dbx_symbol_file_open where the macro is defined! */
2649 val
= lseek (desc
, STRING_TABLE_OFFSET
, L_SET
);
2651 perror_with_name (pst
->symfile_name
);
2652 val
= myread (desc
, stringtab
, stsize
);
2654 perror_with_name (pst
->symfile_name
);
2658 stringtab
= symfile_string_table
;
2659 stsize
= symfile_string_table_size
;
2662 symfile_bfd
= sym_bfd
; /* Kludge for SWAP_SYMBOL */
2664 /* FIXME, this uses internal BFD variables. See above in
2665 dbx_symbol_file_open where the macro is defined! */
2666 psymtab_to_symtab_1 (pst
, desc
, stringtab
, stsize
,
2667 SYMBOL_TABLE_OFFSET
);
2669 /* Match with global symbols. This only needs to be done once,
2670 after all of the symtabs and dependencies have been read in. */
2671 scan_file_globals ();
2673 do_cleanups (old_chain
);
2675 /* Finish up the debug error message. */
2677 printf_filtered ("done.\n");
2682 * Scan through all of the global symbols defined in the object file,
2683 * assigning values to the debugging symbols that need to be assigned
2684 * to. Get these symbols from the misc function list.
2687 scan_file_globals ()
2692 for (mf
= 0; mf
< misc_function_count
; mf
++)
2694 char *namestring
= misc_function_vector
[mf
].name
;
2695 struct symbol
*sym
, *prev
;
2699 prev
= (struct symbol
*) 0;
2701 /* Get the hash index and check all the symbols
2702 under that hash index. */
2704 hash
= hashname (namestring
);
2706 for (sym
= global_sym_chain
[hash
]; sym
;)
2708 if (*namestring
== SYMBOL_NAME (sym
)[0]
2709 && !strcmp(namestring
+ 1, SYMBOL_NAME (sym
) + 1))
2711 /* Splice this symbol out of the hash chain and
2712 assign the value we have to it. */
2714 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
2716 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
2718 /* Check to see whether we need to fix up a common block. */
2719 /* Note: this code might be executed several times for
2720 the same symbol if there are multiple references. */
2721 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2722 fix_common_block (sym
, misc_function_vector
[mf
].address
);
2724 SYMBOL_VALUE_ADDRESS (sym
) = misc_function_vector
[mf
].address
;
2727 sym
= SYMBOL_VALUE_CHAIN (prev
);
2729 sym
= global_sym_chain
[hash
];
2734 sym
= SYMBOL_VALUE_CHAIN (sym
);
2740 /* Process a pair of symbols. Currently they must both be N_SO's. */
2742 process_symbol_pair (type1
, desc1
, value1
, name1
,
2743 type2
, desc2
, value2
, name2
)
2753 /* No need to check PCC_SOL_BROKEN, on the assumption that such
2754 broken PCC's don't put out N_SO pairs. */
2755 if (last_source_file
)
2756 end_symtab (value2
);
2757 start_symtab (name2
, name1
, value2
);
2761 * Read in a defined section of a specific object file's symbols.
2763 * DESC is the file descriptor for the file, positioned at the
2764 * beginning of the symtab
2765 * STRINGTAB is a pointer to the files string
2766 * table, already read in
2767 * SYM_OFFSET is the offset within the file of
2768 * the beginning of the symbols we want to read, NUM_SUMBOLS is the
2769 * number of symbols to read
2770 * TEXT_OFFSET is the beginning of the text segment we are reading symbols for
2771 * TEXT_SIZE is the size of the text segment read in.
2772 * OFFSET is a relocation offset which gets added to each symbol
2776 read_ofile_symtab (desc
, stringtab
, stringtab_size
, sym_offset
,
2777 sym_size
, text_offset
, text_size
, offset
)
2779 register char *stringtab
;
2780 unsigned int stringtab_size
;
2783 CORE_ADDR text_offset
;
2787 register char *namestring
;
2792 stringtab_global
= stringtab
;
2793 last_source_file
= 0;
2795 symtab_input_desc
= desc
;
2796 symbuf_end
= symbuf_idx
= 0;
2798 /* It is necessary to actually read one symbol *before* the start
2799 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
2800 occurs before the N_SO symbol.
2802 Detecting this in read_dbx_symtab
2803 would slow down initial readin, so we look for it here instead. */
2804 if (sym_offset
>= (int)sizeof (struct nlist
))
2806 lseek (desc
, sym_offset
- sizeof (struct nlist
), L_INCR
);
2808 bufp
= &symbuf
[symbuf_idx
++];
2811 if (bufp
->n_un
.n_strx
< 0 || bufp
->n_un
.n_strx
>= stringtab_size
)
2812 error ("Invalid symbol data: bad string table offset: %d",
2814 namestring
= bufp
->n_un
.n_strx
+ stringtab
;
2816 processing_gcc_compilation
=
2817 (bufp
->n_type
== N_TEXT
2818 && !strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
));
2822 /* The N_SO starting this symtab is the first symbol, so we
2823 better not check the symbol before it. I'm not this can
2824 happen, but it doesn't hurt to check for it. */
2825 lseek(desc
, sym_offset
, L_INCR
);
2826 processing_gcc_compilation
= 0;
2829 if (symbuf_idx
== symbuf_end
)
2831 bufp
= &symbuf
[symbuf_idx
];
2832 if (bufp
->n_type
!= (unsigned char)N_SO
)
2833 error("First symbol in segment of executable not a source symbol");
2836 symnum
< sym_size
/ sizeof(struct nlist
);
2839 QUIT
; /* Allow this to be interruptable */
2840 if (symbuf_idx
== symbuf_end
)
2842 bufp
= &symbuf
[symbuf_idx
++];
2845 type
= bufp
->n_type
& N_TYPE
;
2846 if (type
== (unsigned char)N_CATCH
)
2848 /* N_CATCH is not fixed up by the linker, and unfortunately,
2849 there's no other place to put it in the .stab map. */
2850 /* FIXME, do we also have to add OFFSET or something? -- gnu@cygnus */
2851 bufp
->n_value
+= text_offset
;
2853 else if (type
== N_TEXT
|| type
== N_DATA
|| type
== N_BSS
)
2854 bufp
->n_value
+= offset
;
2856 type
= bufp
->n_type
;
2857 if (bufp
->n_un
.n_strx
< 0 || bufp
->n_un
.n_strx
>= stringtab_size
)
2858 error ("Invalid symbol data: bad string table offset: %d",
2860 namestring
= bufp
->n_un
.n_strx
+ stringtab
;
2864 short desc
= bufp
->n_desc
;
2865 unsigned long valu
= bufp
->n_value
;
2867 /* Check for a pair of N_SO symbols. */
2868 if (type
== (unsigned char)N_SO
)
2870 if (symbuf_idx
== symbuf_end
)
2872 bufp
= &symbuf
[symbuf_idx
];
2873 if (bufp
->n_type
== (unsigned char)N_SO
)
2878 bufp
->n_value
+= offset
; /* Relocate */
2882 if (bufp
->n_un
.n_strx
< 0
2883 || bufp
->n_un
.n_strx
>= stringtab_size
)
2884 error ("Invalid symbol data: bad string table offset: %d",
2886 namestring2
= bufp
->n_un
.n_strx
+ stringtab
;
2888 process_symbol_pair (N_SO
, desc
, valu
, namestring
,
2889 N_SO
, bufp
->n_desc
, bufp
->n_value
,
2893 process_one_symbol(type
, desc
, valu
, namestring
);
2896 process_one_symbol (type
, desc
, valu
, namestring
);
2898 /* We skip checking for a new .o or -l file; that should never
2899 happen in this routine. */
2900 else if (type
== N_TEXT
2901 && !strcmp (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
2902 /* I don't think this code will ever be executed, because
2903 the GCC_COMPILED_FLAG_SYMBOL usually is right before
2904 the N_SO symbol which starts this source file.
2905 However, there is no reason not to accept
2906 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
2907 processing_gcc_compilation
= 1;
2908 else if (type
& N_EXT
|| type
== (unsigned char)N_TEXT
2909 || type
== (unsigned char)N_NBTEXT
2911 /* Global symbol: see if we came across a dbx defintion for
2912 a corresponding symbol. If so, store the value. Remove
2913 syms from the chain when their values are stored, but
2914 search the whole chain, as there may be several syms from
2915 different files with the same name. */
2916 /* This is probably not true. Since the files will be read
2917 in one at a time, each reference to a global symbol will
2918 be satisfied in each file as it appears. So we skip this
2922 end_symtab (text_offset
+ text_size
);
2929 register char *p
= name
;
2930 register int total
= p
[0];
2943 /* Ensure result is positive. */
2944 if (total
< 0) total
+= (1000 << 6);
2945 return total
% HASHSIZE
;
2950 process_one_symbol (type
, desc
, valu
, name
)
2955 #ifndef SUN_FIXED_LBRAC_BUG
2956 /* This records the last pc address we've seen. We depend on their being
2957 an SLINE or FUN or SO before the first LBRAC, since the variable does
2958 not get reset in between reads of different symbol files. */
2959 static CORE_ADDR last_pc_address
;
2961 register struct context_stack
*new;
2964 /* Something is wrong if we see real data before
2965 seeing a source file name. */
2967 if (last_source_file
== 0 && type
!= (unsigned char)N_SO
)
2969 /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
2970 where that code is defined. */
2971 if (IGNORE_SYMBOL (type
))
2974 /* FIXME, this should not be an error, since it precludes extending
2975 the symbol table information in this way... */
2976 error ("Invalid symbol data: does not start by identifying a source file.");
2983 /* Either of these types of symbols indicates the start of
2984 a new function. We must process its "name" normally for dbx,
2985 but also record the start of a new lexical context, and possibly
2986 also the end of the lexical context for the previous function. */
2987 /* This is not always true. This type of symbol may indicate a
2988 text segment variable. */
2990 #ifndef SUN_FIXED_LBRAC_BUG
2991 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2994 colon_pos
= strchr (name
, ':');
2996 || (*colon_pos
!= 'f' && *colon_pos
!= 'F'))
2998 define_symbol (valu
, name
, desc
, type
);
3002 within_function
= 1;
3003 if (context_stack_depth
> 0)
3005 new = &context_stack
[--context_stack_depth
];
3006 /* Make a block for the local symbols within. */
3007 finish_block (new->name
, &local_symbols
, new->old_blocks
,
3008 new->start_addr
, valu
);
3010 /* Stack must be empty now. */
3011 if (context_stack_depth
!= 0)
3012 error ("Invalid symbol data: unmatched N_LBRAC before symtab pos %d.",
3015 new = &context_stack
[context_stack_depth
++];
3016 new->old_blocks
= pending_blocks
;
3017 new->start_addr
= valu
;
3018 new->name
= define_symbol (valu
, name
, desc
, type
);
3023 /* Record the address at which this catch takes place. */
3024 define_symbol (valu
, name
, desc
, type
);
3028 /* Don't know what to do with these yet. */
3029 error ("action uncertain for eh extensions");
3033 /* This "symbol" just indicates the start of an inner lexical
3034 context within a function. */
3036 #if !defined (BLOCK_ADDRESS_ABSOLUTE)
3037 /* On most machines, the block addresses are relative to the
3038 N_SO, the linker did not relocate them (sigh). */
3039 valu
+= last_source_start_addr
;
3042 #ifndef SUN_FIXED_LBRAC_BUG
3043 if (valu
< last_pc_address
) {
3044 /* Patch current LBRAC pc value to match last handy pc value */
3045 complain (&lbrac_complaint
, 0);
3046 valu
= last_pc_address
;
3049 if (context_stack_depth
== context_stack_size
)
3051 context_stack_size
*= 2;
3052 context_stack
= (struct context_stack
*)
3053 xrealloc (context_stack
,
3055 * sizeof (struct context_stack
)));
3058 new = &context_stack
[context_stack_depth
++];
3060 new->locals
= local_symbols
;
3061 new->old_blocks
= pending_blocks
;
3062 new->start_addr
= valu
;
3068 /* This "symbol" just indicates the end of an inner lexical
3069 context that was started with N_LBRAC. */
3071 #if !defined (BLOCK_ADDRESS_ABSOLUTE)
3072 /* On most machines, the block addresses are relative to the
3073 N_SO, the linker did not relocate them (sigh). */
3074 valu
+= last_source_start_addr
;
3077 new = &context_stack
[--context_stack_depth
];
3078 if (desc
!= new->depth
)
3079 error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum
);
3081 /* Some compilers put the variable decls inside of an
3082 LBRAC/RBRAC block. This macro should be nonzero if this
3083 is true. DESC is N_DESC from the N_RBRAC symbol.
3084 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL. */
3085 #if !defined (VARIABLES_INSIDE_BLOCK)
3086 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
3089 /* Can only use new->locals as local symbols here if we're in
3090 gcc or on a machine that puts them before the lbrack. */
3091 if (!VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
3092 local_symbols
= new->locals
;
3094 /* If this is not the outermost LBRAC...RBRAC pair in the
3095 function, its local symbols preceded it, and are the ones
3096 just recovered from the context stack. Defined the block for them.
3098 If this is the outermost LBRAC...RBRAC pair, there is no
3099 need to do anything; leave the symbols that preceded it
3100 to be attached to the function's own block. However, if
3101 it is so, we need to indicate that we just moved outside
3104 && (context_stack_depth
3105 > !VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
)))
3107 /* FIXME Muzzle a compiler bug that makes end < start. */
3108 if (new->start_addr
> valu
)
3110 complain(&lbrac_rbrac_complaint
, 0);
3111 new->start_addr
= valu
;
3113 /* Make a block for the local symbols within. */
3114 finish_block (0, &local_symbols
, new->old_blocks
,
3115 new->start_addr
, valu
);
3119 within_function
= 0;
3121 if (VARIABLES_INSIDE_BLOCK(desc
, processing_gcc_compilation
))
3122 /* Now pop locals of block just finished. */
3123 local_symbols
= new->locals
;
3127 /* This kind of symbol supposedly indicates the start
3128 of an object file. In fact this type does not appear. */
3132 /* This type of symbol indicates the start of data
3133 for one source file.
3134 Finish the symbol table of the previous source file
3135 (if any) and start accumulating a new symbol table. */
3136 #ifndef SUN_FIXED_LBRAC_BUG
3137 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
3140 #ifdef PCC_SOL_BROKEN
3141 /* pcc bug, occasionally puts out SO for SOL. */
3142 if (context_stack_depth
> 0)
3144 start_subfile (name
, NULL
);
3148 if (last_source_file
)
3150 start_symtab (name
, NULL
, valu
);
3154 /* This type of symbol indicates the start of data for
3155 a sub-source-file, one whose contents were copied or
3156 included in the compilation of the main source file
3157 (whose name was given in the N_SO symbol.) */
3158 start_subfile (name
, NULL
);
3163 add_new_header_file (name
, valu
);
3164 start_subfile (name
, NULL
);
3168 start_subfile (pop_subfile (), NULL
);
3172 add_old_header_file (name
, valu
);
3176 /* This type of "symbol" really just records
3177 one line-number -- core-address correspondence.
3178 Enter it in the line list for this symbol table. */
3179 #ifndef SUN_FIXED_LBRAC_BUG
3180 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
3182 record_line (desc
, valu
);
3187 error ("Invalid symbol data: common within common at symtab pos %d",
3189 common_block
= local_symbols
;
3190 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
3194 /* Symbols declared since the BCOMM are to have the common block
3195 start address added in when we know it. common_block points to
3196 the first symbol after the BCOMM in the local_symbols list;
3197 copy the list and hang it off the symbol for the common block name
3201 struct symbol
*sym
=
3202 (struct symbol
*) xmalloc (sizeof (struct symbol
));
3203 bzero (sym
, sizeof *sym
);
3204 SYMBOL_NAME (sym
) = savestring (name
, strlen (name
));
3205 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3206 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long)
3207 copy_pending (local_symbols
, common_block_i
, common_block
));
3208 i
= hashname (SYMBOL_NAME (sym
));
3209 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
3210 global_sym_chain
[i
] = sym
;
3221 define_symbol (valu
, name
, desc
, type
);
3225 /* Read a number by which a type is referred to in dbx data,
3226 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
3227 Just a single number N is equivalent to (0,N).
3228 Return the two numbers by storing them in the vector TYPENUMS.
3229 TYPENUMS will then be used as an argument to dbx_lookup_type. */
3232 read_type_number (pp
, typenums
)
3234 register int *typenums
;
3239 typenums
[0] = read_number (pp
, ',');
3240 typenums
[1] = read_number (pp
, ')');
3245 typenums
[1] = read_number (pp
, 0);
3249 /* To handle GNU C++ typename abbreviation, we need to be able to
3250 fill in a type's name as soon as space for that type is allocated.
3251 `type_synonym_name' is the name of the type being allocated.
3252 It is cleared as soon as it is used (lest all allocated types
3254 static char *type_synonym_name
;
3256 static struct symbol
*
3257 define_symbol (valu
, string
, desc
, type
)
3263 register struct symbol
*sym
;
3264 char *p
= (char *) strchr (string
, ':');
3269 /* Ignore syms with empty names. */
3273 /* Ignore old-style symbols from cc -go */
3277 sym
= (struct symbol
*)obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
3279 if (processing_gcc_compilation
) {
3280 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
3281 number of bytes occupied by a type or object, which we ignore. */
3282 SYMBOL_LINE(sym
) = desc
;
3284 SYMBOL_LINE(sym
) = 0; /* unknown */
3287 if (string
[0] == CPLUS_MARKER
)
3289 /* Special GNU C++ names. */
3293 SYMBOL_NAME (sym
) = "this";
3295 case 'v': /* $vtbl_ptr_type */
3296 /* Was: SYMBOL_NAME (sym) = "vptr"; */
3299 SYMBOL_NAME (sym
) = "eh_throw";
3303 /* This was an anonymous type that was never fixed up. */
3314 = (char *) obstack_alloc (symbol_obstack
, ((p
- string
) + 1));
3315 /* Open-coded bcopy--saves function call time. */
3317 register char *p1
= string
;
3318 register char *p2
= SYMBOL_NAME (sym
);
3325 /* Determine the type of name being defined. */
3326 /* The Acorn RISC machine's compiler can put out locals that don't
3327 start with "234=" or "(3,4)=", so assume anything other than the
3328 deftypes we know how to handle is a local. */
3329 /* (Peter Watkins @ Computervision)
3330 Handle Sun-style local fortran array types 'ar...' .
3331 (gnu@cygnus.com) -- this strchr() handles them properly?
3332 (tiemann@cygnus.com) -- 'C' is for catch. */
3333 if (!strchr ("cfFGpPrStTvVXC", *p
))
3338 /* c is a special case, not followed by a type-number.
3339 SYMBOL:c=iVALUE for an integer constant symbol.
3340 SYMBOL:c=rVALUE for a floating constant symbol.
3341 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
3342 e.g. "b:c=e6,0" for "const b = blob1"
3343 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
3347 error ("Invalid symbol data at symtab pos %d.", symnum
);
3352 double d
= atof (p
);
3355 SYMBOL_TYPE (sym
) = builtin_type_double
;
3356 valu
= (char *) obstack_alloc (symbol_obstack
, sizeof (double));
3357 bcopy (&d
, valu
, sizeof (double));
3358 SWAP_TARGET_AND_HOST (valu
, sizeof (double));
3359 SYMBOL_VALUE_BYTES (sym
) = valu
;
3360 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
3365 SYMBOL_TYPE (sym
) = builtin_type_int
;
3366 SYMBOL_VALUE (sym
) = atoi (p
);
3367 SYMBOL_CLASS (sym
) = LOC_CONST
;
3371 /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
3372 e.g. "b:c=e6,0" for "const b = blob1"
3373 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
3377 read_type_number (&p
, typenums
);
3379 error ("Invalid symbol data: no comma in enum const symbol");
3381 SYMBOL_TYPE (sym
) = *dbx_lookup_type (typenums
);
3382 SYMBOL_VALUE (sym
) = atoi (p
);
3383 SYMBOL_CLASS (sym
) = LOC_CONST
;
3387 error ("Invalid symbol data at symtab pos %d.", symnum
);
3389 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3390 add_symbol_to_list (sym
, &file_symbols
);
3394 /* Now usually comes a number that says which data type,
3395 and possibly more stuff to define the type
3396 (all of which is handled by read_type) */
3398 if (deftype
== 'p' && *p
== 'F')
3399 /* pF is a two-letter code that means a function parameter in Fortran.
3400 The type-number specifies the type of the return value.
3401 Translate it into a pointer-to-function type. */
3405 = lookup_pointer_type (lookup_function_type (read_type (&p
)));
3410 synonym
= *p
== 't';
3415 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
3416 strlen (SYMBOL_NAME (sym
)));
3419 type
= read_type (&p
);
3421 if ((deftype
== 'F' || deftype
== 'f')
3422 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
3423 SYMBOL_TYPE (sym
) = lookup_function_type (type
);
3425 SYMBOL_TYPE (sym
) = type
;
3431 /* The name of a caught exception. */
3432 SYMBOL_CLASS (sym
) = LOC_LABEL
;
3433 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3434 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
3435 add_symbol_to_list (sym
, &local_symbols
);
3439 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3440 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3441 add_symbol_to_list (sym
, &file_symbols
);
3445 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3446 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3447 add_symbol_to_list (sym
, &global_symbols
);
3451 /* For a class G (global) symbol, it appears that the
3452 value is not correct. It is necessary to search for the
3453 corresponding linker definition to find the value.
3454 These definitions appear at the end of the namelist. */
3455 i
= hashname (SYMBOL_NAME (sym
));
3456 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
3457 global_sym_chain
[i
] = sym
;
3458 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3459 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3460 add_symbol_to_list (sym
, &global_symbols
);
3463 /* This case is faked by a conditional above,
3464 when there is no code letter in the dbx data.
3465 Dbx data never actually contains 'l'. */
3467 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3468 SYMBOL_VALUE (sym
) = valu
;
3469 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3470 add_symbol_to_list (sym
, &local_symbols
);
3474 /* Normally this is a parameter, a LOC_ARG. On the i960, it
3475 can also be a LOC_LOCAL_ARG depending on symbol type. */
3476 #ifndef DBX_PARM_SYMBOL_CLASS
3477 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
3479 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
3480 SYMBOL_VALUE (sym
) = valu
;
3481 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3482 add_symbol_to_list (sym
, &local_symbols
);
3484 /* If it's gcc-compiled, if it says `short', believe it. */
3485 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
3488 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
3489 /* This macro is defined on machines (e.g. sparc) where
3490 we should believe the type of a PCC 'short' argument,
3491 but shouldn't believe the address (the address is
3492 the address of the corresponding int). Note that
3493 this is only different from the BELIEVE_PCC_PROMOTION
3494 case on big-endian machines.
3496 My guess is that this correction, as opposed to changing
3497 the parameter to an 'int' (as done below, for PCC
3498 on most machines), is the right thing to do
3499 on all machines, but I don't want to risk breaking
3500 something that already works. On most PCC machines,
3501 the sparc problem doesn't come up because the calling
3502 function has to zero the top bytes (not knowing whether
3503 the called function wants an int or a short), so there
3504 is no practical difference between an int and a short
3505 (except perhaps what happens when the GDB user types
3506 "print short_arg = 0x10000;").
3508 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
3509 actually produces the correct address (we don't need to fix it
3510 up). I made this code adapt so that it will offset the symbol
3511 if it was pointing at an int-aligned location and not
3512 otherwise. This way you can use the same gdb for 4.0.x and
3515 if (0 == SYMBOL_VALUE (sym
) % sizeof (int))
3517 if (SYMBOL_TYPE (sym
) == builtin_type_char
3518 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
)
3519 SYMBOL_VALUE (sym
) += 3;
3520 else if (SYMBOL_TYPE (sym
) == builtin_type_short
3521 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
3522 SYMBOL_VALUE (sym
) += 2;
3526 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
3528 /* If PCC says a parameter is a short or a char,
3529 it is really an int. */
3530 if (SYMBOL_TYPE (sym
) == builtin_type_char
3531 || SYMBOL_TYPE (sym
) == builtin_type_short
)
3532 SYMBOL_TYPE (sym
) = builtin_type_int
;
3533 else if (SYMBOL_TYPE (sym
) == builtin_type_unsigned_char
3534 || SYMBOL_TYPE (sym
) == builtin_type_unsigned_short
)
3535 SYMBOL_TYPE (sym
) = builtin_type_unsigned_int
;
3538 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
3541 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3542 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
3543 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3544 add_symbol_to_list (sym
, &local_symbols
);
3548 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
3549 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
3550 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3551 add_symbol_to_list (sym
, &local_symbols
);
3555 /* Static symbol at top level of file */
3556 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3557 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
3558 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3559 add_symbol_to_list (sym
, &file_symbols
);
3563 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3564 SYMBOL_VALUE (sym
) = valu
;
3565 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3566 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0
3567 && (TYPE_FLAGS (SYMBOL_TYPE (sym
)) & TYPE_FLAG_PERM
) == 0)
3568 TYPE_NAME (SYMBOL_TYPE (sym
)) =
3569 obsavestring (SYMBOL_NAME (sym
),
3570 strlen (SYMBOL_NAME (sym
)));
3571 /* C++ vagaries: we may have a type which is derived from
3572 a base type which did not have its name defined when the
3573 derived class was output. We fill in the derived class's
3574 base part member's name here in that case. */
3575 else if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
3576 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
3577 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
3580 for (i
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; i
>= 0; i
--)
3581 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), i
) == 0)
3582 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), i
) =
3583 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), i
));
3586 add_symbol_to_list (sym
, &file_symbols
);
3590 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
3591 SYMBOL_VALUE (sym
) = valu
;
3592 SYMBOL_NAMESPACE (sym
) = STRUCT_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
))
3597 (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_ENUM
3599 : (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
3600 ? "struct " : "union ")),
3602 add_symbol_to_list (sym
, &file_symbols
);
3606 register struct symbol
*typedef_sym
3607 = (struct symbol
*) obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
3608 SYMBOL_NAME (typedef_sym
) = SYMBOL_NAME (sym
);
3609 SYMBOL_TYPE (typedef_sym
) = SYMBOL_TYPE (sym
);
3611 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
3612 SYMBOL_VALUE (typedef_sym
) = valu
;
3613 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
3614 add_symbol_to_list (typedef_sym
, &file_symbols
);
3619 /* Static symbol of local scope */
3620 SYMBOL_CLASS (sym
) = LOC_STATIC
;
3621 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
3622 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3623 add_symbol_to_list (sym
, &local_symbols
);
3627 /* Reference parameter */
3628 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
3629 SYMBOL_VALUE (sym
) = valu
;
3630 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3631 add_symbol_to_list (sym
, &local_symbols
);
3635 /* This is used by Sun FORTRAN for "function result value".
3636 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
3637 that Pascal uses it too, but when I tried it Pascal used
3638 "x:3" (local symbol) instead. */
3639 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
3640 SYMBOL_VALUE (sym
) = valu
;
3641 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3642 add_symbol_to_list (sym
, &local_symbols
);
3646 error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype
, symnum
);
3651 /* What about types defined as forward references inside of a small lexical
3653 /* Add a type to the list of undefined types to be checked through
3654 once this file has been read in. */
3656 add_undefined_type (type
)
3659 if (undef_types_length
== undef_types_allocated
)
3661 undef_types_allocated
*= 2;
3662 undef_types
= (struct type
**)
3663 xrealloc (undef_types
,
3664 undef_types_allocated
* sizeof (struct type
*));
3666 undef_types
[undef_types_length
++] = type
;
3669 /* Add here something to go through each undefined type, see if it's
3670 still undefined, and do a full lookup if so. */
3672 cleanup_undefined_types ()
3676 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
3678 /* Reasonable test to see if it's been defined since. */
3679 if (TYPE_NFIELDS (*type
) == 0)
3681 struct pending
*ppt
;
3683 /* Name of the type, without "struct" or "union" */
3684 char *typename
= TYPE_NAME (*type
);
3686 if (!strncmp (typename
, "struct ", 7))
3688 if (!strncmp (typename
, "union ", 6))
3691 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
3692 for (i
= 0; i
< ppt
->nsyms
; i
++)
3694 struct symbol
*sym
= ppt
->symbol
[i
];
3696 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3697 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
3698 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
3700 && !strcmp (SYMBOL_NAME (sym
), typename
))
3701 bcopy (SYMBOL_TYPE (sym
), *type
, sizeof (struct type
));
3705 /* It has been defined; don't mark it as a stub. */
3706 TYPE_FLAGS (*type
) &= ~TYPE_FLAG_STUB
;
3708 undef_types_length
= 0;
3711 /* Skip rest of this symbol and return an error type.
3713 General notes on error recovery: error_type always skips to the
3714 end of the symbol (modulo cretinous dbx symbol name continuation).
3715 Thus code like this:
3717 if (*(*pp)++ != ';')
3718 return error_type (pp);
3720 is wrong because if *pp starts out pointing at '\0' (typically as the
3721 result of an earlier error), it will be incremented to point to the
3722 start of the next symbol, which might produce strange results, at least
3723 if you run off the end of the string table. Instead use
3726 return error_type (pp);
3732 foo = error_type (pp);
3736 And in case it isn't obvious, the point of all this hair is so the compiler
3737 can define new types and new syntaxes, and old versions of the
3738 debugger will be able to read the new symbol tables. */
3740 static struct type
*
3744 complain (&error_type_complaint
, 0);
3747 /* Skip to end of symbol. */
3748 while (**pp
!= '\0')
3751 /* Check for and handle cretinous dbx symbol name continuation! */
3752 if ((*pp
)[-1] == '\\')
3753 *pp
= next_symbol_text ();
3757 return builtin_type_error
;
3760 /* Read a dbx type reference or definition;
3761 return the type that is meant.
3762 This can be just a number, in which case it references
3763 a type already defined and placed in type_vector.
3764 Or the number can be followed by an =, in which case
3765 it means to define a new type according to the text that
3773 register struct type
*type
= 0;
3778 /* Read type number if present. The type number may be omitted.
3779 for instance in a two-dimensional array declared with type
3780 "ar1;1;10;ar1;1;10;4". */
3781 if ((**pp
>= '0' && **pp
<= '9')
3784 read_type_number (pp
, typenums
);
3786 /* Detect random reference to type not yet defined.
3787 Allocate a type object but leave it zeroed. */
3789 return dbx_alloc_type (typenums
);
3795 /* 'typenums=' not present, type is anonymous. Read and return
3796 the definition, but don't put it in the type vector. */
3797 typenums
[0] = typenums
[1] = -1;
3805 enum type_code code
;
3807 /* Used to index through file_symbols. */
3808 struct pending
*ppt
;
3811 /* Name including "struct", etc. */
3814 /* Name without "struct", etc. */
3815 char *type_name_only
;
3821 /* Set the type code according to the following letter. */
3825 code
= TYPE_CODE_STRUCT
;
3829 code
= TYPE_CODE_UNION
;
3833 code
= TYPE_CODE_ENUM
;
3837 return error_type (pp
);
3840 to
= type_name
= (char *)
3841 obstack_alloc (symbol_obstack
,
3843 ((char *) strchr (*pp
, ':') - (*pp
)) + 1));
3845 /* Copy the prefix. */
3847 while (*to
++ = *from
++)
3851 type_name_only
= to
;
3853 /* Copy the name. */
3855 while ((*to
++ = *from
++) != ':')
3859 /* Set the pointer ahead of the name which we just read. */
3863 /* The following hack is clearly wrong, because it doesn't
3864 check whether we are in a baseclass. I tried to reproduce
3865 the case that it is trying to fix, but I couldn't get
3866 g++ to put out a cross reference to a basetype. Perhaps
3867 it doesn't do it anymore. */
3868 /* Note: for C++, the cross reference may be to a base type which
3869 has not yet been seen. In this case, we skip to the comma,
3870 which will mark the end of the base class name. (The ':'
3871 at the end of the base class name will be skipped as well.)
3872 But sometimes (ie. when the cross ref is the last thing on
3873 the line) there will be no ','. */
3874 from
= (char *) strchr (*pp
, ',');
3880 /* Now check to see whether the type has already been declared. */
3881 /* This is necessary at least in the case where the
3882 program says something like
3884 The compiler puts out a cross-reference; we better find
3885 set the length of the structure correctly so we can
3886 set the length of the array. */
3887 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
3888 for (i
= 0; i
< ppt
->nsyms
; i
++)
3890 struct symbol
*sym
= ppt
->symbol
[i
];
3892 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3893 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
3894 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
3895 && !strcmp (SYMBOL_NAME (sym
), type_name_only
))
3897 obstack_free (symbol_obstack
, type_name
);
3898 type
= SYMBOL_TYPE (sym
);
3903 /* Didn't find the type to which this refers, so we must
3904 be dealing with a forward reference. Allocate a type
3905 structure for it, and keep track of it so we can
3906 fill in the rest of the fields when we get the full
3908 type
= dbx_alloc_type (typenums
);
3909 TYPE_CODE (type
) = code
;
3910 TYPE_NAME (type
) = type_name
;
3912 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3914 add_undefined_type (type
);
3930 read_type_number (pp
, xtypenums
);
3931 type
= *dbx_lookup_type (xtypenums
);
3933 type
= builtin_type_void
;
3934 if (typenums
[0] != -1)
3935 *dbx_lookup_type (typenums
) = type
;
3939 type1
= read_type (pp
);
3940 type
= lookup_pointer_type (type1
);
3941 if (typenums
[0] != -1)
3942 *dbx_lookup_type (typenums
) = type
;
3947 struct type
*domain
= read_type (pp
);
3948 struct type
*memtype
;
3951 /* Invalid member type data format. */
3952 return error_type (pp
);
3955 memtype
= read_type (pp
);
3956 type
= dbx_alloc_type (typenums
);
3957 smash_to_member_type (type
, domain
, memtype
);
3962 if ((*pp
)[0] == '#')
3964 /* We'll get the parameter types from the name. */
3965 struct type
*return_type
;
3968 return_type
= read_type (pp
);
3969 if (*(*pp
)++ != ';')
3970 complain (&invalid_member_complaint
, symnum
);
3971 type
= lookup_function_type (return_type
);
3972 if (typenums
[0] != -1)
3973 *dbx_lookup_type (typenums
) = type
;
3974 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
3975 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3979 struct type
*domain
= read_type (pp
);
3980 struct type
*return_type
;
3983 if (*(*pp
)++ != ',')
3984 error ("invalid member type data format, at symtab pos %d.",
3987 return_type
= read_type (pp
);
3988 args
= read_args (pp
, ';');
3989 type
= dbx_alloc_type (typenums
);
3990 smash_to_method_type (type
, domain
, return_type
, args
);
3995 type1
= read_type (pp
);
3996 type
= lookup_reference_type (type1
);
3997 if (typenums
[0] != -1)
3998 *dbx_lookup_type (typenums
) = type
;
4002 type1
= read_type (pp
);
4003 type
= lookup_function_type (type1
);
4004 if (typenums
[0] != -1)
4005 *dbx_lookup_type (typenums
) = type
;
4009 type
= read_range_type (pp
, typenums
);
4010 if (typenums
[0] != -1)
4011 *dbx_lookup_type (typenums
) = type
;
4015 type
= dbx_alloc_type (typenums
);
4016 type
= read_enum_type (pp
, type
);
4017 *dbx_lookup_type (typenums
) = type
;
4021 type
= dbx_alloc_type (typenums
);
4022 TYPE_NAME (type
) = type_synonym_name
;
4023 type_synonym_name
= 0;
4024 type
= read_struct_type (pp
, type
);
4028 type
= dbx_alloc_type (typenums
);
4029 TYPE_NAME (type
) = type_synonym_name
;
4030 type_synonym_name
= 0;
4031 type
= read_struct_type (pp
, type
);
4032 TYPE_CODE (type
) = TYPE_CODE_UNION
;
4037 return error_type (pp
);
4040 type
= dbx_alloc_type (typenums
);
4041 type
= read_array_type (pp
, type
);
4045 return error_type (pp
);
4052 /* If this is an overriding temporary alteration for a header file's
4053 contents, and this type number is unknown in the global definition,
4054 put this type into the global definition at this type number. */
4055 if (header_file_prev_index
>= 0)
4057 register struct type
**tp
4058 = explicit_lookup_type (header_file_prev_index
, typenums
[1]);
4067 /* This would be a good idea, but it doesn't really work. The problem
4068 is that in order to get the virtual context for a particular type,
4069 you need to know the virtual info from all of its basetypes,
4070 and you need to have processed its methods. Since GDB reads
4071 symbols on a file-by-file basis, this means processing the symbols
4072 of all the files that are needed for each baseclass, which
4073 means potentially reading in all the debugging info just to fill
4074 in information we may never need. */
4076 /* This page contains subroutines of read_type. */
4078 /* FOR_TYPE is a struct type defining a virtual function NAME with type
4079 FN_TYPE. The `virtual context' for this virtual function is the
4080 first base class of FOR_TYPE in which NAME is defined with signature
4081 matching FN_TYPE. OFFSET serves as a hash on matches here.
4083 TYPE is the current type in which we are searching. */
4085 static struct type
*
4086 virtual_context (for_type
, type
, name
, fn_type
, offset
)
4087 struct type
*for_type
, *type
;
4089 struct type
*fn_type
;
4092 struct type
*basetype
= 0;
4095 if (for_type
!= type
)
4097 /* Check the methods of TYPE. */
4098 /* Need to do a check_stub_type here, but that breaks
4099 things because we can get infinite regress. */
4100 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
4101 if (!strcmp (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
4105 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
4106 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
4109 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == offset
-1)
4110 return TYPE_FN_FIELD_FCONTEXT (f
, j
);
4113 for (i
= TYPE_N_BASECLASSES (type
); i
> 0; i
--)
4115 basetype
= virtual_context (for_type
, TYPE_BASECLASS (type
, i
), name
,
4117 if (basetype
!= for_type
)
4124 /* Read the description of a structure (or union type)
4125 and return an object describing the type. */
4127 static struct type
*
4128 read_struct_type (pp
, type
)
4130 register struct type
*type
;
4132 /* Total number of methods defined in this class.
4133 If the class defines two `f' methods, and one `g' method,
4134 then this will have the value 3. */
4135 int total_length
= 0;
4139 struct nextfield
*next
;
4140 int visibility
; /* 0=public, 1=protected, 2=public */
4146 struct next_fnfield
*next
;
4147 int visibility
; /* 0=public, 1=protected, 2=public */
4148 struct fn_field fn_field
;
4151 struct next_fnfieldlist
4153 struct next_fnfieldlist
*next
;
4154 struct fn_fieldlist fn_fieldlist
;
4157 register struct nextfield
*list
= 0;
4158 struct nextfield
*new;
4163 register struct next_fnfieldlist
*mainlist
= 0;
4166 if (TYPE_MAIN_VARIANT (type
) == 0)
4168 TYPE_MAIN_VARIANT (type
) = type
;
4171 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
4173 /* First comes the total size in bytes. */
4175 TYPE_LENGTH (type
) = read_number (pp
, 0);
4177 /* C++: Now, if the class is a derived class, then the next character
4178 will be a '!', followed by the number of base classes derived from.
4179 Each element in the list contains visibility information,
4180 the offset of this base class in the derived structure,
4181 and then the base type. */
4184 int i
, n_baseclasses
, offset
;
4185 struct type
*baseclass
;
4188 /* Nonzero if it is a virtual baseclass, i.e.,
4192 struct C : public B, public virtual A {};
4194 B is a baseclass of C; A is a virtual baseclass for C. This is a C++
4195 2.0 language feature. */
4200 n_baseclasses
= read_number (pp
, ',');
4201 TYPE_FIELD_VIRTUAL_BITS (type
) =
4202 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (n_baseclasses
));
4203 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), n_baseclasses
);
4205 for (i
= 0; i
< n_baseclasses
; i
++)
4208 *pp
= next_symbol_text ();
4219 /* Bad visibility format. */
4220 return error_type (pp
);
4233 /* Bad visibility format. */
4234 return error_type (pp
);
4237 SET_TYPE_FIELD_VIRTUAL (type
, i
);
4240 /* Offset of the portion of the object corresponding to
4241 this baseclass. Always zero in the absence of
4242 multiple inheritance. */
4243 offset
= read_number (pp
, ',');
4244 baseclass
= read_type (pp
);
4245 *pp
+= 1; /* skip trailing ';' */
4248 /* One's understanding improves, grasshopper... */
4251 static int error_printed
= 0;
4256 "\nWarning: GDB has limited understanding of multiple inheritance...");
4258 fprintf(stderr
, "\n");
4264 /* Make this baseclass visible for structure-printing purposes. */
4265 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4268 list
->visibility
= via_public
;
4269 list
->field
.type
= baseclass
;
4270 list
->field
.name
= type_name_no_tag (baseclass
);
4271 list
->field
.bitpos
= offset
;
4272 list
->field
.bitsize
= 0; /* this should be an unpacked field! */
4275 TYPE_N_BASECLASSES (type
) = n_baseclasses
;
4278 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
4279 At the end, we see a semicolon instead of a field.
4281 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
4284 The `?' is a placeholder for one of '/2' (public visibility),
4285 '/1' (protected visibility), '/0' (private visibility), or nothing
4286 (C style symbol table, public visibility). */
4288 /* We better set p right now, in case there are no fields at all... */
4293 /* Check for and handle cretinous dbx symbol name continuation! */
4294 if (**pp
== '\\') *pp
= next_symbol_text ();
4296 /* Get space to record the next field's data. */
4297 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4301 /* Get the field name. */
4303 if (*p
== CPLUS_MARKER
)
4305 /* Special GNU C++ name. */
4308 char *prefix
, *name
; /* FIXME: NAME never set! */
4309 struct type
*context
;
4320 error ("invalid abbreviation at symtab pos %d.", symnum
);
4323 context
= read_type (pp
);
4324 if (type_name_no_tag (context
) == 0)
4327 error ("type name unknown at symtab pos %d.", symnum
);
4328 TYPE_NAME (context
) = obsavestring (name
, p
- name
- 1);
4330 list
->field
.name
= obconcat (prefix
, type_name_no_tag (context
), "");
4333 error ("invalid abbreviation at symtab pos %d.", symnum
);
4334 list
->field
.type
= read_type (pp
);
4335 (*pp
)++; /* Skip the comma. */
4336 list
->field
.bitpos
= read_number (pp
, ';');
4337 /* This field is unpacked. */
4338 list
->field
.bitsize
= 0;
4341 error ("invalid abbreviation at symtab pos %d.", symnum
);
4347 while (*p
!= ':') p
++;
4348 list
->field
.name
= obsavestring (*pp
, p
- *pp
);
4350 /* C++: Check to see if we have hit the methods yet. */
4356 /* This means we have a visibility for a field coming. */
4362 list
->visibility
= 0; /* private */
4367 list
->visibility
= 1; /* protected */
4372 list
->visibility
= 2; /* public */
4377 else /* normal dbx-style format. */
4378 list
->visibility
= 2; /* public */
4380 list
->field
.type
= read_type (pp
);
4383 /* Static class member. */
4384 list
->field
.bitpos
= (long)-1;
4386 while (*p
!= ';') p
++;
4387 list
->field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
4392 else if (**pp
!= ',')
4393 /* Bad structure-type format. */
4394 return error_type (pp
);
4396 (*pp
)++; /* Skip the comma. */
4397 list
->field
.bitpos
= read_number (pp
, ',');
4398 list
->field
.bitsize
= read_number (pp
, ';');
4401 /* FIXME tiemann: what is the story here? What does the compiler
4402 really do? Also, patch gdb.texinfo for this case; I document
4403 it as a possible problem there. Search for "DBX-style". */
4405 /* This is wrong because this is identical to the symbols
4406 produced for GCC 0-size arrays. For example:
4411 The code which dumped core in such circumstances should be
4412 fixed not to dump core. */
4414 /* g++ -g0 can put out bitpos & bitsize zero for a static
4415 field. This does not give us any way of getting its
4416 class, so we can't know its name. But we can just
4417 ignore the field so we don't dump core and other nasty
4419 if (list
->field
.bitpos
== 0
4420 && list
->field
.bitsize
== 0)
4422 complain (&dbx_class_complaint
, 0);
4423 /* Ignore this field. */
4429 /* Detect an unpacked field and mark it as such.
4430 dbx gives a bit size for all fields.
4431 Note that forward refs cannot be packed,
4432 and treat enums as if they had the width of ints. */
4433 if (TYPE_CODE (list
->field
.type
) != TYPE_CODE_INT
4434 && TYPE_CODE (list
->field
.type
) != TYPE_CODE_ENUM
)
4435 list
->field
.bitsize
= 0;
4436 if ((list
->field
.bitsize
== 8 * TYPE_LENGTH (list
->field
.type
)
4437 || (TYPE_CODE (list
->field
.type
) == TYPE_CODE_ENUM
4438 && (list
->field
.bitsize
4439 == 8 * TYPE_LENGTH (builtin_type_int
))
4443 list
->field
.bitpos
% 8 == 0)
4444 list
->field
.bitsize
= 0;
4450 /* chill the list of fields: the last entry (at the head)
4451 is a partially constructed entry which we now scrub. */
4454 /* Now create the vector of fields, and record how big it is.
4455 We need this info to record proper virtual function table information
4456 for this class's virtual functions. */
4458 TYPE_NFIELDS (type
) = nfields
;
4459 TYPE_FIELDS (type
) = (struct field
*) obstack_alloc (symbol_obstack
,
4460 sizeof (struct field
) * nfields
);
4462 TYPE_FIELD_PRIVATE_BITS (type
) =
4463 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (nfields
));
4464 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4466 TYPE_FIELD_PROTECTED_BITS (type
) =
4467 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (nfields
));
4468 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4470 /* Copy the saved-up fields into the field vector. */
4472 for (n
= nfields
; list
; list
= list
->next
)
4475 TYPE_FIELD (type
, n
) = list
->field
;
4476 if (list
->visibility
== 0)
4477 SET_TYPE_FIELD_PRIVATE (type
, n
);
4478 else if (list
->visibility
== 1)
4479 SET_TYPE_FIELD_PROTECTED (type
, n
);
4482 /* Now come the method fields, as NAME::methods
4483 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
4484 At the end, we see a semicolon instead of a field.
4486 For the case of overloaded operators, the format is
4487 OPERATOR::*.methods, where OPERATOR is the string "operator",
4488 `*' holds the place for an operator name (such as `+=')
4489 and `.' marks the end of the operator name. */
4492 /* Now, read in the methods. To simplify matters, we
4493 "unread" the name that has been read, so that we can
4494 start from the top. */
4496 /* For each list of method lists... */
4500 struct next_fnfield
*sublist
= 0;
4502 struct next_fnfieldlist
*new_mainlist
=
4503 (struct next_fnfieldlist
*)alloca (sizeof (struct next_fnfieldlist
));
4508 /* read in the name. */
4509 while (*p
!= ':') p
++;
4510 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
4512 /* This lets the user type "break operator+".
4513 We could just put in "+" as the name, but that wouldn't
4515 static char opname
[32] = "operator";
4516 char *o
= opname
+ 8;
4518 /* Skip past '::'. */
4522 main_fn_name
= savestring (opname
, o
- opname
);
4529 main_fn_name
= savestring (*pp
, p
- *pp
);
4530 /* Skip past '::'. */
4533 new_mainlist
->fn_fieldlist
.name
= main_fn_name
;
4537 struct next_fnfield
*new_sublist
=
4538 (struct next_fnfield
*)alloca (sizeof (struct next_fnfield
));
4540 /* Check for and handle cretinous dbx symbol name continuation! */
4541 if (**pp
== '\\') *pp
= next_symbol_text ();
4543 new_sublist
->fn_field
.type
= read_type (pp
);
4545 /* Invalid symtab info for method. */
4546 return error_type (pp
);
4550 while (*p
!= ';') p
++;
4551 /* If this is just a stub, then we don't have the
4553 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
4555 new_sublist
->visibility
= *(*pp
)++ - '0';
4556 if (**pp
== '\\') *pp
= next_symbol_text ();
4557 /* FIXME: tiemann needs to add const/volatile info
4558 to the methods. For now, just skip the char.
4559 In future, here's what we need to implement:
4561 A for normal functions.
4562 B for `const' member functions.
4563 C for `volatile' member functions.
4564 D for `const volatile' member functions. */
4565 if (**pp
== 'A' || **pp
== 'B' || **pp
== 'C' || **pp
== 'D')
4568 complain(&const_vol_complaint
, **pp
);
4573 /* virtual member function, followed by index. */
4574 /* The sign bit is set to distinguish pointers-to-methods
4575 from virtual function indicies. Since the array is
4576 in words, the quantity must be shifted left by 1
4577 on 16 bit machine, and by 2 on 32 bit machine, forcing
4578 the sign bit out, and usable as a valid index into
4579 the array. Remove the sign bit here. */
4580 new_sublist
->fn_field
.voffset
=
4581 (0x7fffffff & read_number (pp
, ';')) + 1;
4583 /* Figure out from whence this virtual function came.
4584 It may belong to virtual function table of
4585 one of its baseclasses. */
4586 new_sublist
->fn_field
.fcontext
= read_type (pp
);
4594 /* static member function. */
4595 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
4599 /* normal member function. */
4600 new_sublist
->fn_field
.voffset
= 0;
4604 new_sublist
->next
= sublist
;
4605 sublist
= new_sublist
;
4608 while (**pp
!= ';' && *pp
!= '\0');
4612 new_mainlist
->fn_fieldlist
.fn_fields
=
4613 (struct fn_field
*) obstack_alloc (symbol_obstack
,
4614 sizeof (struct fn_field
) * length
);
4615 TYPE_FN_PRIVATE_BITS (new_mainlist
->fn_fieldlist
) =
4616 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (length
));
4617 B_CLRALL (TYPE_FN_PRIVATE_BITS (new_mainlist
->fn_fieldlist
), length
);
4619 TYPE_FN_PROTECTED_BITS (new_mainlist
->fn_fieldlist
) =
4620 (B_TYPE
*) obstack_alloc (symbol_obstack
, B_BYTES (length
));
4621 B_CLRALL (TYPE_FN_PROTECTED_BITS (new_mainlist
->fn_fieldlist
), length
);
4623 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
4625 new_mainlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
4626 if (sublist
->visibility
== 0)
4627 B_SET (new_mainlist
->fn_fieldlist
.private_fn_field_bits
, i
);
4628 else if (sublist
->visibility
== 1)
4629 B_SET (new_mainlist
->fn_fieldlist
.protected_fn_field_bits
, i
);
4632 new_mainlist
->fn_fieldlist
.length
= length
;
4633 new_mainlist
->next
= mainlist
;
4634 mainlist
= new_mainlist
;
4636 total_length
+= length
;
4638 while (**pp
!= ';');
4643 TYPE_FN_FIELDLISTS (type
) =
4644 (struct fn_fieldlist
*) obstack_alloc (symbol_obstack
,
4645 sizeof (struct fn_fieldlist
) * nfn_fields
);
4647 TYPE_NFN_FIELDS (type
) = nfn_fields
;
4648 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
4652 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
4653 TYPE_NFN_FIELDS_TOTAL (type
) +=
4654 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, i
));
4657 for (n
= nfn_fields
; mainlist
; mainlist
= mainlist
->next
)
4658 TYPE_FN_FIELDLISTS (type
)[--n
] = mainlist
->fn_fieldlist
;
4667 |= TYPE_FLAG_HAS_CONSTRUCTOR
| TYPE_FLAG_HAS_DESTRUCTOR
;
4670 else if (**pp
== '+')
4672 TYPE_FLAGS (type
) |= TYPE_FLAG_HAS_CONSTRUCTOR
;
4675 else if (**pp
== '-')
4677 TYPE_FLAGS (type
) |= TYPE_FLAG_HAS_DESTRUCTOR
;
4681 /* Read either a '%' or the final ';'. */
4682 if (*(*pp
)++ == '%')
4684 /* Now we must record the virtual function table pointer's
4685 field information. */
4692 while (*p
!= '\0' && *p
!= ';')
4695 /* Premature end of symbol. */
4696 return error_type (pp
);
4698 TYPE_VPTR_BASETYPE (type
) = t
;
4701 if (TYPE_FIELD_NAME (t
, TYPE_N_BASECLASSES (t
)) == 0)
4702 TYPE_VPTR_FIELDNO (type
) = i
= TYPE_N_BASECLASSES (t
);
4703 else for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); --i
)
4704 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
4705 sizeof (vptr_name
) -1))
4707 TYPE_VPTR_FIELDNO (type
) = i
;
4711 /* Virtual function table field not found. */
4712 return error_type (pp
);
4715 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
4720 TYPE_VPTR_BASETYPE (type
) = 0;
4721 TYPE_VPTR_FIELDNO (type
) = -1;
4726 TYPE_VPTR_BASETYPE (type
) = 0;
4727 TYPE_VPTR_FIELDNO (type
) = -1;
4733 /* Read a definition of an array type,
4734 and create and return a suitable type object.
4735 Also creates a range type which represents the bounds of that
4737 static struct type
*
4738 read_array_type (pp
, type
)
4740 register struct type
*type
;
4742 struct type
*index_type
, *element_type
, *range_type
;
4746 /* Format of an array type:
4747 "ar<index type>;lower;upper;<array_contents_type>". Put code in
4750 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
4751 for these, produce a type like float[][]. */
4753 index_type
= read_type (pp
);
4755 /* Improper format of array type decl. */
4756 return error_type (pp
);
4759 if (!(**pp
>= '0' && **pp
<= '9'))
4764 lower
= read_number (pp
, ';');
4766 if (!(**pp
>= '0' && **pp
<= '9'))
4771 upper
= read_number (pp
, ';');
4773 element_type
= read_type (pp
);
4782 /* Create range type. */
4783 range_type
= (struct type
*) obstack_alloc (symbol_obstack
,
4784 sizeof (struct type
));
4785 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
4786 TYPE_TARGET_TYPE (range_type
) = index_type
;
4788 /* This should never be needed. */
4789 TYPE_LENGTH (range_type
) = sizeof (int);
4791 TYPE_NFIELDS (range_type
) = 2;
4792 TYPE_FIELDS (range_type
) =
4793 (struct field
*) obstack_alloc (symbol_obstack
,
4794 2 * sizeof (struct field
));
4795 TYPE_FIELD_BITPOS (range_type
, 0) = lower
;
4796 TYPE_FIELD_BITPOS (range_type
, 1) = upper
;
4799 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
4800 TYPE_TARGET_TYPE (type
) = element_type
;
4801 TYPE_LENGTH (type
) = (upper
- lower
+ 1) * TYPE_LENGTH (element_type
);
4802 TYPE_NFIELDS (type
) = 1;
4803 TYPE_FIELDS (type
) =
4804 (struct field
*) obstack_alloc (symbol_obstack
,
4805 sizeof (struct field
));
4806 TYPE_FIELD_TYPE (type
, 0) = range_type
;
4812 /* Read a definition of an enumeration type,
4813 and create and return a suitable type object.
4814 Also defines the symbols that represent the values of the type. */
4816 static struct type
*
4817 read_enum_type (pp
, type
)
4819 register struct type
*type
;
4824 register struct symbol
*sym
;
4826 struct pending
**symlist
;
4827 struct pending
*osyms
, *syms
;
4830 if (within_function
)
4831 symlist
= &local_symbols
;
4833 symlist
= &file_symbols
;
4835 o_nsyms
= osyms
? osyms
->nsyms
: 0;
4837 /* Read the value-names and their values.
4838 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
4839 A semicolon or comman instead of a NAME means the end. */
4840 while (**pp
&& **pp
!= ';' && **pp
!= ',')
4842 /* Check for and handle cretinous dbx symbol name continuation! */
4843 if (**pp
== '\\') *pp
= next_symbol_text ();
4846 while (*p
!= ':') p
++;
4847 name
= obsavestring (*pp
, p
- *pp
);
4849 n
= read_number (pp
, ',');
4851 sym
= (struct symbol
*) obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
4852 bzero (sym
, sizeof (struct symbol
));
4853 SYMBOL_NAME (sym
) = name
;
4854 SYMBOL_CLASS (sym
) = LOC_CONST
;
4855 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4856 SYMBOL_VALUE (sym
) = n
;
4857 add_symbol_to_list (sym
, symlist
);
4862 (*pp
)++; /* Skip the semicolon. */
4864 /* Now fill in the fields of the type-structure. */
4866 TYPE_LENGTH (type
) = sizeof (int);
4867 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4868 TYPE_NFIELDS (type
) = nsyms
;
4869 TYPE_FIELDS (type
) = (struct field
*) obstack_alloc (symbol_obstack
, sizeof (struct field
) * nsyms
);
4871 /* Find the symbols for the values and put them into the type.
4872 The symbols can be found in the symlist that we put them on
4873 to cause them to be defined. osyms contains the old value
4874 of that symlist; everything up to there was defined by us. */
4875 /* Note that we preserve the order of the enum constants, so
4876 that in something like "enum {FOO, LAST_THING=FOO}" we print
4877 FOO, not LAST_THING. */
4879 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
4884 for (; j
< syms
->nsyms
; j
++,n
++)
4886 struct symbol
*sym
= syms
->symbol
[j
];
4887 SYMBOL_TYPE (sym
) = type
;
4888 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (sym
);
4889 TYPE_FIELD_VALUE (type
, n
) = 0;
4890 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (sym
);
4891 TYPE_FIELD_BITSIZE (type
, n
) = 0;
4900 /* Read a number from the string pointed to by *PP.
4901 The value of *PP is advanced over the number.
4902 If END is nonzero, the character that ends the
4903 number must match END, or an error happens;
4904 and that character is skipped if it does match.
4905 If END is zero, *PP is left pointing to that character.
4907 If the number fits in a long, set *VALUE and set *BITS to 0.
4908 If not, set *BITS to be the number of bits in the number.
4910 If encounter garbage, set *BITS to -1. */
4913 read_huge_number (pp
, end
, valu
, bits
)
4933 /* Leading zero means octal. GCC uses this to output values larger
4934 than an int (because that would be hard in decimal). */
4941 while ((c
= *p
++) >= '0' && c
<= ('0' + radix
))
4943 if (n
<= LONG_MAX
/ radix
)
4946 n
+= c
- '0'; /* FIXME this overflows anyway */
4951 /* This depends on large values being output in octal, which is
4958 /* Ignore leading zeroes. */
4962 else if (c
== '2' || c
== '3')
4988 /* Large decimal constants are an error (because it is hard to
4989 count how many bits are in them). */
4995 /* -0x7f is the same as 0x80. So deal with it by adding one to
4996 the number of bits. */
5011 #define MAX_OF_TYPE(t) ((1 << (sizeof (t)*8 - 1)) - 1)
5012 #define MIN_OF_TYPE(t) (-(1 << (sizeof (t)*8 - 1)))
5014 static struct type
*
5015 read_range_type (pp
, typenums
)
5023 struct type
*result_type
;
5025 /* First comes a type we are a subrange of.
5026 In C it is usually 0, 1 or the type being defined. */
5027 read_type_number (pp
, rangenums
);
5028 self_subrange
= (rangenums
[0] == typenums
[0] &&
5029 rangenums
[1] == typenums
[1]);
5031 /* A semicolon should now follow; skip it. */
5035 /* The remaining two operands are usually lower and upper bounds
5036 of the range. But in some special cases they mean something else. */
5037 read_huge_number (pp
, ';', &n2
, &n2bits
);
5038 read_huge_number (pp
, ';', &n3
, &n3bits
);
5040 if (n2bits
== -1 || n3bits
== -1)
5041 return error_type (pp
);
5043 /* If limits are huge, must be large integral type. */
5044 if (n2bits
!= 0 || n3bits
!= 0)
5046 char got_signed
= 0;
5047 char got_unsigned
= 0;
5048 /* Number of bits in the type. */
5051 /* Range from 0 to <large number> is an unsigned large integral type. */
5052 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
5057 /* Range from <large number> to <large number>-1 is a large signed
5059 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
5065 if (got_signed
|| got_unsigned
)
5067 result_type
= (struct type
*) obstack_alloc (symbol_obstack
,
5068 sizeof (struct type
));
5069 bzero (result_type
, sizeof (struct type
));
5070 TYPE_LENGTH (result_type
) = nbits
/ TARGET_CHAR_BIT
;
5071 TYPE_MAIN_VARIANT (result_type
) = result_type
;
5072 TYPE_CODE (result_type
) = TYPE_CODE_INT
;
5074 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
5078 return error_type (pp
);
5081 /* A type defined as a subrange of itself, with bounds both 0, is void. */
5082 if (self_subrange
&& n2
== 0 && n3
== 0)
5083 return builtin_type_void
;
5085 /* If n3 is zero and n2 is not, we want a floating type,
5086 and n2 is the width in bytes.
5088 Fortran programs appear to use this for complex types also,
5089 and they give no way to distinguish between double and single-complex!
5090 We don't have complex types, so we would lose on all fortran files!
5091 So return type `double' for all of those. It won't work right
5092 for the complex values, but at least it makes the file loadable. */
5094 if (n3
== 0 && n2
> 0)
5096 if (n2
== sizeof (float))
5097 return builtin_type_float
;
5098 return builtin_type_double
;
5101 /* If the upper bound is -1, it must really be an unsigned int. */
5103 else if (n2
== 0 && n3
== -1)
5105 if (sizeof (int) == sizeof (long))
5106 return builtin_type_unsigned_int
;
5108 return builtin_type_unsigned_long
;
5111 /* Special case: char is defined (Who knows why) as a subrange of
5112 itself with range 0-127. */
5113 else if (self_subrange
&& n2
== 0 && n3
== 127)
5114 return builtin_type_char
;
5116 /* Assumptions made here: Subrange of self is equivalent to subrange
5119 && (self_subrange
||
5120 *dbx_lookup_type (rangenums
) == builtin_type_int
))
5122 /* an unsigned type */
5124 if (n3
== - sizeof (long long))
5125 return builtin_type_unsigned_long_long
;
5127 if (n3
== (unsigned int)~0L)
5128 return builtin_type_unsigned_int
;
5129 if (n3
== (unsigned long)~0L)
5130 return builtin_type_unsigned_long
;
5131 if (n3
== (unsigned short)~0L)
5132 return builtin_type_unsigned_short
;
5133 if (n3
== (unsigned char)~0L)
5134 return builtin_type_unsigned_char
;
5137 else if (n3
== 0 && n2
== -sizeof (long long))
5138 return builtin_type_long_long
;
5140 else if (n2
== -n3
-1)
5143 if (n3
== (1 << (8 * sizeof (int) - 1)) - 1)
5144 return builtin_type_int
;
5145 if (n3
== (1 << (8 * sizeof (long) - 1)) - 1)
5146 return builtin_type_long
;
5147 if (n3
== (1 << (8 * sizeof (short) - 1)) - 1)
5148 return builtin_type_short
;
5149 if (n3
== (1 << (8 * sizeof (char) - 1)) - 1)
5150 return builtin_type_char
;
5153 /* We have a real range type on our hands. Allocate space and
5154 return a real pointer. */
5156 /* At this point I don't have the faintest idea how to deal with
5157 a self_subrange type; I'm going to assume that this is used
5158 as an idiom, and that all of them are special cases. So . . . */
5160 return error_type (pp
);
5162 result_type
= (struct type
*) obstack_alloc (symbol_obstack
,
5163 sizeof (struct type
));
5164 bzero (result_type
, sizeof (struct type
));
5166 TYPE_TARGET_TYPE (result_type
) = (self_subrange
?
5168 *dbx_lookup_type(rangenums
));
5170 /* We have to figure out how many bytes it takes to hold this
5171 range type. I'm going to assume that anything that is pushing
5172 the bounds of a long was taken care of above. */
5173 if (n2
>= MIN_OF_TYPE(char) && n3
<= MAX_OF_TYPE(char))
5174 TYPE_LENGTH (result_type
) = 1;
5175 else if (n2
>= MIN_OF_TYPE(short) && n3
<= MAX_OF_TYPE(short))
5176 TYPE_LENGTH (result_type
) = sizeof (short);
5177 else if (n2
>= MIN_OF_TYPE(int) && n3
<= MAX_OF_TYPE(int))
5178 TYPE_LENGTH (result_type
) = sizeof (int);
5179 else if (n2
>= MIN_OF_TYPE(long) && n3
<= MAX_OF_TYPE(long))
5180 TYPE_LENGTH (result_type
) = sizeof (long);
5182 /* Ranged type doesn't fit within known sizes. */
5183 return error_type (pp
);
5185 TYPE_LENGTH (result_type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type
));
5186 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
5187 TYPE_NFIELDS (result_type
) = 2;
5188 TYPE_FIELDS (result_type
) =
5189 (struct field
*) obstack_alloc (symbol_obstack
,
5190 2 * sizeof (struct field
));
5191 bzero (TYPE_FIELDS (result_type
), 2 * sizeof (struct field
));
5192 TYPE_FIELD_BITPOS (result_type
, 0) = n2
;
5193 TYPE_FIELD_BITPOS (result_type
, 1) = n3
;
5198 /* Read a number from the string pointed to by *PP.
5199 The value of *PP is advanced over the number.
5200 If END is nonzero, the character that ends the
5201 number must match END, or an error happens;
5202 and that character is skipped if it does match.
5203 If END is zero, *PP is left pointing to that character. */
5206 read_number (pp
, end
)
5210 register char *p
= *pp
;
5211 register long n
= 0;
5215 /* Handle an optional leading minus sign. */
5223 /* Read the digits, as far as they go. */
5225 while ((c
= *p
++) >= '0' && c
<= '9')
5233 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c
, symnum
);
5242 /* Read in an argument list. This is a list of types, separated by commas
5243 and terminated with END. Return the list of types read in, or (struct type
5244 **)-1 if there is an error. */
5245 static struct type
**
5250 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
5256 /* Invalid argument list: no ','. */
5257 return (struct type
**)-1;
5260 /* Check for and handle cretinous dbx symbol name continuation! */
5262 *pp
= next_symbol_text ();
5264 types
[n
++] = read_type (pp
);
5266 *pp
+= 1; /* get past `end' (the ':' character) */
5270 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
5272 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
5274 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
5275 bzero (rval
+ n
, sizeof (struct type
*));
5279 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
5281 bcopy (types
, rval
, n
* sizeof (struct type
*));
5285 /* Copy a pending list, used to record the contents of a common
5286 block for later fixup. */
5287 static struct pending
*
5288 copy_pending (beg
, begi
, end
)
5289 struct pending
*beg
, *end
;
5292 struct pending
*new = 0;
5293 struct pending
*next
;
5295 for (next
= beg
; next
!= 0 && (next
!= end
|| begi
< end
->nsyms
);
5296 next
= next
->next
, begi
= 0)
5299 for (j
= begi
; j
< next
->nsyms
; j
++)
5300 add_symbol_to_list (next
->symbol
[j
], &new);
5305 /* Add a common block's start address to the offset of each symbol
5306 declared to be in it (by being between a BCOMM/ECOMM pair that uses
5307 the common block name). */
5310 fix_common_block (sym
, valu
)
5314 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
5315 for ( ; next
; next
= next
->next
)
5318 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
5319 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
5323 /* Register our willingness to decode symbols for SunOS and a.out and
5324 b.out files handled by BFD... */
5325 static struct sym_fns sunos_sym_fns
= {"sunOs", 6,
5326 dbx_new_init
, dbx_symfile_init
,
5327 dbx_symfile_read
, dbx_symfile_discard
};
5329 static struct sym_fns aout_sym_fns
= {"a.out", 5,
5330 dbx_new_init
, dbx_symfile_init
,
5331 dbx_symfile_read
, dbx_symfile_discard
};
5333 static struct sym_fns bout_sym_fns
= {"b.out", 5,
5334 dbx_new_init
, dbx_symfile_init
,
5335 dbx_symfile_read
, dbx_symfile_discard
};
5338 _initialize_dbxread ()
5340 add_symtab_fns(&sunos_sym_fns
);
5341 add_symtab_fns(&aout_sym_fns
);
5342 add_symtab_fns(&bout_sym_fns
);
5344 undef_types_allocated
= 20;
5345 undef_types_length
= 0;
5346 undef_types
= (struct type
**) xmalloc (undef_types_allocated
*
5347 sizeof (struct type
*));