1 /* Read a symbol table in ECOFF format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993 Free Software
4 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
5 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 /* This module provides the function mdebug_build_psymtabs. It reads
25 ECOFF debugging information into partial symbol tables. The
26 debugging information is read from two structures. A struct
27 ecoff_debug_swap includes the sizes of each ECOFF structure and
28 swapping routines; these are fixed for a particular target. A
29 struct ecoff_debug_info points to the debugging information for a
30 particular object file.
32 ECOFF symbol tables are mostly written in the byte order of the
33 target machine. However, one section of the table (the auxiliary
34 symbol information) is written in the host byte order. There is a
35 bit in the other symbol info which describes which host byte order
36 was used. ECOFF thereby takes the trophy from Intel `b.out' for
37 the most brain-dead adaptation of a file format to byte order.
39 This module can read all four of the known byte-order combinations,
40 on any type of host. */
50 #include "stabsread.h"
51 #include "complaints.h"
53 #if !defined (SEEK_SET)
58 /* These are needed if the tm.h file does not contain the necessary
59 mips specific definitions. */
61 #ifndef MIPS_EFI_SYMBOL_NAME
62 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
64 #include "coff/symconst.h"
65 typedef struct mips_extra_func_info
{
68 } *mips_extra_func_info_t
;
75 #include <sys/types.h>
78 #include <sys/param.h>
83 #include "gdb-stabs.h"
87 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
89 #include "libaout.h" /* Private BFD a.out information. */
90 #include "aout/aout64.h"
91 #include "aout/stab_gnu.h" /* STABS information */
93 #include "expression.h"
94 #include "language.h" /* Needed inside partial-stab.h */
96 /* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
97 #ifndef ECOFF_REG_TO_REGNUM
98 #define ECOFF_REG_TO_REGNUM(num) (num)
101 /* Each partial symbol table entry contains a pointer to private data
102 for the read_symtab() function to use when expanding a partial
103 symbol table entry to a full symbol table entry.
105 For mdebugread this structure contains the index of the FDR that this
106 psymtab represents and a pointer to the BFD that the psymtab was
109 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
110 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
111 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
112 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
113 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
114 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
120 const struct ecoff_debug_swap
*debug_swap
;
121 struct ecoff_debug_info
*debug_info
;
122 struct mdebug_pending
**pending_list
;
123 EXTR
*extern_tab
; /* Pointer to external symbols for this file. */
124 int extern_count
; /* Size of extern_tab. */
125 enum language pst_language
;
128 /* Things we import explicitly from other modules */
130 extern int info_verbose
;
132 /* Various complaints about symbol reading that don't abort the process */
134 static struct complaint bad_file_number_complaint
=
135 {"bad file number %d", 0, 0};
137 static struct complaint index_complaint
=
138 {"bad aux index at symbol %s", 0, 0};
140 static struct complaint aux_index_complaint
=
141 {"bad proc end in aux found from symbol %s", 0, 0};
143 static struct complaint block_index_complaint
=
144 {"bad aux index at block symbol %s", 0, 0};
146 static struct complaint unknown_ext_complaint
=
147 {"unknown external symbol %s", 0, 0};
149 static struct complaint unknown_sym_complaint
=
150 {"unknown local symbol %s", 0, 0};
152 static struct complaint unknown_st_complaint
=
153 {"with type %d", 0, 0};
155 static struct complaint block_overflow_complaint
=
156 {"block containing %s overfilled", 0, 0};
158 static struct complaint basic_type_complaint
=
159 {"cannot map ECOFF basic type 0x%x for %s", 0, 0};
161 static struct complaint unknown_type_qual_complaint
=
162 {"unknown type qualifier 0x%x", 0, 0};
164 static struct complaint array_index_type_complaint
=
165 {"illegal array index type for %s, assuming int", 0, 0};
167 static struct complaint bad_tag_guess_complaint
=
168 {"guessed tag type of %s incorrectly", 0, 0};
170 static struct complaint block_member_complaint
=
171 {"declaration block contains unhandled symbol type %d", 0, 0};
173 static struct complaint stEnd_complaint
=
174 {"stEnd with storage class %d not handled", 0, 0};
176 static struct complaint unknown_mdebug_symtype_complaint
=
177 {"unknown symbol type 0x%x", 0, 0};
179 static struct complaint stab_unknown_complaint
=
180 {"unknown stabs symbol %s", 0, 0};
182 static struct complaint pdr_for_nonsymbol_complaint
=
183 {"PDR for %s, but no symbol", 0, 0};
185 static struct complaint pdr_static_symbol_complaint
=
186 {"can't handle PDR for static proc at 0x%lx", 0, 0};
188 static struct complaint bad_setjmp_pdr_complaint
=
189 {"fixing bad setjmp PDR from libc", 0, 0};
191 static struct complaint bad_fbitfield_complaint
=
192 {"can't handle TIR fBitfield for %s", 0, 0};
194 static struct complaint bad_continued_complaint
=
195 {"illegal TIR continued for %s", 0, 0};
197 static struct complaint bad_rfd_entry_complaint
=
198 {"bad rfd entry for %s: file %d, index %d", 0, 0};
200 static struct complaint unexpected_type_code_complaint
=
201 {"unexpected type code for %s", 0, 0};
203 static struct complaint unable_to_cross_ref_complaint
=
204 {"unable to cross ref btTypedef for %s", 0, 0};
206 static struct complaint illegal_forward_tq0_complaint
=
207 {"illegal tq0 in forward typedef for %s", 0, 0};
209 static struct complaint illegal_forward_bt_complaint
=
210 {"illegal bt %d in forward typedef for %s", 0, 0};
212 static struct complaint bad_linetable_guess_complaint
=
213 {"guessed size of linetable for %s incorrectly", 0, 0};
215 static struct complaint bad_ext_ifd_complaint
=
216 {"bad ifd for external symbol: %d (max %d)", 0, 0};
218 static struct complaint bad_ext_iss_complaint
=
219 {"bad iss for external symbol: %ld (max %ld)", 0, 0};
221 /* Macros and extra defs */
223 /* Puns: hard to find whether -g was used and how */
225 #define MIN_GLEVEL GLEVEL_0
226 #define compare_glevel(a,b) \
227 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
228 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
230 /* Things that really are local to this module */
232 /* Remember what we deduced to be the source language of this psymtab. */
234 static enum language psymtab_language
= language_unknown
;
240 /* How to parse debugging information for CUR_BFD. */
242 static const struct ecoff_debug_swap
*debug_swap
;
244 /* Pointers to debugging information for CUR_BFD. */
246 static struct ecoff_debug_info
*debug_info
;
248 /* Pointer to current file decriptor record, and its index */
253 /* Index of current symbol */
257 /* Note how much "debuggable" this image is. We would like
258 to see at least one FDR with full symbols */
263 /* When examining .o files, report on undefined symbols */
265 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
267 /* Pseudo symbol to use when putting stabs into the symbol table. */
269 static char stabs_symbol
[] = STABS_SYMBOL
;
271 /* Types corresponding to btComplex, btDComplex, etc. These are here
272 rather than in gdbtypes.c or some such, because the meaning of codes
273 like btComplex is specific to the mdebug debug format. FIXME: We should
274 be using our own types thoughout this file, instead of sometimes using
277 static struct type
*mdebug_type_complex
;
278 static struct type
*mdebug_type_double_complex
;
279 static struct type
*mdebug_type_fixed_dec
;
280 static struct type
*mdebug_type_float_dec
;
281 static struct type
*mdebug_type_string
;
283 /* Forward declarations */
286 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int, char *));
289 parse_partial_symbols
PARAMS ((struct objfile
*,
290 struct section_offsets
*));
293 *get_rfd
PARAMS ((int, int));
296 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
297 char **, int, char *));
299 static struct symbol
*
300 new_symbol
PARAMS ((char *));
303 new_type
PARAMS ((char *));
305 static struct block
*
306 new_block
PARAMS ((int));
308 static struct symtab
*
309 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
311 static struct linetable
*
312 new_linetable
PARAMS ((int));
314 static struct blockvector
*
315 new_bvect
PARAMS ((int));
318 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int));
321 parse_type
PARAMS ((int, union aux_ext
*, unsigned int, int *, int, char *));
323 static struct symbol
*
324 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
325 enum address_class
));
327 static struct block
*
328 shrink_block
PARAMS ((struct block
*, struct symtab
*));
331 xzalloc
PARAMS ((unsigned int));
334 sort_blocks
PARAMS ((struct symtab
*));
337 compare_blocks
PARAMS ((const void *, const void *));
339 static struct partial_symtab
*
340 new_psymtab
PARAMS ((char *, struct objfile
*));
343 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
346 add_block
PARAMS ((struct block
*, struct symtab
*));
349 add_symbol
PARAMS ((struct symbol
*, struct block
*));
352 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
354 static struct linetable
*
355 shrink_linetable
PARAMS ((struct linetable
*));
358 mdebug_next_symbol_text
PARAMS ((void));
360 /* Address bounds for the signal trampoline in inferior, if any */
362 CORE_ADDR sigtramp_address
, sigtramp_end
;
364 /* Allocate zeroed memory */
370 PTR p
= xmalloc (size
);
376 /* Exported procedure: Builds a symtab from the PST partial one.
377 Restores the environment in effect when PST was created, delegates
378 most of the work to an ancillary procedure, and sorts
379 and reorders the symtab list at the end */
382 mdebug_psymtab_to_symtab (pst
)
383 struct partial_symtab
*pst
;
391 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
392 gdb_flush (gdb_stdout
);
395 next_symbol_text_func
= mdebug_next_symbol_text
;
397 psymtab_to_symtab_1 (pst
, pst
->filename
);
399 /* Match with global symbols. This only needs to be done once,
400 after all of the symtabs and dependencies have been read in. */
401 scan_file_globals (pst
->objfile
);
404 printf_filtered ("done.\n");
407 /* File-level interface functions */
409 /* Find a file descriptor given its index RF relative to a file CF */
419 fdrs
= debug_info
->fdr
;
421 /* Object files do not have the RFD table, all refs are absolute */
424 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
425 ((char *) debug_info
->external_rfd
427 * debug_swap
->external_rfd_size
)),
432 /* Return a safer print NAME for a file descriptor */
439 return "<stripped file>";
442 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
446 /* Read in and parse the symtab of the file OBJFILE. Symbols from
447 different sections are relocated via the SECTION_OFFSETS. */
450 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
)
451 struct objfile
*objfile
;
452 const struct ecoff_debug_swap
*swap
;
453 struct ecoff_debug_info
*info
;
454 struct section_offsets
*section_offsets
;
456 cur_bfd
= objfile
->obfd
;
460 /* Make sure all the FDR information is swapped in. */
461 if (info
->fdr
== (FDR
*) NULL
)
467 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->psymbol_obstack
,
468 (info
->symbolic_header
.ifdMax
470 fdr_src
= info
->external_fdr
;
472 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
474 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
475 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
478 parse_partial_symbols (objfile
, section_offsets
);
481 /* Check to make sure file was compiled with -g. If not, warn the
482 user of this limitation. */
483 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
485 if (max_gdbinfo
== 0)
486 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
488 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
489 gdb_flush (gdb_stdout
);
494 /* Local utilities */
496 /* Map of FDR indexes to partial symtabs */
500 struct partial_symtab
*pst
; /* the psymtab proper */
501 long n_globals
; /* exported globals (external symbols) */
502 long globals_offset
; /* cumulative */
506 /* Utility stack, used to nest procedures and blocks properly.
507 It is a doubly linked list, to avoid too many alloc/free.
508 Since we might need it quite a few times it is NOT deallocated
511 static struct parse_stack
513 struct parse_stack
*next
, *prev
;
514 struct symtab
*cur_st
; /* Current symtab. */
515 struct block
*cur_block
; /* Block in it. */
517 /* What are we parsing. stFile, or stBlock are for files and
518 blocks. stProc or stStaticProc means we have seen the start of a
519 procedure, but not the start of the block within in. When we see
520 the start of that block, we change it to stNil, without pushing a
521 new block, i.e. stNil means both a procedure and a block. */
525 int maxsyms
; /* Max symbols in this block. */
526 struct type
*cur_type
; /* Type we parse fields for. */
527 int cur_field
; /* Field number in cur_type. */
528 CORE_ADDR procadr
; /* Start addres of this procedure */
529 int numargs
; /* Its argument count */
532 *top_stack
; /* Top stack ptr */
535 /* Enter a new lexical context */
540 struct parse_stack
*new;
542 /* Reuse frames if possible */
543 if (top_stack
&& top_stack
->prev
)
544 new = top_stack
->prev
;
546 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
547 /* Initialize new frame with previous content */
550 register struct parse_stack
*prev
= new->prev
;
553 top_stack
->prev
= new;
555 new->next
= top_stack
;
560 /* Exit a lexical context */
568 top_stack
= top_stack
->next
;
572 /* Cross-references might be to things we haven't looked at
573 yet, e.g. type references. To avoid too many type
574 duplications we keep a quick fixup table, an array
575 of lists of references indexed by file descriptor */
577 struct mdebug_pending
579 struct mdebug_pending
*next
; /* link */
580 char *s
; /* the unswapped symbol */
581 struct type
*t
; /* its partial type descriptor */
585 /* The pending information is kept for an entire object file, and used
586 to be in the sym_private field. I took it out when I split
587 mdebugread from mipsread, because this might not be the only type
588 of symbols read from an object file. Instead, we allocate the
589 pending information table when we create the partial symbols, and
590 we store a pointer to the single table in each psymtab. */
592 static struct mdebug_pending
**pending_list
;
594 /* Check whether we already saw symbol SH in file FH */
596 static struct mdebug_pending
*
597 is_pending_symbol (fh
, sh
)
601 int f_idx
= fh
- debug_info
->fdr
;
602 register struct mdebug_pending
*p
;
604 /* Linear search is ok, list is typically no more than 10 deep */
605 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
611 /* Add a new symbol SH of type T */
614 add_pending (fh
, sh
, t
)
619 int f_idx
= fh
- debug_info
->fdr
;
620 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
622 /* Make sure we do not make duplicates */
625 p
= ((struct mdebug_pending
*)
626 obstack_alloc (¤t_objfile
->psymbol_obstack
,
627 sizeof (struct mdebug_pending
)));
630 p
->next
= pending_list
[f_idx
];
631 pending_list
[f_idx
] = p
;
636 /* Parsing Routines proper. */
638 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
639 For blocks, procedures and types we open a new lexical context.
640 This is basically just a big switch on the symbol's type. Argument
641 AX is the base pointer of aux symbols for this file (fh->iauxBase).
642 EXT_SH points to the unswapped symbol, which is needed for struct,
643 union, etc., types; it is NULL for an EXTR. BIGEND says whether
644 aux symbols are big-endian or little-endian. Return count of
645 SYMR's handled (normally one). */
648 parse_symbol (sh
, ax
, ext_sh
, bigend
)
654 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
655 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
656 debug_swap
->swap_sym_in
;
660 struct mdebug_pending
*pend
;
664 enum address_class
class;
666 long svalue
= sh
->value
;
669 if (ext_sh
== (char *) NULL
)
670 name
= debug_info
->ssext
+ sh
->iss
;
672 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
679 case stGlobal
: /* external symbol, goes into global block */
681 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
683 s
= new_symbol (name
);
684 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
687 case stStatic
: /* static data, goes into current block. */
689 b
= top_stack
->cur_block
;
690 s
= new_symbol (name
);
691 if (sh
->sc
== scCommon
)
693 /* It is a FORTRAN common block. At least for SGI Fortran the
694 address is not in the symbol; we need to fix it later in
695 scan_file_globals. */
696 int bucket
= hashname (SYMBOL_NAME (s
));
697 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
698 global_sym_chain
[bucket
] = s
;
701 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
704 case stLocal
: /* local variable, goes into current block */
705 if (sh
->sc
== scRegister
)
707 class = LOC_REGISTER
;
708 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
712 b
= top_stack
->cur_block
;
713 s
= new_symbol (name
);
714 SYMBOL_VALUE (s
) = svalue
;
716 data
: /* Common code for symbols describing data */
717 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
718 SYMBOL_CLASS (s
) = class;
721 /* Type could be missing in a number of cases */
722 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
723 sh
->index
== 0xfffff)
724 SYMBOL_TYPE (s
) = builtin_type_int
; /* undefined? */
726 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
727 /* Value of a data symbol is its memory address */
730 case stParam
: /* arg to procedure, goes into current block */
732 top_stack
->numargs
++;
734 /* Special GNU C++ name. */
735 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
736 name
= "this"; /* FIXME, not alloc'd in obstack */
737 s
= new_symbol (name
);
739 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
743 /* Pass by value in register. */
744 SYMBOL_CLASS(s
) = LOC_REGPARM
;
745 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
748 /* Pass by reference on stack. */
749 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
752 /* Pass by reference in register. */
753 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
754 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
757 /* Pass by value on stack. */
758 SYMBOL_CLASS(s
) = LOC_ARG
;
761 SYMBOL_VALUE (s
) = svalue
;
762 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
763 add_symbol (s
, top_stack
->cur_block
);
765 /* FIXME: This has not been tested. See dbxread.c */
766 /* Add the type of this parameter to the function/procedure
767 type of this block. */
768 add_param_to_type (&top_stack
->cur_block
->function
->type
, s
);
772 case stLabel
: /* label, goes into current block */
773 s
= new_symbol (name
);
774 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
775 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
776 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
777 SYMBOL_TYPE (s
) = builtin_type_int
;
778 add_symbol (s
, top_stack
->cur_block
);
781 case stProc
: /* Procedure, usually goes into global block */
782 case stStaticProc
: /* Static procedure, goes into current block */
783 s
= new_symbol (name
);
784 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
785 SYMBOL_CLASS (s
) = LOC_BLOCK
;
786 /* Type of the return value */
787 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
788 t
= builtin_type_int
;
790 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
791 b
= top_stack
->cur_block
;
792 if (sh
->st
== stProc
)
794 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
795 /* The next test should normally be true, but provides a
796 hook for nested functions (which we don't want to make
798 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
799 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
800 /* Irix 5 sometimes has duplicate names for the same
801 function. We want to add such names up at the global
802 level, not as a nested function. */
803 else if (sh
->value
== top_stack
->procadr
)
804 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
808 /* Make a type for the procedure itself */
810 /* FIXME: This has not been tested yet! See dbxread.c */
811 /* Generate a template for the type of this function. The
812 types of the arguments will be added as we read the symbol
814 memcpy (lookup_function_type (t
), SYMBOL_TYPE (s
), sizeof (struct type
));
816 SYMBOL_TYPE (s
) = lookup_function_type (t
);
819 /* Create and enter a new lexical context */
820 b
= new_block (top_stack
->maxsyms
);
821 SYMBOL_BLOCK_VALUE (s
) = b
;
822 BLOCK_FUNCTION (b
) = s
;
823 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
824 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
825 add_block (b
, top_stack
->cur_st
);
827 /* Not if we only have partial info */
828 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
832 top_stack
->cur_block
= b
;
833 top_stack
->blocktype
= sh
->st
;
834 top_stack
->cur_type
= SYMBOL_TYPE (s
);
835 top_stack
->cur_field
= -1;
836 top_stack
->procadr
= sh
->value
;
837 top_stack
->numargs
= 0;
840 /* Beginning of code for structure, union, and enum definitions.
841 They all share a common set of local variables, defined here. */
843 enum type_code type_code
;
849 case stStruct
: /* Start a block defining a struct type */
850 type_code
= TYPE_CODE_STRUCT
;
851 goto structured_common
;
853 case stUnion
: /* Start a block defining a union type */
854 type_code
= TYPE_CODE_UNION
;
855 goto structured_common
;
857 case stEnum
: /* Start a block defining an enum type */
858 type_code
= TYPE_CODE_ENUM
;
859 goto structured_common
;
861 case stBlock
: /* Either a lexical block, or some type */
862 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
)
863 goto case_stBlock_code
; /* Lexical block */
865 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
867 /* Common code for handling struct, union, enum, and/or as-yet-
868 unknown-type blocks of info about structured data. `type_code'
869 has been set to the proper TYPE_CODE, if we know it. */
872 top_stack
->blocktype
= stBlock
;
874 /* First count the number of fields and the highest value. */
877 for (ext_tsym
= ext_sh
+ external_sym_size
;
879 ext_tsym
+= external_sym_size
)
883 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
891 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
892 /* If the type of the member is Nil (or Void),
893 without qualifiers, assume the tag is an
895 if (tsym
.index
== indexNil
)
896 type_code
= TYPE_CODE_ENUM
;
899 ecoff_swap_tir_in (bigend
,
900 &ax
[tsym
.index
].a_ti
,
902 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
904 type_code
= TYPE_CODE_ENUM
;
907 if (tsym
.value
> max_value
)
908 max_value
= tsym
.value
;
917 /* This is a no-op; is it trying to tell us something
918 we should be checking? */
919 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
923 /* This is something like a struct within a
924 struct. Skip over the fields of the inner
925 struct. The -1 is because the for loop will
926 increment ext_tsym. */
927 ext_tsym
= ((char *) debug_info
->external_sym
928 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
929 * external_sym_size
));
935 /* mips cc puts out a typedef for struct x if it is not yet
936 defined when it encounters
937 struct y { struct x *xp; };
942 complain (&block_member_complaint
, tsym
.st
);
947 /* In an stBlock, there is no way to distinguish structs,
948 unions, and enums at this point. This is a bug in the
949 original design (that has been fixed with the recent
950 addition of the stStruct, stUnion, and stEnum symbol
951 types.) The way you can tell is if/when you see a variable
952 or field of that type. In that case the variable's type
953 (in the AUX table) says if the type is struct, union, or
954 enum, and points back to the stBlock here. So you can
955 patch the tag kind up later - but only if there actually is
956 a variable or field of that type.
958 So until we know for sure, we will guess at this point.
960 If the first member has index==indexNil or a void type,
961 assume we have an enumeration.
962 Otherwise, if there is more than one member, and all
963 the members have offset 0, assume we have a union.
964 Otherwise, assume we have a struct.
966 The heuristic could guess wrong in the case of of an
967 enumeration with no members or a union with one (or zero)
968 members, or when all except the last field of a struct have
969 width zero. These are uncommon and/or illegal situations,
970 and in any case guessing wrong probably doesn't matter
973 But if we later do find out we were wrong, we fixup the tag
974 kind. Members of an enumeration must be handled
975 differently from struct/union fields, and that is harder to
976 patch up, but luckily we shouldn't need to. (If there are
977 any enumeration members, we can tell for sure it's an enum
980 if (type_code
== TYPE_CODE_UNDEF
)
981 if (nfields
> 1 && max_value
== 0)
982 type_code
= TYPE_CODE_UNION
;
984 type_code
= TYPE_CODE_STRUCT
;
986 /* Create a new type or use the pending type. */
987 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
988 if (pend
== (struct mdebug_pending
*) NULL
)
991 add_pending (cur_fdr
, ext_sh
, t
);
996 /* Do not set the tag name if it is a compiler generated tag name
997 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
998 Alpha cc puts out an sh->iss of zero for those. */
999 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1000 TYPE_TAG_NAME (t
) = NULL
;
1002 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1005 TYPE_CODE (t
) = type_code
;
1006 TYPE_LENGTH (t
) = sh
->value
;
1007 TYPE_NFIELDS (t
) = nfields
;
1008 TYPE_FIELDS (t
) = f
= ((struct field
*)
1010 nfields
* sizeof (struct field
)));
1012 if (type_code
== TYPE_CODE_ENUM
)
1014 /* This is a non-empty enum. */
1016 /* DEC c89 has the number of enumerators in the sh.value field,
1017 not the type length, so we have to compensate for that
1018 incompatibility quirk.
1019 This might do the wrong thing for an enum with one or two
1020 enumerators and gcc -gcoff -fshort-enums, but these cases
1021 are hopefully rare enough. */
1022 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
))
1023 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1024 for (ext_tsym
= ext_sh
+ external_sym_size
;
1026 ext_tsym
+= external_sym_size
)
1029 struct symbol
*enum_sym
;
1031 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1033 if (tsym
.st
!= stMember
)
1036 f
->bitpos
= tsym
.value
;
1038 f
->name
= debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1041 enum_sym
= ((struct symbol
*)
1042 obstack_alloc (¤t_objfile
->symbol_obstack
,
1043 sizeof (struct symbol
)));
1044 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1045 SYMBOL_NAME (enum_sym
) = f
->name
;
1046 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1047 SYMBOL_TYPE (enum_sym
) = t
;
1048 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1049 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1050 add_symbol (enum_sym
, top_stack
->cur_block
);
1052 /* Skip the stMembers that we've handled. */
1057 /* make this the current type */
1058 top_stack
->cur_type
= t
;
1059 top_stack
->cur_field
= 0;
1061 /* Do not create a symbol for alpha cc unnamed structs. */
1065 /* gcc puts out an empty struct for an opaque struct definitions,
1066 do not create a symbol for it either. */
1067 if (TYPE_NFIELDS (t
) == 0)
1069 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1073 s
= new_symbol (name
);
1074 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1075 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1076 SYMBOL_VALUE (s
) = 0;
1077 SYMBOL_TYPE (s
) = t
;
1078 add_symbol (s
, top_stack
->cur_block
);
1081 /* End of local variables shared by struct, union, enum, and
1082 block (as yet unknown struct/union/enum) processing. */
1086 /* beginnning of (code) block. Value of symbol
1087 is the displacement from procedure start */
1088 push_parse_stack ();
1090 /* Do not start a new block if this is the outermost block of a
1091 procedure. This allows the LOC_BLOCK symbol to point to the
1092 block with the local variables, so funcname::var works. */
1093 if (top_stack
->blocktype
== stProc
1094 || top_stack
->blocktype
== stStaticProc
)
1096 top_stack
->blocktype
= stNil
;
1100 top_stack
->blocktype
= stBlock
;
1101 b
= new_block (top_stack
->maxsyms
);
1102 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1103 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1104 top_stack
->cur_block
= b
;
1105 add_block (b
, top_stack
->cur_st
);
1108 case stEnd
: /* end (of anything) */
1109 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
)
1111 /* Finished with type */
1112 top_stack
->cur_type
= 0;
1114 else if (sh
->sc
== scText
&&
1115 (top_stack
->blocktype
== stProc
||
1116 top_stack
->blocktype
== stStaticProc
))
1118 /* Finished with procedure */
1119 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1120 struct mips_extra_func_info
*e
;
1124 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1126 /* Make up special symbol to contain procedure specific info */
1127 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1128 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1129 SYMBOL_CLASS (s
) = LOC_CONST
;
1130 SYMBOL_TYPE (s
) = builtin_type_void
;
1131 e
= ((struct mips_extra_func_info
*)
1132 obstack_alloc (¤t_objfile
->symbol_obstack
,
1133 sizeof (struct mips_extra_func_info
)));
1134 SYMBOL_VALUE (s
) = (long) e
;
1135 e
->numargs
= top_stack
->numargs
;
1136 add_symbol (s
, top_stack
->cur_block
);
1138 /* Reallocate symbols, saving memory */
1139 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1141 /* f77 emits proc-level with address bounds==[0,0],
1142 So look for such child blocks, and patch them. */
1143 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1145 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1146 if (BLOCK_SUPERBLOCK (b_bad
) == b
1147 && BLOCK_START (b_bad
) == top_stack
->procadr
1148 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1150 BLOCK_START (b_bad
) = BLOCK_START (b
);
1151 BLOCK_END (b_bad
) = BLOCK_END (b
);
1155 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1157 /* End of (code) block. The value of the symbol is the
1158 displacement from the procedure`s start address of the
1159 end of this block. */
1160 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1161 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1163 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1165 /* End of outermost block. Pop parse stack and ignore. The
1166 following stEnd of stProc will take care of the block. */
1169 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1171 /* End of file. Pop parse stack and ignore. Higher
1172 level code deals with this. */
1176 complain (&stEnd_complaint
, sh
->sc
);
1178 pop_parse_stack (); /* restore previous lexical context */
1181 case stMember
: /* member of struct or union */
1182 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1184 f
->bitpos
= sh
->value
;
1186 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1187 f
->bitsize
= bitsize
;
1190 case stTypedef
: /* type definition */
1191 /* Typedefs for forward declarations and opaque structs from alpha cc
1192 are handled by cross_ref, skip them. */
1196 /* Parse the type or use the pending type. */
1197 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1198 if (pend
== (struct mdebug_pending
*) NULL
)
1200 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1201 add_pending (cur_fdr
, ext_sh
, t
);
1206 /* mips cc puts out a typedef with the name of the struct for forward
1207 declarations. These should not go into the symbol table and
1208 TYPE_NAME should not be set for them.
1209 They can't be distinguished from an intentional typedef to
1210 the same name however:
1212 struct x { int ix; int jx; };
1216 struct xx {int ixx; int jxx; };
1217 generates a cross referencing stTypedef for x and xx.
1218 The user visible effect of this is that the type of a pointer
1219 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1220 The problem is fixed with alpha cc. */
1222 s
= new_symbol (name
);
1223 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1224 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1225 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1226 SYMBOL_TYPE (s
) = t
;
1227 add_symbol (s
, top_stack
->cur_block
);
1229 /* Incomplete definitions of structs should not get a name. */
1230 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1231 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1232 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1233 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1235 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1236 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1238 /* If we are giving a name to a type such as "pointer to
1239 foo" or "function returning foo", we better not set
1240 the TYPE_NAME. If the program contains "typedef char
1241 *caddr_t;", we don't want all variables of type char
1242 * to print as caddr_t. This is not just a
1243 consequence of GDB's type management; CC and GCC (at
1244 least through version 2.4) both output variables of
1245 either type char * or caddr_t with the type
1246 refering to the stTypedef symbol for caddr_t. If a future
1247 compiler cleans this up it GDB is not ready for it
1248 yet, but if it becomes ready we somehow need to
1249 disable this check (without breaking the PCC/GCC2.4
1254 Fortunately, this check seems not to be necessary
1255 for anything except pointers or functions. */
1258 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1262 case stFile
: /* file name */
1263 push_parse_stack ();
1264 top_stack
->blocktype
= sh
->st
;
1267 /* I`ve never seen these for C */
1269 break; /* register relocation */
1271 break; /* forwarding address */
1273 break; /* constant */
1275 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1282 /* Parse the type information provided in the raw AX entries for
1283 the symbol SH. Return the bitfield size in BS, in case.
1284 We must byte-swap the AX entries before we use them; BIGEND says whether
1285 they are big-endian or little-endian (from fh->fBigendian). */
1287 static struct type
*
1288 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1291 unsigned int aux_index
;
1296 /* Null entries in this map are treated specially */
1297 static struct type
**map_bt
[] =
1299 &builtin_type_void
, /* btNil */
1301 &builtin_type_char
, /* btChar */
1302 &builtin_type_unsigned_char
,/* btUChar */
1303 &builtin_type_short
, /* btShort */
1304 &builtin_type_unsigned_short
, /* btUShort */
1305 &builtin_type_int
, /* btInt */
1306 &builtin_type_unsigned_int
, /* btUInt */
1307 &builtin_type_long
, /* btLong */
1308 &builtin_type_unsigned_long
,/* btULong */
1309 &builtin_type_float
, /* btFloat */
1310 &builtin_type_double
, /* btDouble */
1317 &mdebug_type_complex
, /* btComplex */
1318 &mdebug_type_double_complex
, /* btDComplex */
1320 &mdebug_type_fixed_dec
, /* btFixedDec */
1321 &mdebug_type_float_dec
, /* btFloatDec */
1322 &mdebug_type_string
, /* btString */
1325 &builtin_type_void
, /* btVoid */
1326 0, /* DEC C++: Pointer to member */
1327 0, /* DEC C++: Virtual function table */
1328 0, /* DEC C++: Class (Record) */
1329 &builtin_type_long
, /* btLong64 */
1330 &builtin_type_unsigned_long
, /* btULong64 */
1331 &builtin_type_long_long
, /* btLongLong64 */
1332 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1333 &builtin_type_unsigned_long
, /* btAdr64 */
1334 &builtin_type_long
, /* btInt64 */
1335 &builtin_type_unsigned_long
, /* btUInt64 */
1339 struct type
*tp
= 0;
1340 enum type_code type_code
= TYPE_CODE_UNDEF
;
1342 /* Handle corrupt aux indices. */
1343 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1345 complain (&index_complaint
, sym_name
);
1346 return builtin_type_int
;
1350 /* Use aux as a type information record, map its basic type. */
1351 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1352 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1354 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1355 return builtin_type_int
;
1359 tp
= *map_bt
[t
->bt
];
1364 /* Cannot use builtin types -- build our own */
1368 tp
= lookup_pointer_type (builtin_type_void
);
1371 type_code
= TYPE_CODE_STRUCT
;
1374 type_code
= TYPE_CODE_UNION
;
1377 type_code
= TYPE_CODE_ENUM
;
1380 type_code
= TYPE_CODE_RANGE
;
1383 type_code
= TYPE_CODE_SET
;
1386 /* alpha cc uses this for typedefs. The true type will be
1387 obtained by crossreferencing below. */
1388 type_code
= TYPE_CODE_ERROR
;
1391 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1392 return builtin_type_int
;
1396 /* Move on to next aux */
1401 /* Inhibit core dumps with some cfront generated objects that
1403 if (bs
== (int *)NULL
)
1405 complain (&bad_fbitfield_complaint
, sym_name
);
1406 return builtin_type_int
;
1408 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1412 /* All these types really point to some (common) MIPS type
1413 definition, and only the type-qualifiers fully identify
1414 them. We'll make the same effort at sharing. */
1415 if (t
->bt
== btStruct
||
1419 /* btSet (I think) implies that the name is a tag name, not a typedef
1420 name. This apparently is a MIPS extension for C sets. */
1425 /* Try to cross reference this type, build new type on failure. */
1426 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1427 if (tp
== (struct type
*) NULL
)
1428 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1430 /* DEC c89 produces cross references to qualified aggregate types,
1431 dereference them. */
1432 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1433 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1434 tp
= tp
->target_type
;
1436 /* Make sure that TYPE_CODE(tp) has an expected type code.
1437 Any type may be returned from cross_ref if file indirect entries
1439 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1440 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1441 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1443 complain (&unexpected_type_code_complaint
, sym_name
);
1448 /* Usually, TYPE_CODE(tp) is already type_code. The main
1449 exception is if we guessed wrong re struct/union/enum.
1450 But for struct vs. union a wrong guess is harmless, so
1451 don't complain(). */
1452 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1453 && type_code
!= TYPE_CODE_ENUM
)
1454 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1455 && type_code
== TYPE_CODE_ENUM
))
1457 complain (&bad_tag_guess_complaint
, sym_name
);
1460 if (TYPE_CODE (tp
) != type_code
)
1462 TYPE_CODE (tp
) = type_code
;
1465 /* Do not set the tag name if it is a compiler generated tag name
1466 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1467 if (name
[0] == '.' || name
[0] == '\0')
1468 TYPE_TAG_NAME (tp
) = NULL
;
1469 else if (TYPE_TAG_NAME (tp
) == NULL
1470 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1471 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1472 ¤t_objfile
->type_obstack
);
1476 /* All these types really point to some (common) MIPS type
1477 definition, and only the type-qualifiers fully identify
1478 them. We'll make the same effort at sharing.
1479 FIXME: btIndirect cannot happen here as it is handled by the
1480 switch t->bt above. And we are not doing any guessing on range types. */
1481 if (t
->bt
== btIndirect
||
1486 /* Try to cross reference this type, build new type on failure. */
1487 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1488 if (tp
== (struct type
*) NULL
)
1489 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1491 /* Make sure that TYPE_CODE(tp) has an expected type code.
1492 Any type may be returned from cross_ref if file indirect entries
1494 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1496 complain (&unexpected_type_code_complaint
, sym_name
);
1500 /* Usually, TYPE_CODE(tp) is already type_code. The main
1501 exception is if we guessed wrong re struct/union/enum. */
1502 if (TYPE_CODE (tp
) != type_code
)
1504 complain (&bad_tag_guess_complaint
, sym_name
);
1505 TYPE_CODE (tp
) = type_code
;
1507 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1508 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1509 ¤t_objfile
->type_obstack
);
1512 if (t
->bt
== btTypedef
)
1516 /* Try to cross reference this type, it should succeed. */
1517 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1518 if (tp
== (struct type
*) NULL
)
1520 complain (&unable_to_cross_ref_complaint
, sym_name
);
1521 tp
= builtin_type_int
;
1525 /* Deal with range types */
1526 if (t
->bt
== btRange
)
1528 TYPE_NFIELDS (tp
) = 2;
1529 TYPE_FIELDS (tp
) = ((struct field
*)
1530 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1531 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1532 ¤t_objfile
->type_obstack
);
1533 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1535 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1536 ¤t_objfile
->type_obstack
);
1537 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1541 /* Parse all the type qualifiers now. If there are more
1542 than 6 the game will continue in the next aux */
1546 #define PARSE_TQ(tq) \
1547 if (t->tq != tqNil) \
1548 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1560 /* mips cc 2.x and gcc never put out continued aux entries. */
1564 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1568 /* Complain for illegal continuations due to corrupt aux entries. */
1570 complain (&bad_continued_complaint
, sym_name
);
1575 /* Make up a complex type from a basic one. Type is passed by
1576 reference in TPP and side-effected as necessary. The type
1577 qualifier TQ says how to handle the aux symbols at AX for
1578 the symbol SX we are currently analyzing. BIGEND says whether
1579 aux symbols are big-endian or little-endian.
1580 Returns the number of aux symbols we parsed. */
1583 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1594 /* Used in array processing */
1605 t
= lookup_pointer_type (*tpp
);
1610 t
= lookup_function_type (*tpp
);
1617 /* Determine and record the domain type (type of index) */
1618 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, &rndx
);
1624 rf
= AUX_GET_ISYM (bigend
, ax
);
1627 fh
= get_rfd (fd
, rf
);
1629 indx
= parse_type (fd
, debug_info
->external_aux
+ fh
->iauxBase
,
1630 id
, (int *) NULL
, bigend
, sym_name
);
1632 /* The bounds type should be an integer type, but might be anything
1633 else due to corrupt aux entries. */
1634 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1636 complain (&array_index_type_complaint
, sym_name
);
1637 indx
= builtin_type_int
;
1640 /* Get the bounds, and create the array type. */
1642 lower
= AUX_GET_DNLOW (bigend
, ax
);
1644 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1646 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1648 range
= create_range_type ((struct type
*) NULL
, indx
,
1651 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1653 /* We used to fill in the supplied array element bitsize
1654 here if the TYPE_LENGTH of the target type was zero.
1655 This happens for a `pointer to an array of anonymous structs',
1656 but in this case the array element bitsize is also zero,
1657 so nothing is gained.
1658 And we used to check the TYPE_LENGTH of the target type against
1659 the supplied array element bitsize.
1660 gcc causes a mismatch for `pointer to array of object',
1661 since the sdb directives it uses do not have a way of
1662 specifying the bitsize, but it does no harm (the
1663 TYPE_LENGTH should be correct) and we should be able to
1664 ignore the erroneous bitsize from the auxiliary entry safely.
1665 dbx seems to ignore it too. */
1671 /* Volatile -- currently ignored */
1675 /* Const -- currently ignored */
1679 complain (&unknown_type_qual_complaint
, tq
);
1685 /* Parse a procedure descriptor record PR. Note that the procedure is
1686 parsed _after_ the local symbols, now we just insert the extra
1687 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1688 already been placed in the procedure's main block. Note also that
1689 images that have been partially stripped (ld -x) have been deprived
1690 of local symbols, and we have to cope with them here. FIRST_OFF is
1691 the offset of the first procedure for this FDR; we adjust the
1692 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1693 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1694 in question, or NULL to use top_stack->cur_block. */
1696 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long));
1699 parse_procedure (pr
, search_symtab
, first_off
)
1701 struct symtab
*search_symtab
;
1702 unsigned long first_off
;
1704 struct symbol
*s
, *i
;
1706 struct mips_extra_func_info
*e
;
1709 /* Simple rule to find files linked "-x" */
1710 if (cur_fdr
->rss
== -1)
1714 /* Static procedure at address pr->adr. Sigh. */
1715 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1723 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1724 ((char *) debug_info
->external_ext
1726 * debug_swap
->external_ext_size
)),
1728 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1736 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1737 ((char *) debug_info
->external_sym
1738 + ((cur_fdr
->isymBase
+ pr
->isym
)
1739 * debug_swap
->external_sym_size
)),
1741 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1744 if (search_symtab
!= NULL
)
1747 /* This loses both in the case mentioned (want a static, find a global),
1748 but also if we are looking up a non-mangled name which happens to
1749 match the name of a mangled function. */
1750 /* We have to save the cur_fdr across the call to lookup_symbol.
1751 If the pdr is for a static function and if a global function with
1752 the same name exists, lookup_symbol will eventually read in the symtab
1753 for the global function and clobber cur_fdr. */
1754 FDR
*save_cur_fdr
= cur_fdr
;
1755 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1756 cur_fdr
= save_cur_fdr
;
1760 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1766 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1767 VAR_NAMESPACE
, LOC_BLOCK
);
1771 b
= SYMBOL_BLOCK_VALUE (s
);
1775 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1779 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1780 s
= new_symbol (sh_name
);
1781 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1782 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1783 /* Donno its type, hope int is ok */
1784 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1785 add_symbol (s
, top_stack
->cur_block
);
1786 /* Wont have symbols for this one */
1788 SYMBOL_BLOCK_VALUE (s
) = b
;
1789 BLOCK_FUNCTION (b
) = s
;
1790 BLOCK_START (b
) = pr
->adr
;
1791 /* BOUND used to be the end of procedure's text, but the
1792 argument is no longer passed in. */
1793 BLOCK_END (b
) = bound
;
1794 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1795 add_block (b
, top_stack
->cur_st
);
1799 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1803 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1805 e
->pdr
.isym
= (long) s
;
1806 e
->pdr
.adr
+= cur_fdr
->adr
- first_off
;
1808 /* Correct incorrect setjmp procedure descriptor from the library
1809 to make backtrace through setjmp work. */
1810 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1812 complain (&bad_setjmp_pdr_complaint
, 0);
1813 e
->pdr
.pcreg
= RA_REGNUM
;
1814 e
->pdr
.regmask
= 0x80000000;
1815 e
->pdr
.regoffset
= -4;
1818 /* Fake PC_REGNUM for alpha __sigtramp so that read_next_frame_reg
1819 will use the saved user pc from the sigcontext. */
1820 if (STREQ (sh_name
, "__sigtramp"))
1821 e
->pdr
.pcreg
= PC_REGNUM
;
1822 /* Make the same patch for Irix. */
1823 if (STREQ (sh_name
, "_sigtramp"))
1824 e
->pdr
.pcreg
= PC_REGNUM
;
1828 /* Parse the external symbol ES. Just call parse_symbol() after
1829 making sure we know where the aux are for it. For procedures,
1830 parsing of the PDRs has already provided all the needed
1831 information, we only parse them if SKIP_PROCEDURES is false,
1832 and only if this causes no symbol duplication.
1833 BIGEND says whether aux entries are big-endian or little-endian.
1835 This routine clobbers top_stack->cur_block and ->cur_st. */
1838 parse_external (es
, skip_procedures
, bigend
)
1840 int skip_procedures
;
1845 if (es
->ifd
!= ifdNil
)
1848 cur_fdr
= debug_info
->fdr
+ cur_fd
;
1849 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
1853 cur_fdr
= debug_info
->fdr
;
1857 /* Reading .o files */
1858 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1861 switch (es
->asym
.st
)
1864 /* These are generated for static symbols in .o files,
1885 /* FIXME: Turn this into a complaint? */
1887 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1888 what
, debug_info
->ssext
+ es
->asym
.iss
,
1889 fdr_name (cur_fdr
));
1893 switch (es
->asym
.st
)
1896 /* If we have full symbols we do not need more */
1897 if (skip_procedures
)
1899 if (mylookup_symbol (debug_info
->ssext
+ es
->asym
.iss
,
1900 top_stack
->cur_block
,
1901 VAR_NAMESPACE
, LOC_BLOCK
))
1906 /* Note that the case of a symbol with indexNil must be handled
1907 anyways by parse_symbol(). */
1908 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
);
1915 /* Parse the line number info for file descriptor FH into
1916 GDB's linetable LT. MIPS' encoding requires a little bit
1917 of magic to get things out. Note also that MIPS' line
1918 numbers can go back and forth, apparently we can live
1919 with that and do not need to reorder our linetables */
1922 parse_lines (fh
, pr
, lt
, maxlines
)
1925 struct linetable
*lt
;
1928 unsigned char *base
;
1930 int delta
, count
, lineno
= 0;
1931 unsigned long first_off
= pr
->adr
;
1933 if (fh
->cbLine
== 0)
1936 base
= debug_info
->line
+ fh
->cbLineOffset
;
1938 /* Scan by procedure descriptors */
1940 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
1944 unsigned char *halt
;
1946 /* No code for this one */
1947 if (pr
->iline
== ilineNil
||
1948 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1951 /* Determine start and end address of compressed line bytes for
1953 base
= debug_info
->line
+ fh
->cbLineOffset
;
1954 if (j
!= (fh
->cpd
- 1))
1955 halt
= base
+ pr
[1].cbLineOffset
;
1957 halt
= base
+ fh
->cbLine
;
1958 base
+= pr
->cbLineOffset
;
1960 adr
= fh
->adr
+ pr
->adr
- first_off
;
1961 l
= adr
>> 2; /* in words */
1962 for (lineno
= pr
->lnLow
; base
< halt
; )
1964 count
= *base
& 0x0f;
1965 delta
= *base
++ >> 4;
1970 delta
= (base
[0] << 8) | base
[1];
1971 if (delta
>= 0x8000)
1975 lineno
+= delta
; /* first delta is 0 */
1977 /* Complain if the line table overflows. Could happen
1978 with corrupt binaries. */
1979 if (lt
->nitems
>= maxlines
)
1981 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
1984 k
= add_line (lt
, lineno
, l
, k
);
1990 /* Master parsing procedure for first-pass reading of file symbols
1991 into a partial_symtab. */
1994 parse_partial_symbols (objfile
, section_offsets
)
1995 struct objfile
*objfile
;
1996 struct section_offsets
*section_offsets
;
1998 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
1999 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2000 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2001 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2002 = debug_swap
->swap_ext_in
;
2003 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2004 = debug_swap
->swap_sym_in
;
2005 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2006 = debug_swap
->swap_rfd_in
;
2008 HDRR
*hdr
= &debug_info
->symbolic_header
;
2009 /* Running pointers */
2014 register EXTR
*ext_in
;
2017 struct partial_symtab
*pst
;
2019 int past_first_source_file
= 0;
2021 /* List of current psymtab's include files */
2022 char **psymtab_include_list
;
2023 int includes_allocated
;
2026 struct pst_map
*fdr_to_pst
;
2027 /* Index within current psymtab dependency list */
2028 struct partial_symtab
**dependency_list
;
2029 int dependencies_used
, dependencies_allocated
;
2030 struct cleanup
*old_chain
;
2032 enum language prev_language
;
2034 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2035 sizeof (EXTR
) * hdr
->iextMax
);
2037 includes_allocated
= 30;
2039 psymtab_include_list
= (char **) alloca (includes_allocated
*
2041 next_symbol_text_func
= mdebug_next_symbol_text
;
2043 dependencies_allocated
= 30;
2044 dependencies_used
= 0;
2046 (struct partial_symtab
**) alloca (dependencies_allocated
*
2047 sizeof (struct partial_symtab
*));
2049 last_source_file
= NULL
;
2054 * Only parse the Local and External symbols, and the Relative FDR.
2055 * Fixup enough of the loader symtab to be able to use it.
2056 * Allocate space only for the file's portions we need to
2061 max_glevel
= MIN_GLEVEL
;
2063 /* Allocate the map FDR -> PST.
2064 Minor hack: -O3 images might claim some global data belongs
2065 to FDR -1. We`ll go along with that */
2066 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2067 old_chain
= make_cleanup (free
, fdr_to_pst
);
2070 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2071 fdr_to_pst
[-1].pst
= pst
;
2075 /* Allocate the global pending list. */
2077 ((struct mdebug_pending
**)
2078 obstack_alloc (&objfile
->psymbol_obstack
,
2079 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2080 memset ((PTR
) pending_list
, 0,
2081 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2083 /* Pass 0 over external syms: swap them in. */
2084 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2085 make_cleanup (free
, ext_block
);
2087 ext_out
= (char *) debug_info
->external_ext
;
2088 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2090 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2091 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2093 /* Pass 1 over external syms: Presize and partition the list */
2095 ext_in_end
= ext_in
+ hdr
->iextMax
;
2096 for (; ext_in
< ext_in_end
; ext_in
++)
2098 /* See calls to complain below. */
2099 if (ext_in
->ifd
>= -1
2100 && ext_in
->ifd
< hdr
->ifdMax
2101 && ext_in
->asym
.iss
>= 0
2102 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2103 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2106 /* Pass 1.5 over files: partition out global symbol space */
2108 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2110 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2111 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2112 fdr_to_pst
[f_idx
].n_globals
= 0;
2115 /* Pass 2 over external syms: fill in external symbols */
2117 ext_in_end
= ext_in
+ hdr
->iextMax
;
2118 for (; ext_in
< ext_in_end
; ext_in
++)
2120 enum minimal_symbol_type ms_type
= mst_text
;
2122 /* The Irix 5 native tools seem to sometimes generate bogus
2123 external symbols. */
2124 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2126 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2129 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2131 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2136 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2137 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2139 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2142 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2143 switch (ext_in
->asym
.st
)
2148 ms_type
= mst_file_text
;
2151 if (ext_in
->asym
.sc
== scData
2152 || ext_in
->asym
.sc
== scSData
2153 || ext_in
->asym
.sc
== scRData
)
2159 if (ext_in
->asym
.sc
== scAbs
)
2161 else if (ext_in
->asym
.sc
== scText
)
2163 else if (ext_in
->asym
.sc
== scData
2164 || ext_in
->asym
.sc
== scSData
2165 || ext_in
->asym
.sc
== scRData
)
2171 /* The alpha has the section start addresses in stLocal symbols
2172 whose name starts with a `.'. Skip those but complain for all
2173 other stLocal symbols. */
2178 ms_type
= mst_unknown
;
2179 complain (&unknown_ext_complaint
, name
);
2181 prim_record_minimal_symbol (name
, ext_in
->asym
.value
, ms_type
, objfile
);
2184 /* Pass 3 over files, over local syms: fill in static symbols */
2185 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2187 struct partial_symtab
*save_pst
;
2190 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2194 fdr_to_pst
[f_idx
].pst
= NULL
;
2197 pst
= start_psymtab_common (objfile
, section_offsets
,
2199 fh
->cpd
? fh
->adr
: 0,
2200 objfile
->global_psymbols
.next
,
2201 objfile
->static_psymbols
.next
);
2202 pst
->read_symtab_private
= ((char *)
2203 obstack_alloc (&objfile
->psymbol_obstack
,
2204 sizeof (struct symloc
)));
2205 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2208 FDR_IDX (pst
) = f_idx
;
2209 CUR_BFD (pst
) = cur_bfd
;
2210 DEBUG_SWAP (pst
) = debug_swap
;
2211 DEBUG_INFO (pst
) = debug_info
;
2212 PENDING_LIST (pst
) = pending_list
;
2214 /* The way to turn this into a symtab is to call... */
2215 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2217 /* Set up language for the pst.
2218 The language from the FDR is used if it is unambigious (e.g. cfront
2219 with native cc and g++ will set the language to C).
2220 Otherwise we have to deduce the language from the filename.
2221 Native ecoff has every header file in a separate FDR, so
2222 deduce_language_from_filename will return language_unknown for
2223 a header file, which is not what we want.
2224 But the FDRs for the header files are after the FDR for the source
2225 file, so we can assign the language of the source file to the
2226 following header files. Then we save the language in the private
2227 pst data so that we can reuse it when building symtabs. */
2228 prev_language
= psymtab_language
;
2232 case langCplusplusV2
:
2233 psymtab_language
= language_cplus
;
2236 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2239 if (psymtab_language
== language_unknown
)
2240 psymtab_language
= prev_language
;
2241 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2243 pst
->texthigh
= pst
->textlow
;
2245 /* For stabs-in-ecoff files, the second symbol must be @stab.
2246 This symbol is emitted by mips-tfile to signal that the
2247 current object file uses encapsulated stabs instead of mips
2248 ecoff for local symbols. (It is the second symbol because
2249 the first symbol is the stFile used to signal the start of a
2251 processing_gcc_compilation
= 0;
2254 (*swap_sym_in
) (cur_bfd
,
2255 ((char *) debug_info
->external_sym
2256 + (fh
->isymBase
+ 1) * external_sym_size
),
2258 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2259 processing_gcc_compilation
= 2;
2262 if (processing_gcc_compilation
!= 0)
2264 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2269 (*swap_sym_in
) (cur_bfd
,
2270 (((char *) debug_info
->external_sym
)
2271 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2273 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2274 if (!ECOFF_IS_STAB (&sh
))
2276 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2278 long procaddr
= sh
.value
;
2282 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2283 (debug_info
->external_aux
2286 (*swap_sym_in
) (cur_bfd
,
2287 ((char *) debug_info
->external_sym
2288 + ((fh
->isymBase
+ isym
- 1)
2289 * external_sym_size
)),
2293 long high
= procaddr
+ sh
.value
;
2294 if (high
> pst
->texthigh
)
2295 pst
->texthigh
= high
;
2300 #define SET_NAMESTRING() \
2301 namestring = debug_info->ss + fh->issBase + sh.iss
2302 #define CUR_SYMBOL_TYPE type_code
2303 #define CUR_SYMBOL_VALUE sh.value
2304 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2306 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2307 #define HANDLE_RBRAC(val) \
2308 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2309 #include "partial-stab.h"
2314 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2317 enum address_class
class;
2319 (*swap_sym_in
) (cur_bfd
,
2320 ((char *) debug_info
->external_sym
2321 + ((fh
->isymBase
+ cur_sdx
)
2322 * external_sym_size
)),
2325 if (ECOFF_IS_STAB (&sh
))
2331 /* Non absolute static symbols go into the minimal table. */
2332 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2333 || (sh
.index
== indexNil
2334 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2336 /* FIXME, premature? */
2341 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2349 case stStaticProc
: /* Function */
2350 /* I believe this is used only for file-local functions.
2351 The comment in symconst.h ("load time only static procs")
2352 isn't particularly clear on this point. */
2353 prim_record_minimal_symbol (name
, sh
.value
, mst_file_text
,
2357 case stProc
: /* Asm labels apparently */
2358 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2359 VAR_NAMESPACE
, LOC_BLOCK
,
2360 objfile
->static_psymbols
, sh
.value
,
2361 psymtab_language
, objfile
);
2362 /* Skip over procedure to next one. */
2363 if (sh
.index
>= hdr
->iauxMax
)
2365 /* Should not happen, but does when cross-compiling
2366 with the MIPS compiler. FIXME -- pull later. */
2367 complain (&index_complaint
, name
);
2368 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2371 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2372 (debug_info
->external_aux
2375 procaddr
= sh
.value
;
2377 if (new_sdx
<= cur_sdx
)
2379 /* This should not happen either... FIXME. */
2380 complain (&aux_index_complaint
, name
);
2381 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2385 (*swap_sym_in
) (cur_bfd
,
2386 ((char *) debug_info
->external_sym
2387 + ((fh
->isymBase
+ cur_sdx
- 1)
2388 * external_sym_size
)),
2392 high
= procaddr
+ sh
.value
;
2393 if (high
> pst
->texthigh
)
2394 pst
->texthigh
= high
;
2397 case stStatic
: /* Variable */
2398 if (sh
.sc
== scData
|| sh
.sc
== scSData
|| sh
.sc
== scRData
)
2399 prim_record_minimal_symbol (name
, sh
.value
, mst_file_data
,
2402 prim_record_minimal_symbol (name
, sh
.value
, mst_file_bss
,
2407 case stTypedef
:/* Typedef */
2408 /* Skip typedefs for forward declarations and opaque
2409 structs from alpha cc. */
2412 class = LOC_TYPEDEF
;
2415 case stConstant
: /* Constant decl */
2422 case stBlock
: /* { }, str, un, enum*/
2423 /* Do not create a partial symbol for cc unnamed aggregates
2424 and gcc empty aggregates. */
2425 if ((sh
.sc
== scInfo
|| sh
.sc
== scCommon
)
2427 && sh
.index
!= cur_sdx
+ 2)
2429 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2430 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2431 objfile
->static_psymbols
,
2433 psymtab_language
, objfile
);
2435 /* Skip over the block */
2437 if (new_sdx
<= cur_sdx
)
2439 /* This happens with the Ultrix kernel. */
2440 complain (&block_index_complaint
, name
);
2441 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2446 case stFile
: /* File headers */
2447 case stLabel
: /* Labels */
2448 case stEnd
: /* Ends of files */
2451 case stLocal
: /* Local variables */
2452 /* Normally these are skipped because we skip over
2453 all blocks we see. However, these can occur
2454 as visible symbols in a .h file that contains code. */
2458 /* Both complaints are valid: one gives symbol name,
2459 the other the offending symbol type. */
2460 complain (&unknown_sym_complaint
, name
);
2461 complain (&unknown_st_complaint
, sh
.st
);
2465 /* Use this gdb symbol */
2466 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2467 VAR_NAMESPACE
, class,
2468 objfile
->static_psymbols
, sh
.value
,
2469 psymtab_language
, objfile
);
2471 cur_sdx
++; /* Go to next file symbol */
2474 /* Now do enter the external symbols. */
2475 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2476 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2477 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2478 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2479 for (; --cur_sdx
>= 0; ext_ptr
++)
2481 enum address_class
class;
2485 if (ext_ptr
->ifd
!= f_idx
)
2487 psh
= &ext_ptr
->asym
;
2489 /* Do not add undefined symbols to the partial symbol table. */
2490 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2496 /* These are generated for static symbols in .o files,
2507 complain (&unknown_ext_complaint
,
2508 debug_info
->ssext
+ psh
->iss
);
2509 /* Fall through, pretend it's global. */
2514 name
= debug_info
->ssext
+ psh
->iss
;
2515 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2516 VAR_NAMESPACE
, class,
2517 objfile
->global_psymbols
,
2518 (CORE_ADDR
) psh
->value
,
2519 psymtab_language
, objfile
);
2523 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2524 empty and put on the free list. */
2525 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2526 psymtab_include_list
, includes_used
,
2527 -1, save_pst
->texthigh
,
2528 dependency_list
, dependencies_used
);
2529 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2530 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2532 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2533 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2537 /* Now scan the FDRs for dependencies */
2538 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2540 fh
= f_idx
+ debug_info
->fdr
;
2541 pst
= fdr_to_pst
[f_idx
].pst
;
2543 if (pst
== (struct partial_symtab
*)NULL
)
2546 /* This should catch stabs-in-ecoff. */
2550 /* Skip the first file indirect entry as it is a self dependency
2551 for source files or a reverse .h -> .c dependency for header files. */
2552 pst
->number_of_dependencies
= 0;
2554 ((struct partial_symtab
**)
2555 obstack_alloc (&objfile
->psymbol_obstack
,
2557 * sizeof (struct partial_symtab
*))));
2558 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2562 (*swap_rfd_in
) (cur_bfd
,
2563 ((char *) debug_info
->external_rfd
2564 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2566 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2568 complain (&bad_file_number_complaint
, rh
);
2572 /* Skip self dependencies of header files. */
2576 /* Do not add to dependeny list if psymtab was empty. */
2577 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2579 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2582 do_cleanups (old_chain
);
2587 mdebug_next_symbol_text ()
2592 (*debug_swap
->swap_sym_in
) (cur_bfd
,
2593 ((char *) debug_info
->external_sym
2594 + ((cur_fdr
->isymBase
+ cur_sdx
)
2595 * debug_swap
->external_sym_size
)),
2597 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2600 /* Ancillary function to psymtab_to_symtab(). Does all the work
2601 for turning the partial symtab PST into a symtab, recurring
2602 first on all dependent psymtabs. The argument FILENAME is
2603 only passed so we can see in debug stack traces what file
2606 This function has a split personality, based on whether the
2607 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2608 The flow of control and even the memory allocation differs. FIXME. */
2611 psymtab_to_symtab_1 (pst
, filename
)
2612 struct partial_symtab
*pst
;
2615 bfd_size_type external_sym_size
;
2616 bfd_size_type external_pdr_size
;
2617 void (*swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*));
2618 void (*swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*));
2622 struct linetable
*lines
;
2628 /* Read in all partial symbtabs on which this one is dependent.
2629 NOTE that we do have circular dependencies, sigh. We solved
2630 that by setting pst->readin before this point. */
2632 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2633 if (!pst
->dependencies
[i
]->readin
)
2635 /* Inform about additional files to be read in. */
2638 fputs_filtered (" ", gdb_stdout
);
2640 fputs_filtered ("and ", gdb_stdout
);
2642 printf_filtered ("%s...",
2643 pst
->dependencies
[i
]->filename
);
2644 wrap_here (""); /* Flush output */
2645 gdb_flush (gdb_stdout
);
2647 /* We only pass the filename for debug purposes */
2648 psymtab_to_symtab_1 (pst
->dependencies
[i
],
2649 pst
->dependencies
[i
]->filename
);
2652 /* Do nothing if this is a dummy psymtab. */
2654 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
2655 && pst
->textlow
== 0 && pst
->texthigh
== 0)
2658 /* Now read the symbols for this symtab */
2660 cur_bfd
= CUR_BFD (pst
);
2661 debug_swap
= DEBUG_SWAP (pst
);
2662 debug_info
= DEBUG_INFO (pst
);
2663 pending_list
= PENDING_LIST (pst
);
2664 external_sym_size
= debug_swap
->external_sym_size
;
2665 external_pdr_size
= debug_swap
->external_pdr_size
;
2666 swap_sym_in
= debug_swap
->swap_sym_in
;
2667 swap_pdr_in
= debug_swap
->swap_pdr_in
;
2668 current_objfile
= pst
->objfile
;
2669 cur_fd
= FDR_IDX (pst
);
2670 fh
= ((cur_fd
== -1)
2672 : debug_info
->fdr
+ cur_fd
);
2675 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2676 processing_gcc_compilation
= 0;
2677 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
2681 (*swap_sym_in
) (cur_bfd
,
2682 ((char *) debug_info
->external_sym
2683 + (fh
->isymBase
+ 1) * external_sym_size
),
2685 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2688 /* We indicate that this is a GCC compilation so that certain
2689 features will be enabled in stabsread/dbxread. */
2690 processing_gcc_compilation
= 2;
2694 if (processing_gcc_compilation
!= 0)
2699 unsigned long first_off
= 0;
2701 /* This symbol table contains stabs-in-ecoff entries. */
2703 /* Parse local symbols first */
2705 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2707 current_objfile
= NULL
;
2710 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2716 (*swap_sym_in
) (cur_bfd
,
2717 (((char *) debug_info
->external_sym
)
2718 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2720 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2722 if (ECOFF_IS_STAB (&sh
))
2724 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2726 /* We should never get non N_STAB symbols here, but they
2727 should be harmless, so keep process_one_symbol from
2728 complaining about them. */
2729 if (type_code
& N_STAB
)
2731 process_one_symbol (type_code
, 0, valu
, name
,
2732 pst
->section_offsets
, pst
->objfile
);
2734 if (type_code
== N_FUN
)
2736 /* Make up special symbol to contain
2737 procedure specific info */
2738 struct mips_extra_func_info
*e
=
2739 ((struct mips_extra_func_info
*)
2740 obstack_alloc (¤t_objfile
->symbol_obstack
,
2741 sizeof (struct mips_extra_func_info
)));
2742 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
2743 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
2744 SYMBOL_CLASS (s
) = LOC_CONST
;
2745 SYMBOL_TYPE (s
) = builtin_type_void
;
2746 SYMBOL_VALUE (s
) = (long) e
;
2747 add_symbol_to_list (s
, &local_symbols
);
2750 else if (sh
.st
== stLabel
&& sh
.index
!= indexNil
)
2752 /* Handle encoded stab line number. */
2753 record_line (current_subfile
, sh
.index
, valu
);
2755 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
|| sh
.st
== stEnd
)
2756 /* These are generated by gcc-2.x, do not complain */
2759 complain (&stab_unknown_complaint
, name
);
2761 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
2764 /* Sort the symbol table now, we are done adding symbols to it.
2765 We must do this before parse_procedure calls lookup_symbol. */
2766 sort_symtab_syms (st
);
2768 /* This may not be necessary for stabs symtabs. FIXME. */
2771 /* Fill in procedure info next. */
2773 pdr_ptr
= ((char *) debug_info
->external_pdr
2774 + fh
->ipdFirst
* external_pdr_size
);
2775 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2776 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
2780 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
2786 parse_procedure (&pr
, st
, first_off
);
2791 /* This symbol table contains ordinary ecoff entries. */
2793 /* FIXME: doesn't use pst->section_offsets. */
2799 /* How many symbols will we need */
2800 /* FIXME, this does not count enum values. */
2801 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2805 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2809 f_max
+= fh
->csym
+ fh
->cpd
;
2810 maxlines
= 2 * fh
->cline
;
2811 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2813 /* The proper language was already determined when building
2814 the psymtab, use it. */
2815 st
->language
= PST_PRIVATE (pst
)->pst_language
;
2818 psymtab_language
= st
->language
;
2820 lines
= LINETABLE (st
);
2822 /* Get a new lexical context */
2824 push_parse_stack ();
2825 top_stack
->cur_st
= st
;
2826 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
2828 BLOCK_START (top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2829 BLOCK_END (top_stack
->cur_block
) = 0;
2830 top_stack
->blocktype
= stFile
;
2831 top_stack
->maxsyms
= 2 * f_max
;
2832 top_stack
->cur_type
= 0;
2833 top_stack
->procadr
= 0;
2834 top_stack
->numargs
= 0;
2841 /* Parse local symbols first */
2842 sym_ptr
= ((char *) debug_info
->external_sym
2843 + fh
->isymBase
* external_sym_size
);
2844 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
2845 while (sym_ptr
< sym_end
)
2850 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
2851 c
= parse_symbol (&sh
,
2852 debug_info
->external_aux
+ fh
->iauxBase
,
2853 sym_ptr
, fh
->fBigendian
);
2854 sym_ptr
+= c
* external_sym_size
;
2857 /* Linenumbers. At the end, check if we can save memory.
2858 parse_lines has to look ahead an arbitrary number of PDR
2859 structures, so we swap them all first. */
2863 struct cleanup
*old_chain
;
2869 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
2871 old_chain
= make_cleanup (free
, pr_block
);
2873 pdr_ptr
= ((char *) debug_info
->external_pdr
2874 + fh
->ipdFirst
* external_pdr_size
);
2875 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2879 pdr_ptr
+= external_pdr_size
, pdr_in
++)
2880 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
2882 parse_lines (fh
, pr_block
, lines
, maxlines
);
2883 if (lines
->nitems
< fh
->cline
)
2884 lines
= shrink_linetable (lines
);
2886 /* Fill in procedure info next. */
2888 pdr_in_end
= pdr_in
+ fh
->cpd
;
2889 for (; pdr_in
< pdr_in_end
; pdr_in
++)
2890 parse_procedure (pdr_in
, 0, pr_block
->adr
);
2892 do_cleanups (old_chain
);
2896 LINETABLE (st
) = lines
;
2898 /* .. and our share of externals.
2899 XXX use the global list to speed up things here. how?
2900 FIXME, Maybe quit once we have found the right number of ext's? */
2901 top_stack
->cur_st
= st
;
2902 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
2904 top_stack
->blocktype
= stFile
;
2906 = (debug_info
->symbolic_header
.isymMax
2907 + debug_info
->symbolic_header
.ipdMax
2908 + debug_info
->symbolic_header
.iextMax
);
2910 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
2911 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2912 parse_external (ext_ptr
, 1, fh
->fBigendian
);
2914 /* If there are undefined symbols, tell the user.
2915 The alpha has an undefined symbol for every symbol that is
2916 from a shared library, so tell the user only if verbose is on. */
2917 if (info_verbose
&& n_undef_symbols
)
2919 printf_filtered ("File %s contains %d unresolved references:",
2920 st
->filename
, n_undef_symbols
);
2921 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2922 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2923 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2928 /* Sort the symbol table now, we are done adding symbols to it.*/
2929 sort_symtab_syms (st
);
2934 /* Now link the psymtab and the symtab. */
2937 current_objfile
= NULL
;
2940 /* Ancillary parsing procedures. */
2942 /* Lookup the type at relative index RN. Return it in TPP
2943 if found and in any event come up with its name PNAME.
2944 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2945 Return value says how many aux symbols we ate. */
2948 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
2952 enum type_code type_code
; /* Use to alloc new type if none is found. */
2964 struct mdebug_pending
*pend
;
2966 *tpp
= (struct type
*)NULL
;
2968 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, rn
);
2970 /* Escape index means 'the next one' */
2971 if (rn
->rfd
== 0xfff)
2974 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2981 /* mips cc uses a rf of -1 for opaque struct definitions.
2982 Set TYPE_FLAG_STUB for these types so that check_stub_type will
2983 resolve them if the struct gets defined in another compilation unit. */
2986 *pname
= "<undefined>";
2987 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
2988 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
2992 /* mips cc uses an escaped rn->index of 0 for struct return types
2993 of procedures that were compiled without -g. These will always remain
2995 if (rn
->rfd
== 0xfff && rn
->index
== 0)
2997 *pname
= "<undefined>";
3001 /* Find the relative file descriptor and the symbol in it. */
3002 fh
= get_rfd (fd
, rf
);
3003 xref_fd
= fh
- debug_info
->fdr
;
3005 if (rn
->index
>= fh
->csym
)
3007 /* File indirect entry is corrupt. */
3008 *pname
= "<illegal>";
3009 complain (&bad_rfd_entry_complaint
,
3010 sym_name
, xref_fd
, rn
->index
);
3014 /* If we have processed this symbol then we left a forwarding
3015 pointer to the type in the pending list. If not, we`ll put
3016 it in a list of pending types, to be processed later when
3017 the file will be. In any event, we collect the name for the
3020 esh
= ((char *) debug_info
->external_sym
3021 + ((fh
->isymBase
+ rn
->index
)
3022 * debug_swap
->external_sym_size
));
3023 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3025 /* Make sure that this type of cross reference can be handled. */
3027 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
3028 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3029 && sh
.st
!= stEnum
))
3031 /* File indirect entry is corrupt. */
3032 *pname
= "<illegal>";
3033 complain (&bad_rfd_entry_complaint
,
3034 sym_name
, xref_fd
, rn
->index
);
3038 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3040 pend
= is_pending_symbol (fh
, esh
);
3045 /* We have not yet seen this type. */
3047 if (sh
.iss
== 0 && sh
.st
== stTypedef
)
3051 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3053 a) forward declarations of structs/unions/enums which are not
3054 defined in this compilation unit.
3055 For these the type will be void. This is a bad design decision
3056 as cross referencing across compilation units is impossible
3057 due to the missing name.
3058 b) forward declarations of structs/unions/enums which are defined
3059 later in this file or in another file in the same compilation
3060 unit. Simply cross reference those again to get the
3062 The forward references are not entered in the pending list and
3063 in the symbol table. */
3065 ecoff_swap_tir_in (bigend
,
3066 &(debug_info
->external_aux
3067 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3069 if (tir
.tq0
!= tqNil
)
3070 complain (&illegal_forward_tq0_complaint
, sym_name
);
3074 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3076 *pname
= "<undefined>";
3083 (debug_info
->external_aux
3084 + fh
->iauxBase
+ sh
.index
+ 1),
3085 tpp
, type_code
, pname
,
3086 fh
->fBigendian
, sym_name
);
3090 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3091 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3097 else if (sh
.st
== stTypedef
)
3099 /* Parse the type for a normal typedef. This might recursively call
3100 cross_ref till we get a non typedef'ed type.
3101 FIXME: This is not correct behaviour, but gdb currently
3102 cannot handle typedefs without type copying. But type copying is
3103 impossible as we might have mutual forward references between
3104 two files and the copied type would not get filled in when
3105 we later parse its definition. */
3106 *tpp
= parse_type (xref_fd
,
3107 debug_info
->external_aux
+ fh
->iauxBase
,
3111 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
3115 /* Cross reference to a struct/union/enum which is defined
3116 in another file in the same compilation unit but that file
3117 has not been parsed yet.
3118 Initialize the type only, it will be filled in when
3119 it's definition is parsed. */
3120 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3122 add_pending (fh
, esh
, *tpp
);
3125 /* We used one auxent normally, two if we got a "next one" rf. */
3130 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3131 keeping the symtab sorted */
3133 static struct symbol
*
3134 mylookup_symbol (name
, block
, namespace, class)
3136 register struct block
*block
;
3137 enum namespace namespace;
3138 enum address_class
class;
3140 register int bot
, top
, inc
;
3141 register struct symbol
*sym
;
3144 top
= BLOCK_NSYMS (block
);
3148 sym
= BLOCK_SYM (block
, bot
);
3149 if (SYMBOL_NAME (sym
)[0] == inc
3150 && SYMBOL_NAMESPACE (sym
) == namespace
3151 && SYMBOL_CLASS (sym
) == class
3152 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3156 block
= BLOCK_SUPERBLOCK (block
);
3158 return mylookup_symbol (name
, block
, namespace, class);
3163 /* Add a new symbol S to a block B.
3164 Infrequently, we will need to reallocate the block to make it bigger.
3165 We only detect this case when adding to top_stack->cur_block, since
3166 that's the only time we know how big the block is. FIXME. */
3173 int nsyms
= BLOCK_NSYMS (b
)++;
3174 struct block
*origb
;
3175 struct parse_stack
*stackp
;
3177 if (b
== top_stack
->cur_block
&&
3178 nsyms
>= top_stack
->maxsyms
)
3180 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3181 /* In this case shrink_block is actually grow_block, since
3182 BLOCK_NSYMS(b) is larger than its current size. */
3184 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3186 /* Now run through the stack replacing pointers to the
3187 original block. shrink_block has already done this
3188 for the blockvector and BLOCK_FUNCTION. */
3189 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3191 if (stackp
->cur_block
== origb
)
3193 stackp
->cur_block
= b
;
3194 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3198 BLOCK_SYM (b
, nsyms
) = s
;
3201 /* Add a new block B to a symtab S */
3208 struct blockvector
*bv
= BLOCKVECTOR (s
);
3210 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3211 (sizeof (struct blockvector
)
3212 + BLOCKVECTOR_NBLOCKS (bv
)
3213 * sizeof (bv
->block
)));
3214 if (bv
!= BLOCKVECTOR (s
))
3215 BLOCKVECTOR (s
) = bv
;
3217 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3220 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3221 MIPS' linenumber encoding might need more than one byte
3222 to describe it, LAST is used to detect these continuation lines.
3224 Combining lines with the same line number seems like a bad idea.
3225 E.g: There could be a line number entry with the same line number after the
3226 prologue and GDB should not ignore it (this is a better way to find
3227 a prologue than mips_skip_prologue).
3228 But due to the compressed line table format there are line number entries
3229 for the same line which are needed to bridge the gap to the next
3230 line number entry. These entries have a bogus address info with them
3231 and we are unable to tell them from intended duplicate line number
3233 This is another reason why -ggdb debugging format is preferable. */
3236 add_line (lt
, lineno
, adr
, last
)
3237 struct linetable
*lt
;
3242 /* DEC c89 sometimes produces zero linenos which confuse gdb.
3243 Change them to something sensible. */
3247 last
= -2; /* make sure we record first line */
3249 if (last
== lineno
) /* skip continuation lines */
3252 lt
->item
[lt
->nitems
].line
= lineno
;
3253 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3257 /* Sorting and reordering procedures */
3259 /* Blocks with a smaller low bound should come first */
3262 compare_blocks (arg1
, arg2
)
3266 register int addr_diff
;
3267 struct block
**b1
= (struct block
**) arg1
;
3268 struct block
**b2
= (struct block
**) arg2
;
3270 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3272 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3276 /* Sort the blocks of a symtab S.
3277 Reorder the blocks in the blockvector by code-address,
3278 as required by some MI search routines */
3284 struct blockvector
*bv
= BLOCKVECTOR (s
);
3286 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3289 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3290 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3291 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3292 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3296 * This is very unfortunate: normally all functions are compiled in
3297 * the order they are found, but if the file is compiled -O3 things
3298 * are very different. It would be nice to find a reliable test
3299 * to detect -O3 images in advance.
3301 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3302 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3303 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3304 sizeof (struct block
*),
3308 register CORE_ADDR high
= 0;
3309 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3311 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3312 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3313 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3314 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3317 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3318 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3320 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3321 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3322 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3323 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3327 /* Constructor/restructor/destructor procedures */
3329 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3330 MAXSYMS and linenumbers MAXLINES we'll put in it */
3332 static struct symtab
*
3333 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3337 struct objfile
*objfile
;
3339 struct symtab
*s
= allocate_symtab (name
, objfile
);
3341 LINETABLE (s
) = new_linetable (maxlines
);
3343 /* All symtabs must have at least two blocks */
3344 BLOCKVECTOR (s
) = new_bvect (2);
3345 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3346 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3347 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3348 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3350 s
->free_code
= free_linetable
;
3355 /* Allocate a new partial_symtab NAME */
3357 static struct partial_symtab
*
3358 new_psymtab (name
, objfile
)
3360 struct objfile
*objfile
;
3362 struct partial_symtab
*psymtab
;
3364 psymtab
= allocate_psymtab (name
, objfile
);
3366 /* Keep a backpointer to the file's symbols */
3368 psymtab
->read_symtab_private
= ((char *)
3369 obstack_alloc (&objfile
->psymbol_obstack
,
3370 sizeof (struct symloc
)));
3371 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3372 CUR_BFD (psymtab
) = cur_bfd
;
3373 DEBUG_SWAP (psymtab
) = debug_swap
;
3374 DEBUG_INFO (psymtab
) = debug_info
;
3375 PENDING_LIST (psymtab
) = pending_list
;
3377 /* The way to turn this into a symtab is to call... */
3378 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
3383 /* Allocate a linetable array of the given SIZE. Since the struct
3384 already includes one item, we subtract one when calculating the
3385 proper size to allocate. */
3387 static struct linetable
*
3388 new_linetable (size
)
3391 struct linetable
*l
;
3393 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3394 l
= (struct linetable
*) xmalloc (size
);
3399 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3400 I am not so sure about the 3.4 ones.
3402 Since the struct linetable already includes one item, we subtract one when
3403 calculating the proper size to allocate. */
3405 static struct linetable
*
3406 shrink_linetable (lt
)
3407 struct linetable
*lt
;
3410 return (struct linetable
*) xrealloc ((PTR
) lt
,
3411 (sizeof (struct linetable
)
3413 * sizeof (lt
->item
))));
3416 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3418 static struct blockvector
*
3422 struct blockvector
*bv
;
3425 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3426 bv
= (struct blockvector
*) xzalloc (size
);
3428 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3433 /* Allocate and zero a new block of MAXSYMS symbols */
3435 static struct block
*
3439 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3441 return (struct block
*) xzalloc (size
);
3444 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3445 Shrink_block can also be used by add_symbol to grow a block. */
3447 static struct block
*
3453 struct blockvector
*bv
= BLOCKVECTOR (s
);
3456 /* Just reallocate it and fix references to the old one */
3458 new = (struct block
*) xrealloc ((PTR
) b
,
3459 (sizeof (struct block
)
3460 + ((BLOCK_NSYMS (b
) - 1)
3461 * sizeof (struct symbol
*))));
3463 /* Should chase pointers to old one. Fortunately, that`s just
3464 the block`s function and inferior blocks */
3465 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3466 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3467 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3468 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3469 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3470 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3471 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3475 /* Create a new symbol with printname NAME */
3477 static struct symbol
*
3481 struct symbol
*s
= ((struct symbol
*)
3482 obstack_alloc (¤t_objfile
->symbol_obstack
,
3483 sizeof (struct symbol
)));
3485 memset ((PTR
) s
, 0, sizeof (*s
));
3486 SYMBOL_NAME (s
) = name
;
3487 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3488 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3492 /* Create a new type with printname NAME */
3494 static struct type
*
3500 t
= alloc_type (current_objfile
);
3501 TYPE_NAME (t
) = name
;
3502 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3506 /* Read ECOFF debugging information from a BFD section. This is
3507 called from elfread.c. It parses the section into a
3508 ecoff_debug_info struct, and then lets the rest of the file handle
3512 elfmdebug_build_psymtabs (objfile
, swap
, sec
, section_offsets
)
3513 struct objfile
*objfile
;
3514 const struct ecoff_debug_swap
*swap
;
3516 struct section_offsets
*section_offsets
;
3518 bfd
*abfd
= objfile
->obfd
;
3520 struct ecoff_debug_info
*info
;
3522 buf
= alloca (swap
->external_hdr_size
);
3523 if (bfd_get_section_contents (abfd
, sec
, buf
, (file_ptr
) 0,
3524 swap
->external_hdr_size
) == false)
3525 perror_with_name (bfd_get_filename (abfd
));
3527 info
= ((struct ecoff_debug_info
*)
3528 obstack_alloc (&objfile
->psymbol_obstack
,
3529 sizeof (struct ecoff_debug_info
)));
3531 (*swap
->swap_hdr_in
) (abfd
, buf
, &info
->symbolic_header
);
3533 /* The offsets in symbolic_header are file offsets, not section
3534 offsets. Strangely, on Irix 5 the information is not entirely
3535 within the .mdebug section. There are parts of an executable
3536 file which are not within any ELF section at all. This means
3537 that we must read the information using bfd_read. */
3539 #define READ(ptr, count, off, size, type) \
3542 if (info->symbolic_header.count == 0) \
3543 info->ptr = (type) NULL; \
3546 info->ptr = ((type) \
3547 obstack_alloc (&objfile->psymbol_obstack, \
3548 (info->symbolic_header.count \
3550 if (bfd_seek (abfd, info->symbolic_header.off, SEEK_SET) < 0 \
3551 || (bfd_read ((PTR) info->ptr, size, \
3552 info->symbolic_header.count, abfd) \
3553 != info->symbolic_header.count * size)) \
3554 perror_with_name (bfd_get_filename (abfd)); \
3559 READ (line
, cbLine
, cbLineOffset
, sizeof (unsigned char), unsigned char *);
3560 READ (external_dnr
, idnMax
, cbDnOffset
, swap
->external_dnr_size
, PTR
);
3561 READ (external_pdr
, ipdMax
, cbPdOffset
, swap
->external_pdr_size
, PTR
);
3562 READ (external_sym
, isymMax
, cbSymOffset
, swap
->external_sym_size
, PTR
);
3563 READ (external_opt
, ioptMax
, cbOptOffset
, swap
->external_opt_size
, PTR
);
3564 READ (external_aux
, iauxMax
, cbAuxOffset
, sizeof (union aux_ext
),
3566 READ (ss
, issMax
, cbSsOffset
, sizeof (char), char *);
3567 READ (ssext
, issExtMax
, cbSsExtOffset
, sizeof (char), char *);
3568 READ (external_fdr
, ifdMax
, cbFdOffset
, swap
->external_fdr_size
, PTR
);
3569 READ (external_rfd
, crfd
, cbRfdOffset
, swap
->external_rfd_size
, PTR
);
3570 READ (external_ext
, iextMax
, cbExtOffset
, swap
->external_ext_size
, PTR
);
3576 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
);
3580 /* Things used for calling functions in the inferior.
3581 These functions are exported to our companion
3582 mips-tdep.c file and are here because they play
3583 with the symbol-table explicitly. */
3585 /* Sigtramp: make sure we have all the necessary information
3586 about the signal trampoline code. Since the official code
3587 from MIPS does not do so, we make up that information ourselves.
3588 If they fix the library (unlikely) this code will neutralize itself. */
3590 /* FIXME: This function is called only by mips-tdep.c. It needs to be
3591 here because it calls functions defined in this file, but perhaps
3592 this could be handled in a better way. */
3599 struct block
*b
, *b0
= NULL
;
3601 sigtramp_address
= -1;
3603 /* We have to handle the following cases here:
3604 a) The Mips library has a sigtramp label within sigvec.
3605 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3606 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3609 b0
= SYMBOL_BLOCK_VALUE (s
);
3610 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3614 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3615 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3618 /* But maybe this program uses its own version of sigvec */
3622 /* Did we or MIPSco fix the library ? */
3623 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3625 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3626 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3630 sigtramp_address
= SYMBOL_VALUE (s
);
3631 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3633 /* But what symtab does it live in ? */
3634 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3637 * Ok, there goes the fix: turn it into a procedure, with all the
3638 * needed info. Note we make it a nested procedure of sigvec,
3639 * which is the way the (assembly) code is actually written.
3641 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
3642 SYMBOL_CLASS (s
) = LOC_BLOCK
;
3643 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3645 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
3647 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3649 SYMBOL_BLOCK_VALUE (s
) = b
;
3650 BLOCK_START (b
) = sigtramp_address
;
3651 BLOCK_END (b
) = sigtramp_end
;
3652 BLOCK_FUNCTION (b
) = s
;
3653 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
3657 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3659 struct mips_extra_func_info
*e
=
3660 ((struct mips_extra_func_info
*)
3661 xzalloc (sizeof (struct mips_extra_func_info
)));
3663 e
->numargs
= 0; /* the kernel thinks otherwise */
3664 /* align_longword(sigcontext + SIGFRAME) */
3665 e
->pdr
.frameoffset
= 0x150;
3666 e
->pdr
.framereg
= SP_REGNUM
;
3667 /* read_next_frame_reg provides the true pc at the time of signal */
3668 e
->pdr
.pcreg
= PC_REGNUM
;
3669 e
->pdr
.regmask
= -2;
3670 e
->pdr
.regoffset
= -(41 * sizeof (int));
3671 e
->pdr
.fregmask
= -1;
3672 e
->pdr
.fregoffset
= -(7 * sizeof (int));
3673 e
->pdr
.isym
= (long) s
;
3674 e
->pdr
.adr
= sigtramp_address
;
3676 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3677 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3678 SYMBOL_VALUE (s
) = (long) e
;
3679 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3680 SYMBOL_CLASS (s
) = LOC_CONST
;
3681 SYMBOL_TYPE (s
) = builtin_type_void
;
3682 current_objfile
= NULL
;
3685 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
3689 _initialize_mdebugread ()
3691 /* Missing basic types */
3693 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
3695 mdebug_type_string
=
3696 init_type (TYPE_CODE_STRING
,
3697 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3699 (struct objfile
*) NULL
);
3701 mdebug_type_complex
=
3702 init_type (TYPE_CODE_ERROR
,
3703 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3705 (struct objfile
*) NULL
);
3706 mdebug_type_double_complex
=
3707 init_type (TYPE_CODE_ERROR
,
3708 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3709 0, "double complex",
3710 (struct objfile
*) NULL
);
3712 /* We use TYPE_CODE_INT to print these as integers. Does this do any
3713 good? Would we be better off with TYPE_CODE_ERROR? Should
3714 TYPE_CODE_ERROR print things in hex if it knows the size? */
3715 mdebug_type_fixed_dec
=
3716 init_type (TYPE_CODE_INT
,
3717 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3719 (struct objfile
*) NULL
);
3721 mdebug_type_float_dec
=
3722 init_type (TYPE_CODE_ERROR
,
3723 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3724 0, "floating decimal",
3725 (struct objfile
*) NULL
);