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 /* Alpha cc unnamed structs do not get a tag name. */
998 TYPE_TAG_NAME (t
) = NULL
;
1000 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1003 TYPE_CODE (t
) = type_code
;
1004 TYPE_LENGTH (t
) = sh
->value
;
1005 TYPE_NFIELDS (t
) = nfields
;
1006 TYPE_FIELDS (t
) = f
= ((struct field
*)
1008 nfields
* sizeof (struct field
)));
1010 if (type_code
== TYPE_CODE_ENUM
)
1012 /* This is a non-empty enum. */
1013 for (ext_tsym
= ext_sh
+ external_sym_size
;
1015 ext_tsym
+= external_sym_size
)
1018 struct symbol
*enum_sym
;
1020 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1022 if (tsym
.st
!= stMember
)
1025 f
->bitpos
= tsym
.value
;
1027 f
->name
= debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1030 enum_sym
= ((struct symbol
*)
1031 obstack_alloc (¤t_objfile
->symbol_obstack
,
1032 sizeof (struct symbol
)));
1033 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1034 SYMBOL_NAME (enum_sym
) = f
->name
;
1035 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1036 SYMBOL_TYPE (enum_sym
) = t
;
1037 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1038 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1039 add_symbol (enum_sym
, top_stack
->cur_block
);
1041 /* Skip the stMembers that we've handled. */
1046 /* make this the current type */
1047 top_stack
->cur_type
= t
;
1048 top_stack
->cur_field
= 0;
1050 /* Do not create a symbol for alpha cc unnamed structs. */
1054 /* gcc puts out an empty struct for an opaque struct definitions,
1055 do not create a symbol for it either. */
1056 if (TYPE_NFIELDS (t
) == 0)
1058 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1062 s
= new_symbol (name
);
1063 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1064 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1065 SYMBOL_VALUE (s
) = 0;
1066 SYMBOL_TYPE (s
) = t
;
1067 add_symbol (s
, top_stack
->cur_block
);
1070 /* End of local variables shared by struct, union, enum, and
1071 block (as yet unknown struct/union/enum) processing. */
1075 /* beginnning of (code) block. Value of symbol
1076 is the displacement from procedure start */
1077 push_parse_stack ();
1079 /* Do not start a new block if this is the outermost block of a
1080 procedure. This allows the LOC_BLOCK symbol to point to the
1081 block with the local variables, so funcname::var works. */
1082 if (top_stack
->blocktype
== stProc
1083 || top_stack
->blocktype
== stStaticProc
)
1085 top_stack
->blocktype
= stNil
;
1089 top_stack
->blocktype
= stBlock
;
1090 b
= new_block (top_stack
->maxsyms
);
1091 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1092 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1093 top_stack
->cur_block
= b
;
1094 add_block (b
, top_stack
->cur_st
);
1097 case stEnd
: /* end (of anything) */
1098 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
)
1100 /* Finished with type */
1101 top_stack
->cur_type
= 0;
1103 else if (sh
->sc
== scText
&&
1104 (top_stack
->blocktype
== stProc
||
1105 top_stack
->blocktype
== stStaticProc
))
1107 /* Finished with procedure */
1108 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1109 struct mips_extra_func_info
*e
;
1113 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1115 /* Make up special symbol to contain procedure specific info */
1116 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1117 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1118 SYMBOL_CLASS (s
) = LOC_CONST
;
1119 SYMBOL_TYPE (s
) = builtin_type_void
;
1120 e
= ((struct mips_extra_func_info
*)
1121 obstack_alloc (¤t_objfile
->symbol_obstack
,
1122 sizeof (struct mips_extra_func_info
)));
1123 SYMBOL_VALUE (s
) = (long) e
;
1124 e
->numargs
= top_stack
->numargs
;
1125 add_symbol (s
, top_stack
->cur_block
);
1127 /* Reallocate symbols, saving memory */
1128 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1130 /* f77 emits proc-level with address bounds==[0,0],
1131 So look for such child blocks, and patch them. */
1132 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1134 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1135 if (BLOCK_SUPERBLOCK (b_bad
) == b
1136 && BLOCK_START (b_bad
) == top_stack
->procadr
1137 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1139 BLOCK_START (b_bad
) = BLOCK_START (b
);
1140 BLOCK_END (b_bad
) = BLOCK_END (b
);
1144 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1146 /* End of (code) block. The value of the symbol is the
1147 displacement from the procedure`s start address of the
1148 end of this block. */
1149 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1150 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1152 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1154 /* End of outermost block. Pop parse stack and ignore. The
1155 following stEnd of stProc will take care of the block. */
1158 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1160 /* End of file. Pop parse stack and ignore. Higher
1161 level code deals with this. */
1165 complain (&stEnd_complaint
, sh
->sc
);
1167 pop_parse_stack (); /* restore previous lexical context */
1170 case stMember
: /* member of struct or union */
1171 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1173 f
->bitpos
= sh
->value
;
1175 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1176 f
->bitsize
= bitsize
;
1179 case stTypedef
: /* type definition */
1180 /* Typedefs for forward declarations and opaque structs from alpha cc
1181 are handled by cross_ref, skip them. */
1185 /* Parse the type or use the pending type. */
1186 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1187 if (pend
== (struct mdebug_pending
*) NULL
)
1189 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1190 add_pending (cur_fdr
, ext_sh
, t
);
1195 /* mips cc puts out a typedef with the name of the struct for forward
1196 declarations. These should not go into the symbol table and
1197 TYPE_NAME should not be set for them.
1198 They can't be distinguished from an intentional typedef to
1199 the same name however:
1201 struct x { int ix; int jx; };
1205 struct xx {int ixx; int jxx; };
1206 generates a cross referencing stTypedef for x and xx.
1207 The user visible effect of this is that the type of a pointer
1208 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1209 The problem is fixed with alpha cc. */
1211 s
= new_symbol (name
);
1212 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1213 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1214 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1215 SYMBOL_TYPE (s
) = t
;
1216 add_symbol (s
, top_stack
->cur_block
);
1218 /* Incomplete definitions of structs should not get a name. */
1219 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1220 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1221 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1222 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1224 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1225 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1227 /* If we are giving a name to a type such as "pointer to
1228 foo" or "function returning foo", we better not set
1229 the TYPE_NAME. If the program contains "typedef char
1230 *caddr_t;", we don't want all variables of type char
1231 * to print as caddr_t. This is not just a
1232 consequence of GDB's type management; CC and GCC (at
1233 least through version 2.4) both output variables of
1234 either type char * or caddr_t with the type
1235 refering to the stTypedef symbol for caddr_t. If a future
1236 compiler cleans this up it GDB is not ready for it
1237 yet, but if it becomes ready we somehow need to
1238 disable this check (without breaking the PCC/GCC2.4
1243 Fortunately, this check seems not to be necessary
1244 for anything except pointers or functions. */
1247 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1251 case stFile
: /* file name */
1252 push_parse_stack ();
1253 top_stack
->blocktype
= sh
->st
;
1256 /* I`ve never seen these for C */
1258 break; /* register relocation */
1260 break; /* forwarding address */
1262 break; /* constant */
1264 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1271 /* Parse the type information provided in the raw AX entries for
1272 the symbol SH. Return the bitfield size in BS, in case.
1273 We must byte-swap the AX entries before we use them; BIGEND says whether
1274 they are big-endian or little-endian (from fh->fBigendian). */
1276 static struct type
*
1277 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1280 unsigned int aux_index
;
1285 /* Null entries in this map are treated specially */
1286 static struct type
**map_bt
[] =
1288 &builtin_type_void
, /* btNil */
1290 &builtin_type_char
, /* btChar */
1291 &builtin_type_unsigned_char
,/* btUChar */
1292 &builtin_type_short
, /* btShort */
1293 &builtin_type_unsigned_short
, /* btUShort */
1294 &builtin_type_int
, /* btInt */
1295 &builtin_type_unsigned_int
, /* btUInt */
1296 &builtin_type_long
, /* btLong */
1297 &builtin_type_unsigned_long
,/* btULong */
1298 &builtin_type_float
, /* btFloat */
1299 &builtin_type_double
, /* btDouble */
1306 &mdebug_type_complex
, /* btComplex */
1307 &mdebug_type_double_complex
, /* btDComplex */
1309 &mdebug_type_fixed_dec
, /* btFixedDec */
1310 &mdebug_type_float_dec
, /* btFloatDec */
1311 &mdebug_type_string
, /* btString */
1314 &builtin_type_void
, /* btVoid */
1315 0, /* DEC C++: Pointer to member */
1316 0, /* DEC C++: Virtual function table */
1317 0, /* DEC C++: Class (Record) */
1318 &builtin_type_long
, /* btLong64 */
1319 &builtin_type_unsigned_long
, /* btULong64 */
1320 &builtin_type_long_long
, /* btLongLong64 */
1321 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1322 &builtin_type_unsigned_long
, /* btAdr64 */
1323 &builtin_type_long
, /* btInt64 */
1324 &builtin_type_unsigned_long
, /* btUInt64 */
1328 struct type
*tp
= 0;
1329 enum type_code type_code
= TYPE_CODE_UNDEF
;
1331 /* Handle corrupt aux indices. */
1332 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1334 complain (&index_complaint
, sym_name
);
1335 return builtin_type_int
;
1339 /* Use aux as a type information record, map its basic type. */
1340 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1341 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1343 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1344 return builtin_type_int
;
1348 tp
= *map_bt
[t
->bt
];
1353 /* Cannot use builtin types -- build our own */
1357 tp
= lookup_pointer_type (builtin_type_void
);
1360 type_code
= TYPE_CODE_STRUCT
;
1363 type_code
= TYPE_CODE_UNION
;
1366 type_code
= TYPE_CODE_ENUM
;
1369 type_code
= TYPE_CODE_RANGE
;
1372 type_code
= TYPE_CODE_SET
;
1375 /* alpha cc uses this for typedefs. The true type will be
1376 obtained by crossreferencing below. */
1377 type_code
= TYPE_CODE_ERROR
;
1380 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1381 return builtin_type_int
;
1385 /* Move on to next aux */
1390 /* Inhibit core dumps with some cfront generated objects that
1392 if (bs
== (int *)NULL
)
1394 complain (&bad_fbitfield_complaint
, sym_name
);
1395 return builtin_type_int
;
1397 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1401 /* All these types really point to some (common) MIPS type
1402 definition, and only the type-qualifiers fully identify
1403 them. We'll make the same effort at sharing. */
1404 if (t
->bt
== btStruct
||
1408 /* btSet (I think) implies that the name is a tag name, not a typedef
1409 name. This apparently is a MIPS extension for C sets. */
1414 /* Try to cross reference this type, build new type on failure. */
1415 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1416 if (tp
== (struct type
*) NULL
)
1417 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1419 /* Make sure that TYPE_CODE(tp) has an expected type code.
1420 Any type may be returned from cross_ref if file indirect entries
1422 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1423 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1424 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1426 complain (&unexpected_type_code_complaint
, sym_name
);
1431 /* Usually, TYPE_CODE(tp) is already type_code. The main
1432 exception is if we guessed wrong re struct/union/enum.
1433 But for struct vs. union a wrong guess is harmless, so
1434 don't complain(). */
1435 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1436 && type_code
!= TYPE_CODE_ENUM
)
1437 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1438 && type_code
== TYPE_CODE_ENUM
))
1440 complain (&bad_tag_guess_complaint
, sym_name
);
1443 if (TYPE_CODE (tp
) != type_code
)
1445 TYPE_CODE (tp
) = type_code
;
1448 /* Do not set the tag name if it is a compiler generated tag name
1449 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1450 if (name
[0] == '.' || name
[0] == '\0')
1451 TYPE_TAG_NAME (tp
) = NULL
;
1452 else if (TYPE_TAG_NAME (tp
) == NULL
1453 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1454 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1455 ¤t_objfile
->type_obstack
);
1459 /* All these types really point to some (common) MIPS type
1460 definition, and only the type-qualifiers fully identify
1461 them. We'll make the same effort at sharing.
1462 FIXME: btIndirect cannot happen here as it is handled by the
1463 switch t->bt above. And we are not doing any guessing on range types. */
1464 if (t
->bt
== btIndirect
||
1469 /* Try to cross reference this type, build new type on failure. */
1470 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1471 if (tp
== (struct type
*) NULL
)
1472 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1474 /* Make sure that TYPE_CODE(tp) has an expected type code.
1475 Any type may be returned from cross_ref if file indirect entries
1477 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1479 complain (&unexpected_type_code_complaint
, sym_name
);
1483 /* Usually, TYPE_CODE(tp) is already type_code. The main
1484 exception is if we guessed wrong re struct/union/enum. */
1485 if (TYPE_CODE (tp
) != type_code
)
1487 complain (&bad_tag_guess_complaint
, sym_name
);
1488 TYPE_CODE (tp
) = type_code
;
1490 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1491 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1492 ¤t_objfile
->type_obstack
);
1495 if (t
->bt
== btTypedef
)
1499 /* Try to cross reference this type, it should succeed. */
1500 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1501 if (tp
== (struct type
*) NULL
)
1503 complain (&unable_to_cross_ref_complaint
, sym_name
);
1504 tp
= builtin_type_int
;
1508 /* Deal with range types */
1509 if (t
->bt
== btRange
)
1511 TYPE_NFIELDS (tp
) = 2;
1512 TYPE_FIELDS (tp
) = ((struct field
*)
1513 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1514 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1515 ¤t_objfile
->type_obstack
);
1516 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1518 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1519 ¤t_objfile
->type_obstack
);
1520 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1524 /* Parse all the type qualifiers now. If there are more
1525 than 6 the game will continue in the next aux */
1529 #define PARSE_TQ(tq) \
1530 if (t->tq != tqNil) \
1531 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1543 /* mips cc 2.x and gcc never put out continued aux entries. */
1547 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1551 /* Complain for illegal continuations due to corrupt aux entries. */
1553 complain (&bad_continued_complaint
, sym_name
);
1558 /* Make up a complex type from a basic one. Type is passed by
1559 reference in TPP and side-effected as necessary. The type
1560 qualifier TQ says how to handle the aux symbols at AX for
1561 the symbol SX we are currently analyzing. BIGEND says whether
1562 aux symbols are big-endian or little-endian.
1563 Returns the number of aux symbols we parsed. */
1566 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1577 /* Used in array processing */
1588 t
= lookup_pointer_type (*tpp
);
1593 t
= lookup_function_type (*tpp
);
1600 /* Determine and record the domain type (type of index) */
1601 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, &rndx
);
1607 rf
= AUX_GET_ISYM (bigend
, ax
);
1610 fh
= get_rfd (fd
, rf
);
1612 indx
= parse_type (fd
, debug_info
->external_aux
+ fh
->iauxBase
,
1613 id
, (int *) NULL
, bigend
, sym_name
);
1615 /* The bounds type should be an integer type, but might be anything
1616 else due to corrupt aux entries. */
1617 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1619 complain (&array_index_type_complaint
, sym_name
);
1620 indx
= builtin_type_int
;
1623 /* Get the bounds, and create the array type. */
1625 lower
= AUX_GET_DNLOW (bigend
, ax
);
1627 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1629 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1631 range
= create_range_type ((struct type
*) NULL
, indx
,
1634 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1636 /* We used to fill in the supplied array element bitsize
1637 here if the TYPE_LENGTH of the target type was zero.
1638 This happens for a `pointer to an array of anonymous structs',
1639 but in this case the array element bitsize is also zero,
1640 so nothing is gained.
1641 And we used to check the TYPE_LENGTH of the target type against
1642 the supplied array element bitsize.
1643 gcc causes a mismatch for `pointer to array of object',
1644 since the sdb directives it uses do not have a way of
1645 specifying the bitsize, but it does no harm (the
1646 TYPE_LENGTH should be correct) and we should be able to
1647 ignore the erroneous bitsize from the auxiliary entry safely.
1648 dbx seems to ignore it too. */
1654 /* Volatile -- currently ignored */
1658 /* Const -- currently ignored */
1662 complain (&unknown_type_qual_complaint
, tq
);
1668 /* Parse a procedure descriptor record PR. Note that the procedure is
1669 parsed _after_ the local symbols, now we just insert the extra
1670 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1671 already been placed in the procedure's main block. Note also that
1672 images that have been partially stripped (ld -x) have been deprived
1673 of local symbols, and we have to cope with them here. FIRST_OFF is
1674 the offset of the first procedure for this FDR; we adjust the
1675 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1676 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1677 in question, or NULL to use top_stack->cur_block. */
1679 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long));
1682 parse_procedure (pr
, search_symtab
, first_off
)
1684 struct symtab
*search_symtab
;
1685 unsigned long first_off
;
1687 struct symbol
*s
, *i
;
1689 struct mips_extra_func_info
*e
;
1692 /* Simple rule to find files linked "-x" */
1693 if (cur_fdr
->rss
== -1)
1697 /* Static procedure at address pr->adr. Sigh. */
1698 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1706 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1707 ((char *) debug_info
->external_ext
1709 * debug_swap
->external_ext_size
)),
1711 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1719 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1720 ((char *) debug_info
->external_sym
1721 + ((cur_fdr
->isymBase
+ pr
->isym
)
1722 * debug_swap
->external_sym_size
)),
1724 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1727 if (search_symtab
!= NULL
)
1730 /* This loses both in the case mentioned (want a static, find a global),
1731 but also if we are looking up a non-mangled name which happens to
1732 match the name of a mangled function. */
1733 /* We have to save the cur_fdr across the call to lookup_symbol.
1734 If the pdr is for a static function and if a global function with
1735 the same name exists, lookup_symbol will eventually read in the symtab
1736 for the global function and clobber cur_fdr. */
1737 FDR
*save_cur_fdr
= cur_fdr
;
1738 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1739 cur_fdr
= save_cur_fdr
;
1743 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1749 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1750 VAR_NAMESPACE
, LOC_BLOCK
);
1754 b
= SYMBOL_BLOCK_VALUE (s
);
1758 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1762 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1763 s
= new_symbol (sh_name
);
1764 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1765 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1766 /* Donno its type, hope int is ok */
1767 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1768 add_symbol (s
, top_stack
->cur_block
);
1769 /* Wont have symbols for this one */
1771 SYMBOL_BLOCK_VALUE (s
) = b
;
1772 BLOCK_FUNCTION (b
) = s
;
1773 BLOCK_START (b
) = pr
->adr
;
1774 /* BOUND used to be the end of procedure's text, but the
1775 argument is no longer passed in. */
1776 BLOCK_END (b
) = bound
;
1777 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1778 add_block (b
, top_stack
->cur_st
);
1782 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1786 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1788 e
->pdr
.isym
= (long) s
;
1789 e
->pdr
.adr
+= cur_fdr
->adr
- first_off
;
1791 /* Correct incorrect setjmp procedure descriptor from the library
1792 to make backtrace through setjmp work. */
1793 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1795 complain (&bad_setjmp_pdr_complaint
, 0);
1796 e
->pdr
.pcreg
= RA_REGNUM
;
1797 e
->pdr
.regmask
= 0x80000000;
1798 e
->pdr
.regoffset
= -4;
1801 /* Fake PC_REGNUM for alpha __sigtramp so that read_next_frame_reg
1802 will use the saved user pc from the sigcontext. */
1803 if (STREQ (sh_name
, "__sigtramp"))
1804 e
->pdr
.pcreg
= PC_REGNUM
;
1805 /* Make the same patch for Irix. */
1806 if (STREQ (sh_name
, "_sigtramp"))
1807 e
->pdr
.pcreg
= PC_REGNUM
;
1811 /* Parse the external symbol ES. Just call parse_symbol() after
1812 making sure we know where the aux are for it. For procedures,
1813 parsing of the PDRs has already provided all the needed
1814 information, we only parse them if SKIP_PROCEDURES is false,
1815 and only if this causes no symbol duplication.
1816 BIGEND says whether aux entries are big-endian or little-endian.
1818 This routine clobbers top_stack->cur_block and ->cur_st. */
1821 parse_external (es
, skip_procedures
, bigend
)
1823 int skip_procedures
;
1828 if (es
->ifd
!= ifdNil
)
1831 cur_fdr
= debug_info
->fdr
+ cur_fd
;
1832 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
1836 cur_fdr
= debug_info
->fdr
;
1840 /* Reading .o files */
1841 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1844 switch (es
->asym
.st
)
1847 /* These are generated for static symbols in .o files,
1868 /* FIXME: Turn this into a complaint? */
1870 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1871 what
, debug_info
->ssext
+ es
->asym
.iss
,
1872 fdr_name (cur_fdr
));
1876 switch (es
->asym
.st
)
1879 /* If we have full symbols we do not need more */
1880 if (skip_procedures
)
1882 if (mylookup_symbol (debug_info
->ssext
+ es
->asym
.iss
,
1883 top_stack
->cur_block
,
1884 VAR_NAMESPACE
, LOC_BLOCK
))
1889 /* Note that the case of a symbol with indexNil must be handled
1890 anyways by parse_symbol(). */
1891 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
);
1898 /* Parse the line number info for file descriptor FH into
1899 GDB's linetable LT. MIPS' encoding requires a little bit
1900 of magic to get things out. Note also that MIPS' line
1901 numbers can go back and forth, apparently we can live
1902 with that and do not need to reorder our linetables */
1905 parse_lines (fh
, pr
, lt
, maxlines
)
1908 struct linetable
*lt
;
1911 unsigned char *base
;
1913 int delta
, count
, lineno
= 0;
1914 unsigned long first_off
= pr
->adr
;
1916 if (fh
->cbLine
== 0)
1919 base
= debug_info
->line
+ fh
->cbLineOffset
;
1921 /* Scan by procedure descriptors */
1923 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
1927 unsigned char *halt
;
1929 /* No code for this one */
1930 if (pr
->iline
== ilineNil
||
1931 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1934 /* Determine start and end address of compressed line bytes for
1936 base
= debug_info
->line
+ fh
->cbLineOffset
;
1937 if (j
!= (fh
->cpd
- 1))
1938 halt
= base
+ pr
[1].cbLineOffset
;
1940 halt
= base
+ fh
->cbLine
;
1941 base
+= pr
->cbLineOffset
;
1943 adr
= fh
->adr
+ pr
->adr
- first_off
;
1944 l
= adr
>> 2; /* in words */
1945 for (lineno
= pr
->lnLow
; base
< halt
; )
1947 count
= *base
& 0x0f;
1948 delta
= *base
++ >> 4;
1953 delta
= (base
[0] << 8) | base
[1];
1954 if (delta
>= 0x8000)
1958 lineno
+= delta
; /* first delta is 0 */
1960 /* Complain if the line table overflows. Could happen
1961 with corrupt binaries. */
1962 if (lt
->nitems
>= maxlines
)
1964 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
1967 k
= add_line (lt
, lineno
, l
, k
);
1973 /* Master parsing procedure for first-pass reading of file symbols
1974 into a partial_symtab. */
1977 parse_partial_symbols (objfile
, section_offsets
)
1978 struct objfile
*objfile
;
1979 struct section_offsets
*section_offsets
;
1981 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
1982 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
1983 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
1984 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
1985 = debug_swap
->swap_ext_in
;
1986 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
1987 = debug_swap
->swap_sym_in
;
1988 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
1989 = debug_swap
->swap_rfd_in
;
1991 HDRR
*hdr
= &debug_info
->symbolic_header
;
1992 /* Running pointers */
1997 register EXTR
*ext_in
;
2000 struct partial_symtab
*pst
;
2002 int past_first_source_file
= 0;
2004 /* List of current psymtab's include files */
2005 char **psymtab_include_list
;
2006 int includes_allocated
;
2009 struct pst_map
*fdr_to_pst
;
2010 /* Index within current psymtab dependency list */
2011 struct partial_symtab
**dependency_list
;
2012 int dependencies_used
, dependencies_allocated
;
2013 struct cleanup
*old_chain
;
2015 enum language prev_language
;
2017 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2018 sizeof (EXTR
) * hdr
->iextMax
);
2020 includes_allocated
= 30;
2022 psymtab_include_list
= (char **) alloca (includes_allocated
*
2024 next_symbol_text_func
= mdebug_next_symbol_text
;
2026 dependencies_allocated
= 30;
2027 dependencies_used
= 0;
2029 (struct partial_symtab
**) alloca (dependencies_allocated
*
2030 sizeof (struct partial_symtab
*));
2032 last_source_file
= NULL
;
2037 * Only parse the Local and External symbols, and the Relative FDR.
2038 * Fixup enough of the loader symtab to be able to use it.
2039 * Allocate space only for the file's portions we need to
2044 max_glevel
= MIN_GLEVEL
;
2046 /* Allocate the map FDR -> PST.
2047 Minor hack: -O3 images might claim some global data belongs
2048 to FDR -1. We`ll go along with that */
2049 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2050 old_chain
= make_cleanup (free
, fdr_to_pst
);
2053 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2054 fdr_to_pst
[-1].pst
= pst
;
2058 /* Allocate the global pending list. */
2060 ((struct mdebug_pending
**)
2061 obstack_alloc (&objfile
->psymbol_obstack
,
2062 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2063 memset ((PTR
) pending_list
, 0,
2064 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2066 /* Pass 0 over external syms: swap them in. */
2067 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2068 make_cleanup (free
, ext_block
);
2070 ext_out
= (char *) debug_info
->external_ext
;
2071 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2073 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2074 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2076 /* Pass 1 over external syms: Presize and partition the list */
2078 ext_in_end
= ext_in
+ hdr
->iextMax
;
2079 for (; ext_in
< ext_in_end
; ext_in
++)
2081 /* See calls to complain below. */
2082 if (ext_in
->ifd
>= -1
2083 && ext_in
->ifd
< hdr
->ifdMax
2084 && ext_in
->asym
.iss
>= 0
2085 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2086 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2089 /* Pass 1.5 over files: partition out global symbol space */
2091 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2093 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2094 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2095 fdr_to_pst
[f_idx
].n_globals
= 0;
2098 /* Pass 2 over external syms: fill in external symbols */
2100 ext_in_end
= ext_in
+ hdr
->iextMax
;
2101 for (; ext_in
< ext_in_end
; ext_in
++)
2103 enum minimal_symbol_type ms_type
= mst_text
;
2105 /* The Irix 5 native tools seem to sometimes generate bogus
2106 external symbols. */
2107 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2109 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2112 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2114 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2119 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2120 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2122 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2125 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2126 switch (ext_in
->asym
.st
)
2131 ms_type
= mst_file_text
;
2134 if (ext_in
->asym
.sc
== scData
2135 || ext_in
->asym
.sc
== scSData
2136 || ext_in
->asym
.sc
== scRData
)
2142 if (ext_in
->asym
.sc
== scAbs
)
2144 else if (ext_in
->asym
.sc
== scText
)
2146 else if (ext_in
->asym
.sc
== scData
2147 || ext_in
->asym
.sc
== scSData
2148 || ext_in
->asym
.sc
== scRData
)
2154 /* The alpha has the section start addresses in stLocal symbols
2155 whose name starts with a `.'. Skip those but complain for all
2156 other stLocal symbols. */
2161 ms_type
= mst_unknown
;
2162 complain (&unknown_ext_complaint
, name
);
2164 prim_record_minimal_symbol (name
, ext_in
->asym
.value
, ms_type
, objfile
);
2167 /* Pass 3 over files, over local syms: fill in static symbols */
2168 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2170 struct partial_symtab
*save_pst
;
2173 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2177 fdr_to_pst
[f_idx
].pst
= NULL
;
2180 pst
= start_psymtab_common (objfile
, section_offsets
,
2182 fh
->cpd
? fh
->adr
: 0,
2183 objfile
->global_psymbols
.next
,
2184 objfile
->static_psymbols
.next
);
2185 pst
->read_symtab_private
= ((char *)
2186 obstack_alloc (&objfile
->psymbol_obstack
,
2187 sizeof (struct symloc
)));
2188 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2191 FDR_IDX (pst
) = f_idx
;
2192 CUR_BFD (pst
) = cur_bfd
;
2193 DEBUG_SWAP (pst
) = debug_swap
;
2194 DEBUG_INFO (pst
) = debug_info
;
2195 PENDING_LIST (pst
) = pending_list
;
2197 /* The way to turn this into a symtab is to call... */
2198 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2200 /* Set up language for the pst.
2201 The language from the FDR is used if it is unambigious (e.g. cfront
2202 with native cc and g++ will set the language to C).
2203 Otherwise we have to deduce the language from the filename.
2204 Native ecoff has every header file in a separate FDR, so
2205 deduce_language_from_filename will return language_unknown for
2206 a header file, which is not what we want.
2207 But the FDRs for the header files are after the FDR for the source
2208 file, so we can assign the language of the source file to the
2209 following header files. Then we save the language in the private
2210 pst data so that we can reuse it when building symtabs. */
2211 prev_language
= psymtab_language
;
2215 case langCplusplusV2
:
2216 psymtab_language
= language_cplus
;
2219 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2222 if (psymtab_language
== language_unknown
)
2223 psymtab_language
= prev_language
;
2224 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2226 pst
->texthigh
= pst
->textlow
;
2228 /* For stabs-in-ecoff files, the second symbol must be @stab.
2229 This symbol is emitted by mips-tfile to signal that the
2230 current object file uses encapsulated stabs instead of mips
2231 ecoff for local symbols. (It is the second symbol because
2232 the first symbol is the stFile used to signal the start of a
2234 processing_gcc_compilation
= 0;
2237 (*swap_sym_in
) (cur_bfd
,
2238 ((char *) debug_info
->external_sym
2239 + (fh
->isymBase
+ 1) * external_sym_size
),
2241 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2242 processing_gcc_compilation
= 2;
2245 if (processing_gcc_compilation
!= 0)
2247 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2252 (*swap_sym_in
) (cur_bfd
,
2253 (((char *) debug_info
->external_sym
)
2254 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2256 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2257 if (!ECOFF_IS_STAB (&sh
))
2259 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2261 long procaddr
= sh
.value
;
2265 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2266 (debug_info
->external_aux
2269 (*swap_sym_in
) (cur_bfd
,
2270 ((char *) debug_info
->external_sym
2271 + ((fh
->isymBase
+ isym
- 1)
2272 * external_sym_size
)),
2276 long high
= procaddr
+ sh
.value
;
2277 if (high
> pst
->texthigh
)
2278 pst
->texthigh
= high
;
2283 #define SET_NAMESTRING() \
2284 namestring = debug_info->ss + fh->issBase + sh.iss
2285 #define CUR_SYMBOL_TYPE type_code
2286 #define CUR_SYMBOL_VALUE sh.value
2287 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2289 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2290 #define HANDLE_RBRAC(val) \
2291 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2292 #include "partial-stab.h"
2297 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2300 enum address_class
class;
2302 (*swap_sym_in
) (cur_bfd
,
2303 ((char *) debug_info
->external_sym
2304 + ((fh
->isymBase
+ cur_sdx
)
2305 * external_sym_size
)),
2308 if (ECOFF_IS_STAB (&sh
))
2314 /* Non absolute static symbols go into the minimal table. */
2315 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2316 || (sh
.index
== indexNil
2317 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2319 /* FIXME, premature? */
2324 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2332 case stStaticProc
: /* Function */
2333 /* I believe this is used only for file-local functions.
2334 The comment in symconst.h ("load time only static procs")
2335 isn't particularly clear on this point. */
2336 prim_record_minimal_symbol (name
, sh
.value
, mst_file_text
,
2340 case stProc
: /* Asm labels apparently */
2341 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2342 VAR_NAMESPACE
, LOC_BLOCK
,
2343 objfile
->static_psymbols
, sh
.value
,
2344 psymtab_language
, objfile
);
2345 /* Skip over procedure to next one. */
2346 if (sh
.index
>= hdr
->iauxMax
)
2348 /* Should not happen, but does when cross-compiling
2349 with the MIPS compiler. FIXME -- pull later. */
2350 complain (&index_complaint
, name
);
2351 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2354 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2355 (debug_info
->external_aux
2358 procaddr
= sh
.value
;
2360 if (new_sdx
<= cur_sdx
)
2362 /* This should not happen either... FIXME. */
2363 complain (&aux_index_complaint
, name
);
2364 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2368 (*swap_sym_in
) (cur_bfd
,
2369 ((char *) debug_info
->external_sym
2370 + ((fh
->isymBase
+ cur_sdx
- 1)
2371 * external_sym_size
)),
2375 high
= procaddr
+ sh
.value
;
2376 if (high
> pst
->texthigh
)
2377 pst
->texthigh
= high
;
2380 case stStatic
: /* Variable */
2381 if (sh
.sc
== scData
|| sh
.sc
== scSData
|| sh
.sc
== scRData
)
2382 prim_record_minimal_symbol (name
, sh
.value
, mst_file_data
,
2385 prim_record_minimal_symbol (name
, sh
.value
, mst_file_bss
,
2390 case stTypedef
:/* Typedef */
2391 /* Skip typedefs for forward declarations and opaque
2392 structs from alpha cc. */
2395 class = LOC_TYPEDEF
;
2398 case stConstant
: /* Constant decl */
2405 case stBlock
: /* { }, str, un, enum*/
2406 /* Do not create a partial symbol for cc unnamed aggregates
2407 and gcc empty aggregates. */
2408 if ((sh
.sc
== scInfo
|| sh
.sc
== scCommon
)
2410 && sh
.index
!= cur_sdx
+ 2)
2412 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2413 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2414 objfile
->static_psymbols
,
2416 psymtab_language
, objfile
);
2418 /* Skip over the block */
2420 if (new_sdx
<= cur_sdx
)
2422 /* This happens with the Ultrix kernel. */
2423 complain (&block_index_complaint
, name
);
2424 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2429 case stFile
: /* File headers */
2430 case stLabel
: /* Labels */
2431 case stEnd
: /* Ends of files */
2434 case stLocal
: /* Local variables */
2435 /* Normally these are skipped because we skip over
2436 all blocks we see. However, these can occur
2437 as visible symbols in a .h file that contains code. */
2441 /* Both complaints are valid: one gives symbol name,
2442 the other the offending symbol type. */
2443 complain (&unknown_sym_complaint
, name
);
2444 complain (&unknown_st_complaint
, sh
.st
);
2448 /* Use this gdb symbol */
2449 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2450 VAR_NAMESPACE
, class,
2451 objfile
->static_psymbols
, sh
.value
,
2452 psymtab_language
, objfile
);
2454 cur_sdx
++; /* Go to next file symbol */
2457 /* Now do enter the external symbols. */
2458 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2459 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2460 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2461 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2462 for (; --cur_sdx
>= 0; ext_ptr
++)
2464 enum address_class
class;
2468 if (ext_ptr
->ifd
!= f_idx
)
2470 psh
= &ext_ptr
->asym
;
2472 /* Do not add undefined symbols to the partial symbol table. */
2473 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2479 /* These are generated for static symbols in .o files,
2490 complain (&unknown_ext_complaint
,
2491 debug_info
->ssext
+ psh
->iss
);
2492 /* Fall through, pretend it's global. */
2497 name
= debug_info
->ssext
+ psh
->iss
;
2498 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2499 VAR_NAMESPACE
, class,
2500 objfile
->global_psymbols
,
2501 (CORE_ADDR
) psh
->value
,
2502 psymtab_language
, objfile
);
2506 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2507 empty and put on the free list. */
2508 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2509 psymtab_include_list
, includes_used
,
2510 -1, save_pst
->texthigh
,
2511 dependency_list
, dependencies_used
);
2512 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2513 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2515 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2516 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2520 /* Now scan the FDRs for dependencies */
2521 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2523 fh
= f_idx
+ debug_info
->fdr
;
2524 pst
= fdr_to_pst
[f_idx
].pst
;
2526 if (pst
== (struct partial_symtab
*)NULL
)
2529 /* This should catch stabs-in-ecoff. */
2533 /* Skip the first file indirect entry as it is a self dependency
2534 for source files or a reverse .h -> .c dependency for header files. */
2535 pst
->number_of_dependencies
= 0;
2537 ((struct partial_symtab
**)
2538 obstack_alloc (&objfile
->psymbol_obstack
,
2540 * sizeof (struct partial_symtab
*))));
2541 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2545 (*swap_rfd_in
) (cur_bfd
,
2546 ((char *) debug_info
->external_rfd
2547 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2549 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2551 complain (&bad_file_number_complaint
, rh
);
2555 /* Skip self dependencies of header files. */
2559 /* Do not add to dependeny list if psymtab was empty. */
2560 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2562 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2565 do_cleanups (old_chain
);
2570 mdebug_next_symbol_text ()
2575 (*debug_swap
->swap_sym_in
) (cur_bfd
,
2576 ((char *) debug_info
->external_sym
2577 + ((cur_fdr
->isymBase
+ cur_sdx
)
2578 * debug_swap
->external_sym_size
)),
2580 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2583 /* Ancillary function to psymtab_to_symtab(). Does all the work
2584 for turning the partial symtab PST into a symtab, recurring
2585 first on all dependent psymtabs. The argument FILENAME is
2586 only passed so we can see in debug stack traces what file
2589 This function has a split personality, based on whether the
2590 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2591 The flow of control and even the memory allocation differs. FIXME. */
2594 psymtab_to_symtab_1 (pst
, filename
)
2595 struct partial_symtab
*pst
;
2598 bfd_size_type external_sym_size
;
2599 bfd_size_type external_pdr_size
;
2600 void (*swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*));
2601 void (*swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*));
2605 struct linetable
*lines
;
2611 /* Read in all partial symbtabs on which this one is dependent.
2612 NOTE that we do have circular dependencies, sigh. We solved
2613 that by setting pst->readin before this point. */
2615 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2616 if (!pst
->dependencies
[i
]->readin
)
2618 /* Inform about additional files to be read in. */
2621 fputs_filtered (" ", gdb_stdout
);
2623 fputs_filtered ("and ", gdb_stdout
);
2625 printf_filtered ("%s...",
2626 pst
->dependencies
[i
]->filename
);
2627 wrap_here (""); /* Flush output */
2628 gdb_flush (gdb_stdout
);
2630 /* We only pass the filename for debug purposes */
2631 psymtab_to_symtab_1 (pst
->dependencies
[i
],
2632 pst
->dependencies
[i
]->filename
);
2635 /* Do nothing if this is a dummy psymtab. */
2637 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
2638 && pst
->textlow
== 0 && pst
->texthigh
== 0)
2641 /* Now read the symbols for this symtab */
2643 cur_bfd
= CUR_BFD (pst
);
2644 debug_swap
= DEBUG_SWAP (pst
);
2645 debug_info
= DEBUG_INFO (pst
);
2646 pending_list
= PENDING_LIST (pst
);
2647 external_sym_size
= debug_swap
->external_sym_size
;
2648 external_pdr_size
= debug_swap
->external_pdr_size
;
2649 swap_sym_in
= debug_swap
->swap_sym_in
;
2650 swap_pdr_in
= debug_swap
->swap_pdr_in
;
2651 current_objfile
= pst
->objfile
;
2652 cur_fd
= FDR_IDX (pst
);
2653 fh
= ((cur_fd
== -1)
2655 : debug_info
->fdr
+ cur_fd
);
2658 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2659 processing_gcc_compilation
= 0;
2660 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
2664 (*swap_sym_in
) (cur_bfd
,
2665 ((char *) debug_info
->external_sym
2666 + (fh
->isymBase
+ 1) * external_sym_size
),
2668 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2671 /* We indicate that this is a GCC compilation so that certain
2672 features will be enabled in stabsread/dbxread. */
2673 processing_gcc_compilation
= 2;
2677 if (processing_gcc_compilation
!= 0)
2682 unsigned long first_off
= 0;
2684 /* This symbol table contains stabs-in-ecoff entries. */
2686 /* Parse local symbols first */
2688 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2690 current_objfile
= NULL
;
2693 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2699 (*swap_sym_in
) (cur_bfd
,
2700 (((char *) debug_info
->external_sym
)
2701 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2703 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2705 if (ECOFF_IS_STAB (&sh
))
2707 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2708 process_one_symbol (type_code
, 0, valu
, name
,
2709 pst
->section_offsets
, pst
->objfile
);
2710 if (type_code
== N_FUN
)
2712 /* Make up special symbol to contain
2713 procedure specific info */
2714 struct mips_extra_func_info
*e
=
2715 ((struct mips_extra_func_info
*)
2716 obstack_alloc (¤t_objfile
->symbol_obstack
,
2717 sizeof (struct mips_extra_func_info
)));
2718 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
2719 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
2720 SYMBOL_CLASS (s
) = LOC_CONST
;
2721 SYMBOL_TYPE (s
) = builtin_type_void
;
2722 SYMBOL_VALUE (s
) = (long) e
;
2723 add_symbol_to_list (s
, &local_symbols
);
2726 else if (sh
.st
== stLabel
&& sh
.index
!= indexNil
)
2728 /* Handle encoded stab line number. */
2729 record_line (current_subfile
, sh
.index
, valu
);
2731 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
|| sh
.st
== stEnd
)
2732 /* These are generated by gcc-2.x, do not complain */
2735 complain (&stab_unknown_complaint
, name
);
2737 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
2740 /* Sort the symbol table now, we are done adding symbols to it.
2741 We must do this before parse_procedure calls lookup_symbol. */
2742 sort_symtab_syms (st
);
2744 /* This may not be necessary for stabs symtabs. FIXME. */
2747 /* Fill in procedure info next. */
2749 pdr_ptr
= ((char *) debug_info
->external_pdr
2750 + fh
->ipdFirst
* external_pdr_size
);
2751 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2752 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
2756 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
2762 parse_procedure (&pr
, st
, first_off
);
2767 /* This symbol table contains ordinary ecoff entries. */
2769 /* FIXME: doesn't use pst->section_offsets. */
2775 /* How many symbols will we need */
2776 /* FIXME, this does not count enum values. */
2777 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2781 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2785 f_max
+= fh
->csym
+ fh
->cpd
;
2786 maxlines
= 2 * fh
->cline
;
2787 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2789 /* The proper language was already determined when building
2790 the psymtab, use it. */
2791 st
->language
= PST_PRIVATE (pst
)->pst_language
;
2794 psymtab_language
= st
->language
;
2796 lines
= LINETABLE (st
);
2798 /* Get a new lexical context */
2800 push_parse_stack ();
2801 top_stack
->cur_st
= st
;
2802 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
2804 BLOCK_START (top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2805 BLOCK_END (top_stack
->cur_block
) = 0;
2806 top_stack
->blocktype
= stFile
;
2807 top_stack
->maxsyms
= 2 * f_max
;
2808 top_stack
->cur_type
= 0;
2809 top_stack
->procadr
= 0;
2810 top_stack
->numargs
= 0;
2817 /* Parse local symbols first */
2818 sym_ptr
= ((char *) debug_info
->external_sym
2819 + fh
->isymBase
* external_sym_size
);
2820 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
2821 while (sym_ptr
< sym_end
)
2826 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
2827 c
= parse_symbol (&sh
,
2828 debug_info
->external_aux
+ fh
->iauxBase
,
2829 sym_ptr
, fh
->fBigendian
);
2830 sym_ptr
+= c
* external_sym_size
;
2833 /* Linenumbers. At the end, check if we can save memory.
2834 parse_lines has to look ahead an arbitrary number of PDR
2835 structures, so we swap them all first. */
2839 struct cleanup
*old_chain
;
2845 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
2847 old_chain
= make_cleanup (free
, pr_block
);
2849 pdr_ptr
= ((char *) debug_info
->external_pdr
2850 + fh
->ipdFirst
* external_pdr_size
);
2851 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2855 pdr_ptr
+= external_pdr_size
, pdr_in
++)
2856 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
2858 parse_lines (fh
, pr_block
, lines
, maxlines
);
2859 if (lines
->nitems
< fh
->cline
)
2860 lines
= shrink_linetable (lines
);
2862 /* Fill in procedure info next. */
2864 pdr_in_end
= pdr_in
+ fh
->cpd
;
2865 for (; pdr_in
< pdr_in_end
; pdr_in
++)
2866 parse_procedure (pdr_in
, 0, pr_block
->adr
);
2868 do_cleanups (old_chain
);
2872 LINETABLE (st
) = lines
;
2874 /* .. and our share of externals.
2875 XXX use the global list to speed up things here. how?
2876 FIXME, Maybe quit once we have found the right number of ext's? */
2877 top_stack
->cur_st
= st
;
2878 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
2880 top_stack
->blocktype
= stFile
;
2882 = (debug_info
->symbolic_header
.isymMax
2883 + debug_info
->symbolic_header
.ipdMax
2884 + debug_info
->symbolic_header
.iextMax
);
2886 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
2887 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
2888 parse_external (ext_ptr
, 1, fh
->fBigendian
);
2890 /* If there are undefined symbols, tell the user.
2891 The alpha has an undefined symbol for every symbol that is
2892 from a shared library, so tell the user only if verbose is on. */
2893 if (info_verbose
&& n_undef_symbols
)
2895 printf_filtered ("File %s contains %d unresolved references:",
2896 st
->filename
, n_undef_symbols
);
2897 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
2898 n_undef_vars
, n_undef_procs
, n_undef_labels
);
2899 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
2904 /* Sort the symbol table now, we are done adding symbols to it.*/
2905 sort_symtab_syms (st
);
2910 /* Now link the psymtab and the symtab. */
2913 current_objfile
= NULL
;
2916 /* Ancillary parsing procedures. */
2918 /* Lookup the type at relative index RN. Return it in TPP
2919 if found and in any event come up with its name PNAME.
2920 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
2921 Return value says how many aux symbols we ate. */
2924 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
2928 enum type_code type_code
; /* Use to alloc new type if none is found. */
2940 struct mdebug_pending
*pend
;
2942 *tpp
= (struct type
*)NULL
;
2944 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, rn
);
2946 /* Escape index means 'the next one' */
2947 if (rn
->rfd
== 0xfff)
2950 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
2957 /* mips cc uses a rf of -1 for opaque struct definitions.
2958 Set TYPE_FLAG_STUB for these types so that check_stub_type will
2959 resolve them if the struct gets defined in another compilation unit. */
2962 *pname
= "<undefined>";
2963 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
2964 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
2968 /* mips cc uses an escaped rn->index of 0 for struct return types
2969 of procedures that were compiled without -g. These will always remain
2971 if (rn
->rfd
== 0xfff && rn
->index
== 0)
2973 *pname
= "<undefined>";
2977 /* Find the relative file descriptor and the symbol in it. */
2978 fh
= get_rfd (fd
, rf
);
2979 xref_fd
= fh
- debug_info
->fdr
;
2981 if (rn
->index
>= fh
->csym
)
2983 /* File indirect entry is corrupt. */
2984 *pname
= "<illegal>";
2985 complain (&bad_rfd_entry_complaint
,
2986 sym_name
, xref_fd
, rn
->index
);
2990 /* If we have processed this symbol then we left a forwarding
2991 pointer to the type in the pending list. If not, we`ll put
2992 it in a list of pending types, to be processed later when
2993 the file will be. In any event, we collect the name for the
2996 esh
= ((char *) debug_info
->external_sym
2997 + ((fh
->isymBase
+ rn
->index
)
2998 * debug_swap
->external_sym_size
));
2999 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3001 /* Make sure that this type of cross reference can be handled. */
3003 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
3004 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3005 && sh
.st
!= stEnum
))
3007 /* File indirect entry is corrupt. */
3008 *pname
= "<illegal>";
3009 complain (&bad_rfd_entry_complaint
,
3010 sym_name
, xref_fd
, rn
->index
);
3014 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3016 pend
= is_pending_symbol (fh
, esh
);
3021 /* We have not yet seen this type. */
3023 if (sh
.iss
== 0 && sh
.st
== stTypedef
)
3027 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3029 a) forward declarations of structs/unions/enums which are not
3030 defined in this compilation unit.
3031 For these the type will be void. This is a bad design decision
3032 as cross referencing across compilation units is impossible
3033 due to the missing name.
3034 b) forward declarations of structs/unions/enums which are defined
3035 later in this file or in another file in the same compilation
3036 unit. Simply cross reference those again to get the
3038 The forward references are not entered in the pending list and
3039 in the symbol table. */
3041 ecoff_swap_tir_in (bigend
,
3042 &(debug_info
->external_aux
3043 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3045 if (tir
.tq0
!= tqNil
)
3046 complain (&illegal_forward_tq0_complaint
, sym_name
);
3050 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3052 *pname
= "<undefined>";
3059 (debug_info
->external_aux
3060 + fh
->iauxBase
+ sh
.index
+ 1),
3061 tpp
, type_code
, pname
,
3062 fh
->fBigendian
, sym_name
);
3066 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3067 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3073 else if (sh
.st
== stTypedef
)
3075 /* Parse the type for a normal typedef. This might recursively call
3076 cross_ref till we get a non typedef'ed type.
3077 FIXME: This is not correct behaviour, but gdb currently
3078 cannot handle typedefs without type copying. But type copying is
3079 impossible as we might have mutual forward references between
3080 two files and the copied type would not get filled in when
3081 we later parse its definition. */
3082 *tpp
= parse_type (xref_fd
,
3083 debug_info
->external_aux
+ fh
->iauxBase
,
3087 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
3091 /* Cross reference to a struct/union/enum which is defined
3092 in another file in the same compilation unit but that file
3093 has not been parsed yet.
3094 Initialize the type only, it will be filled in when
3095 it's definition is parsed. */
3096 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3098 add_pending (fh
, esh
, *tpp
);
3101 /* We used one auxent normally, two if we got a "next one" rf. */
3106 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3107 keeping the symtab sorted */
3109 static struct symbol
*
3110 mylookup_symbol (name
, block
, namespace, class)
3112 register struct block
*block
;
3113 enum namespace namespace;
3114 enum address_class
class;
3116 register int bot
, top
, inc
;
3117 register struct symbol
*sym
;
3120 top
= BLOCK_NSYMS (block
);
3124 sym
= BLOCK_SYM (block
, bot
);
3125 if (SYMBOL_NAME (sym
)[0] == inc
3126 && SYMBOL_NAMESPACE (sym
) == namespace
3127 && SYMBOL_CLASS (sym
) == class
3128 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3132 block
= BLOCK_SUPERBLOCK (block
);
3134 return mylookup_symbol (name
, block
, namespace, class);
3139 /* Add a new symbol S to a block B.
3140 Infrequently, we will need to reallocate the block to make it bigger.
3141 We only detect this case when adding to top_stack->cur_block, since
3142 that's the only time we know how big the block is. FIXME. */
3149 int nsyms
= BLOCK_NSYMS (b
)++;
3150 struct block
*origb
;
3151 struct parse_stack
*stackp
;
3153 if (b
== top_stack
->cur_block
&&
3154 nsyms
>= top_stack
->maxsyms
)
3156 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3157 /* In this case shrink_block is actually grow_block, since
3158 BLOCK_NSYMS(b) is larger than its current size. */
3160 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3162 /* Now run through the stack replacing pointers to the
3163 original block. shrink_block has already done this
3164 for the blockvector and BLOCK_FUNCTION. */
3165 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3167 if (stackp
->cur_block
== origb
)
3169 stackp
->cur_block
= b
;
3170 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3174 BLOCK_SYM (b
, nsyms
) = s
;
3177 /* Add a new block B to a symtab S */
3184 struct blockvector
*bv
= BLOCKVECTOR (s
);
3186 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3187 (sizeof (struct blockvector
)
3188 + BLOCKVECTOR_NBLOCKS (bv
)
3189 * sizeof (bv
->block
)));
3190 if (bv
!= BLOCKVECTOR (s
))
3191 BLOCKVECTOR (s
) = bv
;
3193 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3196 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3197 MIPS' linenumber encoding might need more than one byte
3198 to describe it, LAST is used to detect these continuation lines.
3200 Combining lines with the same line number seems like a bad idea.
3201 E.g: There could be a line number entry with the same line number after the
3202 prologue and GDB should not ignore it (this is a better way to find
3203 a prologue than mips_skip_prologue).
3204 But due to the compressed line table format there are line number entries
3205 for the same line which are needed to bridge the gap to the next
3206 line number entry. These entries have a bogus address info with them
3207 and we are unable to tell them from intended duplicate line number
3209 This is another reason why -ggdb debugging format is preferable. */
3212 add_line (lt
, lineno
, adr
, last
)
3213 struct linetable
*lt
;
3219 last
= -2; /* make sure we record first line */
3221 if (last
== lineno
) /* skip continuation lines */
3224 lt
->item
[lt
->nitems
].line
= lineno
;
3225 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3229 /* Sorting and reordering procedures */
3231 /* Blocks with a smaller low bound should come first */
3234 compare_blocks (arg1
, arg2
)
3238 register int addr_diff
;
3239 struct block
**b1
= (struct block
**) arg1
;
3240 struct block
**b2
= (struct block
**) arg2
;
3242 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3244 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3248 /* Sort the blocks of a symtab S.
3249 Reorder the blocks in the blockvector by code-address,
3250 as required by some MI search routines */
3256 struct blockvector
*bv
= BLOCKVECTOR (s
);
3258 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3261 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3262 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3263 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3264 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3268 * This is very unfortunate: normally all functions are compiled in
3269 * the order they are found, but if the file is compiled -O3 things
3270 * are very different. It would be nice to find a reliable test
3271 * to detect -O3 images in advance.
3273 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3274 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3275 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3276 sizeof (struct block
*),
3280 register CORE_ADDR high
= 0;
3281 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3283 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3284 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3285 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3286 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3289 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3290 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3292 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3293 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3294 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3295 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3299 /* Constructor/restructor/destructor procedures */
3301 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3302 MAXSYMS and linenumbers MAXLINES we'll put in it */
3304 static struct symtab
*
3305 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3309 struct objfile
*objfile
;
3311 struct symtab
*s
= allocate_symtab (name
, objfile
);
3313 LINETABLE (s
) = new_linetable (maxlines
);
3315 /* All symtabs must have at least two blocks */
3316 BLOCKVECTOR (s
) = new_bvect (2);
3317 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3318 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3319 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3320 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3322 s
->free_code
= free_linetable
;
3327 /* Allocate a new partial_symtab NAME */
3329 static struct partial_symtab
*
3330 new_psymtab (name
, objfile
)
3332 struct objfile
*objfile
;
3334 struct partial_symtab
*psymtab
;
3336 psymtab
= allocate_psymtab (name
, objfile
);
3338 /* Keep a backpointer to the file's symbols */
3340 psymtab
->read_symtab_private
= ((char *)
3341 obstack_alloc (&objfile
->psymbol_obstack
,
3342 sizeof (struct symloc
)));
3343 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3344 CUR_BFD (psymtab
) = cur_bfd
;
3345 DEBUG_SWAP (psymtab
) = debug_swap
;
3346 DEBUG_INFO (psymtab
) = debug_info
;
3347 PENDING_LIST (psymtab
) = pending_list
;
3349 /* The way to turn this into a symtab is to call... */
3350 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
3355 /* Allocate a linetable array of the given SIZE. Since the struct
3356 already includes one item, we subtract one when calculating the
3357 proper size to allocate. */
3359 static struct linetable
*
3360 new_linetable (size
)
3363 struct linetable
*l
;
3365 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3366 l
= (struct linetable
*) xmalloc (size
);
3371 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3372 I am not so sure about the 3.4 ones.
3374 Since the struct linetable already includes one item, we subtract one when
3375 calculating the proper size to allocate. */
3377 static struct linetable
*
3378 shrink_linetable (lt
)
3379 struct linetable
*lt
;
3382 return (struct linetable
*) xrealloc ((PTR
) lt
,
3383 (sizeof (struct linetable
)
3385 * sizeof (lt
->item
))));
3388 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3390 static struct blockvector
*
3394 struct blockvector
*bv
;
3397 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3398 bv
= (struct blockvector
*) xzalloc (size
);
3400 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3405 /* Allocate and zero a new block of MAXSYMS symbols */
3407 static struct block
*
3411 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3413 return (struct block
*) xzalloc (size
);
3416 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3417 Shrink_block can also be used by add_symbol to grow a block. */
3419 static struct block
*
3425 struct blockvector
*bv
= BLOCKVECTOR (s
);
3428 /* Just reallocate it and fix references to the old one */
3430 new = (struct block
*) xrealloc ((PTR
) b
,
3431 (sizeof (struct block
)
3432 + ((BLOCK_NSYMS (b
) - 1)
3433 * sizeof (struct symbol
*))));
3435 /* Should chase pointers to old one. Fortunately, that`s just
3436 the block`s function and inferior blocks */
3437 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3438 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3439 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3440 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3441 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3442 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3443 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3447 /* Create a new symbol with printname NAME */
3449 static struct symbol
*
3453 struct symbol
*s
= ((struct symbol
*)
3454 obstack_alloc (¤t_objfile
->symbol_obstack
,
3455 sizeof (struct symbol
)));
3457 memset ((PTR
) s
, 0, sizeof (*s
));
3458 SYMBOL_NAME (s
) = name
;
3459 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3460 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3464 /* Create a new type with printname NAME */
3466 static struct type
*
3472 t
= alloc_type (current_objfile
);
3473 TYPE_NAME (t
) = name
;
3474 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3478 /* Read ECOFF debugging information from a BFD section. This is
3479 called from elfread.c. It parses the section into a
3480 ecoff_debug_info struct, and then lets the rest of the file handle
3484 elfmdebug_build_psymtabs (objfile
, swap
, sec
, section_offsets
)
3485 struct objfile
*objfile
;
3486 const struct ecoff_debug_swap
*swap
;
3488 struct section_offsets
*section_offsets
;
3490 bfd
*abfd
= objfile
->obfd
;
3492 struct ecoff_debug_info
*info
;
3494 buf
= alloca (swap
->external_hdr_size
);
3495 if (bfd_get_section_contents (abfd
, sec
, buf
, (file_ptr
) 0,
3496 swap
->external_hdr_size
) == false)
3497 perror_with_name (bfd_get_filename (abfd
));
3499 info
= ((struct ecoff_debug_info
*)
3500 obstack_alloc (&objfile
->psymbol_obstack
,
3501 sizeof (struct ecoff_debug_info
)));
3503 (*swap
->swap_hdr_in
) (abfd
, buf
, &info
->symbolic_header
);
3505 /* The offsets in symbolic_header are file offsets, not section
3506 offsets. Strangely, on Irix 5 the information is not entirely
3507 within the .mdebug section. There are parts of an executable
3508 file which are not within any ELF section at all. This means
3509 that we must read the information using bfd_read. */
3511 #define READ(ptr, count, off, size, type) \
3514 if (info->symbolic_header.count == 0) \
3515 info->ptr = (type) NULL; \
3518 info->ptr = ((type) \
3519 obstack_alloc (&objfile->psymbol_obstack, \
3520 (info->symbolic_header.count \
3522 if (bfd_seek (abfd, info->symbolic_header.off, SEEK_SET) < 0 \
3523 || (bfd_read ((PTR) info->ptr, size, \
3524 info->symbolic_header.count, abfd) \
3525 != info->symbolic_header.count * size)) \
3526 perror_with_name (bfd_get_filename (abfd)); \
3531 READ (line
, cbLine
, cbLineOffset
, sizeof (unsigned char), unsigned char *);
3532 READ (external_dnr
, idnMax
, cbDnOffset
, swap
->external_dnr_size
, PTR
);
3533 READ (external_pdr
, ipdMax
, cbPdOffset
, swap
->external_pdr_size
, PTR
);
3534 READ (external_sym
, isymMax
, cbSymOffset
, swap
->external_sym_size
, PTR
);
3535 READ (external_opt
, ioptMax
, cbOptOffset
, swap
->external_opt_size
, PTR
);
3536 READ (external_aux
, iauxMax
, cbAuxOffset
, sizeof (union aux_ext
),
3538 READ (ss
, issMax
, cbSsOffset
, sizeof (char), char *);
3539 READ (ssext
, issExtMax
, cbSsExtOffset
, sizeof (char), char *);
3540 READ (external_fdr
, ifdMax
, cbFdOffset
, swap
->external_fdr_size
, PTR
);
3541 READ (external_rfd
, crfd
, cbRfdOffset
, swap
->external_rfd_size
, PTR
);
3542 READ (external_ext
, iextMax
, cbExtOffset
, swap
->external_ext_size
, PTR
);
3548 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
);
3552 /* Things used for calling functions in the inferior.
3553 These functions are exported to our companion
3554 mips-tdep.c file and are here because they play
3555 with the symbol-table explicitly. */
3557 /* Sigtramp: make sure we have all the necessary information
3558 about the signal trampoline code. Since the official code
3559 from MIPS does not do so, we make up that information ourselves.
3560 If they fix the library (unlikely) this code will neutralize itself. */
3562 /* FIXME: This function is called only by mips-tdep.c. It needs to be
3563 here because it calls functions defined in this file, but perhaps
3564 this could be handled in a better way. */
3571 struct block
*b
, *b0
= NULL
;
3573 sigtramp_address
= -1;
3575 /* We have to handle the following cases here:
3576 a) The Mips library has a sigtramp label within sigvec.
3577 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3578 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3581 b0
= SYMBOL_BLOCK_VALUE (s
);
3582 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3586 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3587 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3590 /* But maybe this program uses its own version of sigvec */
3594 /* Did we or MIPSco fix the library ? */
3595 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3597 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3598 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3602 sigtramp_address
= SYMBOL_VALUE (s
);
3603 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3605 /* But what symtab does it live in ? */
3606 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3609 * Ok, there goes the fix: turn it into a procedure, with all the
3610 * needed info. Note we make it a nested procedure of sigvec,
3611 * which is the way the (assembly) code is actually written.
3613 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
3614 SYMBOL_CLASS (s
) = LOC_BLOCK
;
3615 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3617 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
3619 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3621 SYMBOL_BLOCK_VALUE (s
) = b
;
3622 BLOCK_START (b
) = sigtramp_address
;
3623 BLOCK_END (b
) = sigtramp_end
;
3624 BLOCK_FUNCTION (b
) = s
;
3625 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
3629 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3631 struct mips_extra_func_info
*e
=
3632 ((struct mips_extra_func_info
*)
3633 xzalloc (sizeof (struct mips_extra_func_info
)));
3635 e
->numargs
= 0; /* the kernel thinks otherwise */
3636 /* align_longword(sigcontext + SIGFRAME) */
3637 e
->pdr
.frameoffset
= 0x150;
3638 e
->pdr
.framereg
= SP_REGNUM
;
3639 /* read_next_frame_reg provides the true pc at the time of signal */
3640 e
->pdr
.pcreg
= PC_REGNUM
;
3641 e
->pdr
.regmask
= -2;
3642 e
->pdr
.regoffset
= -(41 * sizeof (int));
3643 e
->pdr
.fregmask
= -1;
3644 e
->pdr
.fregoffset
= -(7 * sizeof (int));
3645 e
->pdr
.isym
= (long) s
;
3646 e
->pdr
.adr
= sigtramp_address
;
3648 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3649 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3650 SYMBOL_VALUE (s
) = (long) e
;
3651 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3652 SYMBOL_CLASS (s
) = LOC_CONST
;
3653 SYMBOL_TYPE (s
) = builtin_type_void
;
3654 current_objfile
= NULL
;
3657 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
3661 _initialize_mdebugread ()
3663 /* Missing basic types */
3665 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
3667 mdebug_type_string
=
3668 init_type (TYPE_CODE_STRING
,
3669 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3671 (struct objfile
*) NULL
);
3673 mdebug_type_complex
=
3674 init_type (TYPE_CODE_ERROR
,
3675 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3677 (struct objfile
*) NULL
);
3678 mdebug_type_double_complex
=
3679 init_type (TYPE_CODE_ERROR
,
3680 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3681 0, "double complex",
3682 (struct objfile
*) NULL
);
3684 /* We use TYPE_CODE_INT to print these as integers. Does this do any
3685 good? Would we be better off with TYPE_CODE_ERROR? Should
3686 TYPE_CODE_ERROR print things in hex if it knows the size? */
3687 mdebug_type_fixed_dec
=
3688 init_type (TYPE_CODE_INT
,
3689 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3691 (struct objfile
*) NULL
);
3693 mdebug_type_float_dec
=
3694 init_type (TYPE_CODE_ERROR
,
3695 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3696 0, "floating decimal",
3697 (struct objfile
*) NULL
);