1 /* Read a symbol table in ECOFF format (Third-Eye).
3 Copyright (C) 1986-2022 Free Software Foundation, Inc.
5 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
6 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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. */
46 #include "filenames.h"
48 #include "gdbsupport/gdb_obstack.h"
49 #include "buildsym-legacy.h"
50 #include "stabsread.h"
51 #include "complaints.h"
53 #include "gdb-demangle.h"
55 #include "dictionary.h"
56 #include "mdebugread.h"
63 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files. */
65 #include "libaout.h" /* Private BFD a.out information. */
66 #include "aout/aout64.h"
67 #include "aout/stab_gnu.h" /* STABS information. */
69 #include "expression.h"
73 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
74 We use this define in order to know whether we should override a
75 symbol's ECOFF section with its ELF section. This is necessary in
76 case the symbol's ELF section could not be represented in ECOFF. */
77 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
78 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
80 /* The objfile we are currently reading. */
82 static struct objfile
*mdebugread_objfile
;
86 /* We put a pointer to this structure in the read_symtab_private field
91 /* Index of the FDR that this psymtab represents. */
93 /* The BFD that the psymtab was created from. */
95 const struct ecoff_debug_swap
*debug_swap
;
96 struct ecoff_debug_info
*debug_info
;
97 struct mdebug_pending
**pending_list
;
98 /* Pointer to external symbols for this file. */
100 /* Size of extern_tab. */
102 enum language pst_language
;
105 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
106 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
107 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
108 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
109 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
110 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
112 #define SC_IS_TEXT(sc) ((sc) == scText \
113 || (sc) == scRConst \
116 #define SC_IS_DATA(sc) ((sc) == scData \
121 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
122 #define SC_IS_BSS(sc) ((sc) == scBss)
123 #define SC_IS_SBSS(sc) ((sc) == scSBss)
124 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
126 /* Various complaints about symbol reading that don't abort the process. */
128 index_complaint (const char *arg1
)
130 complaint (_("bad aux index at symbol %s"), arg1
);
134 unknown_ext_complaint (const char *arg1
)
136 complaint (_("unknown external symbol %s"), arg1
);
140 basic_type_complaint (int arg1
, const char *arg2
)
142 complaint (_("cannot map ECOFF basic type 0x%x for %s"),
147 bad_tag_guess_complaint (const char *arg1
)
149 complaint (_("guessed tag type of %s incorrectly"), arg1
);
153 bad_rfd_entry_complaint (const char *arg1
, int arg2
, int arg3
)
155 complaint (_("bad rfd entry for %s: file %d, index %d"),
160 unexpected_type_code_complaint (const char *arg1
)
162 complaint (_("unexpected type code for %s"), arg1
);
165 /* Macros and extra defs. */
167 /* Puns: hard to find whether -g was used and how. */
169 #define MIN_GLEVEL GLEVEL_0
170 #define compare_glevel(a,b) \
171 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
172 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
174 /* Things that really are local to this module. */
176 /* Remember what we deduced to be the source language of this psymtab. */
178 static enum language psymtab_language
= language_unknown
;
184 /* How to parse debugging information for CUR_BFD. */
186 static const struct ecoff_debug_swap
*debug_swap
;
188 /* Pointers to debugging information for CUR_BFD. */
190 static struct ecoff_debug_info
*debug_info
;
192 /* Pointer to current file descriptor record, and its index. */
197 /* Index of current symbol. */
201 /* Note how much "debuggable" this image is. We would like
202 to see at least one FDR with full symbols. */
204 static int max_gdbinfo
;
205 static int max_glevel
;
207 /* When examining .o files, report on undefined symbols. */
209 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
211 /* Pseudo symbol to use when putting stabs into the symbol table. */
213 static char stabs_symbol
[] = STABS_SYMBOL
;
215 /* Nonzero if we have seen ecoff debugging info for a file. */
217 static int found_ecoff_debugging_info
;
219 /* Forward declarations. */
221 static int upgrade_type (int, struct type
**, int, union aux_ext
*,
224 static void parse_partial_symbols (minimal_symbol_reader
&,
228 static int has_opaque_xref (FDR
*, SYMR
*);
230 static int cross_ref (int, union aux_ext
*, struct type
**, enum type_code
,
231 const char **, int, const char *);
233 static struct symbol
*new_symbol (const char *);
235 static struct type
*new_type (char *);
237 enum block_type
{ FUNCTION_BLOCK
, NON_FUNCTION_BLOCK
};
239 static struct block
*new_block (enum block_type
, enum language
);
241 static struct compunit_symtab
*new_symtab (const char *, int, struct objfile
*);
243 static struct linetable
*new_linetable (int);
245 static struct blockvector
*new_bvect (int);
247 static struct type
*parse_type (int, union aux_ext
*, unsigned int, int *,
250 static struct symbol
*mylookup_symbol (const char *, const struct block
*,
251 domain_enum
, enum address_class
);
253 static void sort_blocks (struct symtab
*);
255 static legacy_psymtab
*new_psymtab (const char *, psymtab_storage
*,
258 static void mdebug_expand_psymtab (legacy_psymtab
*pst
,
259 struct objfile
*objfile
);
261 static void add_block (struct block
*, struct symtab
*);
263 static void add_symbol (struct symbol
*, struct symtab
*, struct block
*);
265 static int add_line (struct linetable
*, int, CORE_ADDR
, int);
267 static struct linetable
*shrink_linetable (struct linetable
*);
269 static void handle_psymbol_enumerators (struct objfile
*, psymtab_storage
*,
271 FDR
*, int, CORE_ADDR
);
273 static const char *mdebug_next_symbol_text (struct objfile
*);
275 /* Exported procedure: Builds a symtab from the partial symtab SELF.
276 Restores the environment in effect when SELF was created, delegates
277 most of the work to an ancillary procedure, and sorts
278 and reorders the symtab list at the end. SELF is not NULL. */
281 mdebug_read_symtab (legacy_psymtab
*self
, struct objfile
*objfile
)
283 next_symbol_text_func
= mdebug_next_symbol_text
;
285 self
->expand_psymtab (objfile
);
287 /* Match with global symbols. This only needs to be done once,
288 after all of the symtabs and dependencies have been read in. */
289 scan_file_globals (objfile
);
292 /* File-level interface functions. */
294 /* Find a file descriptor given its index RF relative to a file CF. */
297 get_rfd (int cf
, int rf
)
303 fdrs
= debug_info
->fdr
;
305 /* Object files do not have the RFD table, all refs are absolute. */
308 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
309 ((char *) debug_info
->external_rfd
311 * debug_swap
->external_rfd_size
)),
316 /* Return a safer print NAME for a file descriptor. */
322 return "<stripped file>";
325 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
329 /* Read in and parse the symtab of the file OBJFILE. Symbols from
330 different sections are relocated via the SECTION_OFFSETS. */
333 mdebug_build_psymtabs (minimal_symbol_reader
&reader
,
334 struct objfile
*objfile
,
335 const struct ecoff_debug_swap
*swap
,
336 struct ecoff_debug_info
*info
)
338 cur_bfd
= objfile
->obfd
;
342 stabsread_new_init ();
343 free_header_files ();
344 init_header_files ();
346 /* Make sure all the FDR information is swapped in. */
347 if (info
->fdr
== NULL
)
353 info
->fdr
= (FDR
*) XOBNEWVEC (&objfile
->objfile_obstack
, FDR
,
354 info
->symbolic_header
.ifdMax
);
355 fdr_src
= (char *) info
->external_fdr
;
357 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
359 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
360 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
363 psymbol_functions
*psf
= new psymbol_functions ();
364 psymtab_storage
*partial_symtabs
= psf
->get_partial_symtabs ().get ();
365 objfile
->qf
.emplace_front (psf
);
366 parse_partial_symbols (reader
, partial_symtabs
, objfile
);
369 /* Check to make sure file was compiled with -g. If not, warn the
370 user of this limitation. */
371 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
373 if (max_gdbinfo
== 0)
374 gdb_printf (_("\n%s not compiled with -g, "
375 "debugging support is limited.\n"),
377 gdb_printf (_("You should compile with -g2 or "
378 "-g3 for best debugging support.\n"));
383 /* Local utilities */
385 /* Map of FDR indexes to partial symtabs. */
389 legacy_psymtab
*pst
= nullptr; /* the psymtab proper */
390 long n_globals
= 0; /* exported globals (external symbols) */
391 long globals_offset
= 0; /* cumulative */
395 /* Utility stack, used to nest procedures and blocks properly.
396 It is a doubly linked list, to avoid too many alloc/free.
397 Since we might need it quite a few times it is NOT deallocated
400 static struct parse_stack
402 struct parse_stack
*next
, *prev
;
403 struct symtab
*cur_st
; /* Current symtab. */
404 struct block
*cur_block
; /* Block in it. */
406 /* What are we parsing. stFile, or stBlock are for files and
407 blocks. stProc or stStaticProc means we have seen the start of a
408 procedure, but not the start of the block within in. When we see
409 the start of that block, we change it to stNil, without pushing a
410 new block, i.e. stNil means both a procedure and a block. */
414 struct type
*cur_type
; /* Type we parse fields for. */
415 int cur_field
; /* Field number in cur_type. */
416 CORE_ADDR procadr
; /* Start addres of this procedure. */
417 int numargs
; /* Its argument count. */
420 *top_stack
; /* Top stack ptr */
423 /* Enter a new lexical context. */
426 push_parse_stack (void)
428 struct parse_stack
*newobj
;
430 /* Reuse frames if possible. */
431 if (top_stack
&& top_stack
->prev
)
432 newobj
= top_stack
->prev
;
434 newobj
= XCNEW (struct parse_stack
);
435 /* Initialize new frame with previous content. */
438 struct parse_stack
*prev
= newobj
->prev
;
440 *newobj
= *top_stack
;
441 top_stack
->prev
= newobj
;
443 newobj
->next
= top_stack
;
448 /* Exit a lexical context. */
451 pop_parse_stack (void)
456 top_stack
= top_stack
->next
;
460 /* Cross-references might be to things we haven't looked at
461 yet, e.g. type references. To avoid too many type
462 duplications we keep a quick fixup table, an array
463 of lists of references indexed by file descriptor. */
465 struct mdebug_pending
467 struct mdebug_pending
*next
; /* link */
468 char *s
; /* the unswapped symbol */
469 struct type
*t
; /* its partial type descriptor */
473 /* The pending information is kept for an entire object file. We
474 allocate the pending information table when we create the partial
475 symbols, and we store a pointer to the single table in each
478 static struct mdebug_pending
**pending_list
;
480 /* Check whether we already saw symbol SH in file FH. */
482 static struct mdebug_pending
*
483 is_pending_symbol (FDR
*fh
, char *sh
)
485 int f_idx
= fh
- debug_info
->fdr
;
486 struct mdebug_pending
*p
;
488 /* Linear search is ok, list is typically no more than 10 deep. */
489 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
495 /* Add a new symbol SH of type T. */
498 add_pending (FDR
*fh
, char *sh
, struct type
*t
)
500 int f_idx
= fh
- debug_info
->fdr
;
501 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
503 /* Make sure we do not make duplicates. */
506 p
= XOBNEW (&mdebugread_objfile
->objfile_obstack
, mdebug_pending
);
509 p
->next
= pending_list
[f_idx
];
510 pending_list
[f_idx
] = p
;
515 /* Parsing Routines proper. */
518 reg_value_complaint (int regnum
, int num_regs
, const char *sym
)
520 complaint (_("bad register number %d (max %d) in symbol %s"),
521 regnum
, num_regs
- 1, sym
);
524 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
525 For blocks, procedures and types we open a new lexical context.
526 This is basically just a big switch on the symbol's type. Argument
527 AX is the base pointer of aux symbols for this file (fh->iauxBase).
528 EXT_SH points to the unswapped symbol, which is needed for struct,
529 union, etc., types; it is NULL for an EXTR. BIGEND says whether
530 aux symbols are big-endian or little-endian. Return count of
531 SYMR's handled (normally one). */
534 mdebug_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
536 int regno
= gdbarch_ecoff_reg_to_regnum (gdbarch
, sym
->value_longest ());
538 if (regno
< 0 || regno
>= gdbarch_num_cooked_regs (gdbarch
))
540 reg_value_complaint (regno
, gdbarch_num_cooked_regs (gdbarch
),
543 regno
= gdbarch_sp_regnum (gdbarch
); /* Known safe, though useless. */
549 static const struct symbol_register_ops mdebug_register_funcs
= {
553 /* The "aclass" indices for computed symbols. */
555 static int mdebug_register_index
;
556 static int mdebug_regparm_index
;
558 /* Common code for symbols describing data. */
561 add_data_symbol (SYMR
*sh
, union aux_ext
*ax
, int bigend
,
562 struct symbol
*s
, int aclass_index
, struct block
*b
,
563 struct objfile
*objfile
, const char *name
)
565 s
->set_domain (VAR_DOMAIN
);
566 s
->set_aclass_index (aclass_index
);
567 add_symbol (s
, top_stack
->cur_st
, b
);
569 /* Type could be missing if file is compiled without debugging info. */
570 if (SC_IS_UNDEF (sh
->sc
)
571 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
572 s
->set_type (objfile_type (objfile
)->nodebug_data_symbol
);
574 s
->set_type (parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
));
575 /* Value of a data symbol is its memory address. */
579 parse_symbol (SYMR
*sh
, union aux_ext
*ax
, char *ext_sh
, int bigend
,
580 const section_offsets
§ion_offsets
, struct objfile
*objfile
)
582 struct gdbarch
*gdbarch
= objfile
->arch ();
583 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
584 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
588 struct mdebug_pending
*pend
;
592 long svalue
= sh
->value
;
596 name
= debug_info
->ssext
+ sh
->iss
;
598 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
604 /* Do not relocate relative values.
605 The value of a stEnd symbol is the displacement from the
606 corresponding start symbol value.
607 The value of a stBlock symbol is the displacement from the
608 procedure address. */
609 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
610 sh
->value
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
617 sh
->value
+= section_offsets
[SECT_OFF_DATA (objfile
)];
621 sh
->value
+= section_offsets
[SECT_OFF_BSS (objfile
)];
630 case stGlobal
: /* External symbol, goes into global block. */
631 b
= BLOCKVECTOR_BLOCK (top_stack
->cur_st
->compunit ()->blockvector (),
633 s
= new_symbol (name
);
634 s
->set_value_address (sh
->value
);
635 add_data_symbol (sh
, ax
, bigend
, s
, LOC_STATIC
, b
, objfile
, name
);
638 case stStatic
: /* Static data, goes into current block. */
639 b
= top_stack
->cur_block
;
640 s
= new_symbol (name
);
641 if (SC_IS_COMMON (sh
->sc
))
643 /* It is a FORTRAN common block. At least for SGI Fortran the
644 address is not in the symbol; we need to fix it later in
645 scan_file_globals. */
646 int bucket
= hashname (s
->linkage_name ());
647 s
->set_value_chain (global_sym_chain
[bucket
]);
648 global_sym_chain
[bucket
] = s
;
651 s
->set_value_address (sh
->value
);
652 add_data_symbol (sh
, ax
, bigend
, s
, LOC_STATIC
, b
, objfile
, name
);
655 case stLocal
: /* Local variable, goes into current block. */
656 b
= top_stack
->cur_block
;
657 s
= new_symbol (name
);
658 s
->set_value_longest (svalue
);
659 if (sh
->sc
== scRegister
)
660 add_data_symbol (sh
, ax
, bigend
, s
, mdebug_register_index
,
663 add_data_symbol (sh
, ax
, bigend
, s
, LOC_LOCAL
,
667 case stParam
: /* Arg to procedure, goes into current
670 found_ecoff_debugging_info
= 1;
671 top_stack
->numargs
++;
673 /* Special GNU C++ name. */
674 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
675 name
= "this"; /* FIXME, not alloc'd in obstack. */
676 s
= new_symbol (name
);
678 s
->set_domain (VAR_DOMAIN
);
679 s
->set_is_argument (1);
683 /* Pass by value in register. */
684 s
->set_aclass_index (mdebug_register_index
);
687 /* Pass by reference on stack. */
688 s
->set_aclass_index (LOC_REF_ARG
);
691 /* Pass by reference in register. */
692 s
->set_aclass_index (mdebug_regparm_index
);
695 /* Pass by value on stack. */
696 s
->set_aclass_index (LOC_ARG
);
699 s
->set_value_longest (svalue
);
700 s
->set_type (parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
));
701 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
704 case stLabel
: /* label, goes into current block. */
705 s
= new_symbol (name
);
706 s
->set_domain (VAR_DOMAIN
); /* So that it can be used */
707 s
->set_aclass_index (LOC_LABEL
); /* but not misused. */
708 s
->set_value_address (sh
->value
);
709 s
->set_type (objfile_type (objfile
)->builtin_int
);
710 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
713 case stProc
: /* Procedure, usually goes into global block. */
714 case stStaticProc
: /* Static procedure, goes into current block. */
715 /* For stProc symbol records, we need to check the storage class
716 as well, as only (stProc, scText) entries represent "real"
717 procedures - See the Compaq document titled "Object File /
718 Symbol Table Format Specification" for more information.
719 If the storage class is not scText, we discard the whole block
720 of symbol records for this stProc. */
721 if (sh
->st
== stProc
&& sh
->sc
!= scText
)
723 char *ext_tsym
= ext_sh
;
724 int keep_counting
= 1;
727 while (keep_counting
)
729 ext_tsym
+= external_sym_size
;
730 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
740 complaint (_("unknown symbol type 0x%x"), sh
->st
);
746 s
= new_symbol (name
);
747 s
->set_domain (VAR_DOMAIN
);
748 s
->set_aclass_index (LOC_BLOCK
);
749 /* Type of the return value. */
750 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
751 t
= objfile_type (objfile
)->builtin_int
;
754 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
755 if (strcmp (name
, "malloc") == 0
756 && t
->code () == TYPE_CODE_VOID
)
758 /* I don't know why, but, at least under Alpha GNU/Linux,
759 when linking against a malloc without debugging
760 symbols, its read as a function returning void---this
761 is bad because it means we cannot call functions with
762 string arguments interactively; i.e., "call
763 printf("howdy\n")" would fail with the error message
764 "program has no memory available". To avoid this, we
765 patch up the type and make it void*
766 instead. (davidm@azstarnet.com). */
767 t
= make_pointer_type (t
, NULL
);
770 b
= top_stack
->cur_block
;
771 if (sh
->st
== stProc
)
773 const struct blockvector
*bv
774 = top_stack
->cur_st
->compunit ()->blockvector ();
776 /* The next test should normally be true, but provides a
777 hook for nested functions (which we don't want to make
779 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
780 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
781 /* Irix 5 sometimes has duplicate names for the same
782 function. We want to add such names up at the global
783 level, not as a nested function. */
784 else if (sh
->value
== top_stack
->procadr
)
785 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
787 add_symbol (s
, top_stack
->cur_st
, b
);
789 /* Make a type for the procedure itself. */
790 s
->set_type (lookup_function_type (t
));
792 /* All functions in C++ have prototypes. For C we don't have enough
793 information in the debug info. */
794 if (s
->language () == language_cplus
)
795 s
->type ()->set_is_prototyped (true);
797 /* Create and enter a new lexical context. */
798 b
= new_block (FUNCTION_BLOCK
, s
->language ());
799 s
->set_value_block (b
);
801 b
->set_start (sh
->value
);
802 b
->set_end (sh
->value
);
803 b
->set_superblock (top_stack
->cur_block
);
804 add_block (b
, top_stack
->cur_st
);
806 /* Not if we only have partial info. */
807 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
811 top_stack
->cur_block
= b
;
812 top_stack
->blocktype
= sh
->st
;
813 top_stack
->cur_type
= s
->type ();
814 top_stack
->cur_field
= -1;
815 top_stack
->procadr
= sh
->value
;
816 top_stack
->numargs
= 0;
819 /* Beginning of code for structure, union, and enum definitions.
820 They all share a common set of local variables, defined here. */
822 enum type_code type_code
;
828 case stStruct
: /* Start a block defining a struct type. */
829 type_code
= TYPE_CODE_STRUCT
;
830 goto structured_common
;
832 case stUnion
: /* Start a block defining a union type. */
833 type_code
= TYPE_CODE_UNION
;
834 goto structured_common
;
836 case stEnum
: /* Start a block defining an enum type. */
837 type_code
= TYPE_CODE_ENUM
;
838 goto structured_common
;
840 case stBlock
: /* Either a lexical block, or some type. */
841 if (sh
->sc
!= scInfo
&& !SC_IS_COMMON (sh
->sc
))
842 goto case_stBlock_code
; /* Lexical block */
844 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
846 /* Common code for handling struct, union, enum, and/or as-yet-
847 unknown-type blocks of info about structured data. `type_code'
848 has been set to the proper TYPE_CODE, if we know it. */
850 found_ecoff_debugging_info
= 1;
852 top_stack
->blocktype
= stBlock
;
854 /* First count the number of fields and the highest value. */
857 for (ext_tsym
= ext_sh
+ external_sym_size
;
859 ext_tsym
+= external_sym_size
)
863 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
868 /* C++ encodes class types as structures where there the
869 methods are encoded as stProc. The scope of stProc
870 symbols also ends with stEnd, thus creating a risk of
871 taking the wrong stEnd symbol record as the end of
872 the current struct, which would cause GDB to undercount
873 the real number of fields in this struct. To make sure
874 we really reached the right stEnd symbol record, we
875 check the associated name, and match it against the
876 struct name. Since method names are mangled while
877 the class name is not, there is no risk of having a
878 method whose name is identical to the class name
879 (in particular constructor method names are different
880 from the class name). There is therefore no risk that
881 this check stops the count on the StEnd of a method.
883 Also, assume that we're really at the end when tsym.iss
885 if (tsym
.iss
== issNull
886 || strcmp (debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
,
892 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
894 /* If the type of the member is Nil (or Void),
895 without qualifiers, assume the tag is an
897 Alpha cc -migrate enums are recognized by a zero
898 index and a zero symbol value.
899 DU 4.0 cc enums are recognized by a member type of
900 btEnum without qualifiers and a zero symbol value. */
901 if (tsym
.index
== indexNil
902 || (tsym
.index
== 0 && sh
->value
== 0))
903 type_code
= TYPE_CODE_ENUM
;
906 (*debug_swap
->swap_tir_in
) (bigend
,
907 &ax
[tsym
.index
].a_ti
,
909 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
910 || (tir
.bt
== btEnum
&& sh
->value
== 0))
912 type_code
= TYPE_CODE_ENUM
;
916 if (tsym
.value
> max_value
)
917 max_value
= tsym
.value
;
926 /* This is a no-op; is it trying to tell us something
927 we should be checking? */
928 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED */
932 /* This is something like a struct within a
933 struct. Skip over the fields of the inner
934 struct. The -1 is because the for loop will
935 increment ext_tsym. */
936 ext_tsym
= ((char *) debug_info
->external_sym
937 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
938 * external_sym_size
));
944 /* mips cc puts out a typedef for struct x if it is not yet
945 defined when it encounters
946 struct y { struct x *xp; };
951 /* Irix5 cc puts out a stIndirect for struct x if it is not
952 yet defined when it encounters
953 struct y { struct x *xp; };
958 complaint (_("declaration block contains "
959 "unhandled symbol type %d"),
965 /* In an stBlock, there is no way to distinguish structs,
966 unions, and enums at this point. This is a bug in the
967 original design (that has been fixed with the recent
968 addition of the stStruct, stUnion, and stEnum symbol
969 types.) The way you can tell is if/when you see a variable
970 or field of that type. In that case the variable's type
971 (in the AUX table) says if the type is struct, union, or
972 enum, and points back to the stBlock here. So you can
973 patch the tag kind up later - but only if there actually is
974 a variable or field of that type.
976 So until we know for sure, we will guess at this point.
978 If the first member has index==indexNil or a void type,
979 assume we have an enumeration.
980 Otherwise, if there is more than one member, and all
981 the members have offset 0, assume we have a union.
982 Otherwise, assume we have a struct.
984 The heuristic could guess wrong in the case of of an
985 enumeration with no members or a union with one (or zero)
986 members, or when all except the last field of a struct have
987 width zero. These are uncommon and/or illegal situations,
988 and in any case guessing wrong probably doesn't matter
991 But if we later do find out we were wrong, we fixup the tag
992 kind. Members of an enumeration must be handled
993 differently from struct/union fields, and that is harder to
994 patch up, but luckily we shouldn't need to. (If there are
995 any enumeration members, we can tell for sure it's an enum
998 if (type_code
== TYPE_CODE_UNDEF
)
1000 if (nfields
> 1 && max_value
== 0)
1001 type_code
= TYPE_CODE_UNION
;
1003 type_code
= TYPE_CODE_STRUCT
;
1006 /* Create a new type or use the pending type. */
1007 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1010 t
= new_type (NULL
);
1011 add_pending (cur_fdr
, ext_sh
, t
);
1016 /* Do not set the tag name if it is a compiler generated tag name
1017 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1018 Alpha cc puts out an sh->iss of zero for those. */
1019 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1022 t
->set_name (obconcat (&mdebugread_objfile
->objfile_obstack
,
1023 name
, (char *) NULL
));
1025 t
->set_code (type_code
);
1026 TYPE_LENGTH (t
) = sh
->value
;
1027 t
->set_num_fields (nfields
);
1028 f
= ((struct field
*) TYPE_ALLOC (t
, nfields
* sizeof (struct field
)));
1031 if (type_code
== TYPE_CODE_ENUM
)
1033 int unsigned_enum
= 1;
1035 /* This is a non-empty enum. */
1037 /* DEC c89 has the number of enumerators in the sh.value field,
1038 not the type length, so we have to compensate for that
1039 incompatibility quirk.
1040 This might do the wrong thing for an enum with one or two
1041 enumerators and gcc -gcoff -fshort-enums, but these cases
1042 are hopefully rare enough.
1043 Alpha cc -migrate has a sh.value field of zero, we adjust
1045 if (TYPE_LENGTH (t
) == t
->num_fields ()
1046 || TYPE_LENGTH (t
) == 0)
1047 TYPE_LENGTH (t
) = gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
1048 for (ext_tsym
= ext_sh
+ external_sym_size
;
1050 ext_tsym
+= external_sym_size
)
1053 struct symbol
*enum_sym
;
1055 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1057 if (tsym
.st
!= stMember
)
1060 f
->set_loc_enumval (tsym
.value
);
1062 f
->set_name (debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
);
1063 FIELD_BITSIZE (*f
) = 0;
1065 enum_sym
= new (&mdebugread_objfile
->objfile_obstack
) symbol
;
1066 enum_sym
->set_linkage_name
1067 (obstack_strdup (&mdebugread_objfile
->objfile_obstack
,
1069 enum_sym
->set_aclass_index (LOC_CONST
);
1070 enum_sym
->set_type (t
);
1071 enum_sym
->set_domain (VAR_DOMAIN
);
1072 enum_sym
->set_value_longest (tsym
.value
);
1073 if (enum_sym
->value_longest () < 0)
1075 add_symbol (enum_sym
, top_stack
->cur_st
, top_stack
->cur_block
);
1077 /* Skip the stMembers that we've handled. */
1082 t
->set_is_unsigned (true);
1084 /* Make this the current type. */
1085 top_stack
->cur_type
= t
;
1086 top_stack
->cur_field
= 0;
1088 /* Do not create a symbol for alpha cc unnamed structs. */
1092 /* gcc puts out an empty struct for an opaque struct definitions,
1093 do not create a symbol for it either. */
1094 if (t
->num_fields () == 0)
1096 t
->set_is_stub (true);
1100 s
= new_symbol (name
);
1101 s
->set_domain (STRUCT_DOMAIN
);
1102 s
->set_aclass_index (LOC_TYPEDEF
);
1103 s
->set_value_longest (0);
1105 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1108 /* End of local variables shared by struct, union, enum, and
1109 block (as yet unknown struct/union/enum) processing. */
1113 found_ecoff_debugging_info
= 1;
1114 /* Beginnning of (code) block. Value of symbol
1115 is the displacement from procedure start. */
1116 push_parse_stack ();
1118 /* Do not start a new block if this is the outermost block of a
1119 procedure. This allows the LOC_BLOCK symbol to point to the
1120 block with the local variables, so funcname::var works. */
1121 if (top_stack
->blocktype
== stProc
1122 || top_stack
->blocktype
== stStaticProc
)
1124 top_stack
->blocktype
= stNil
;
1128 top_stack
->blocktype
= stBlock
;
1129 b
= new_block (NON_FUNCTION_BLOCK
, psymtab_language
);
1130 b
->set_start (sh
->value
+ top_stack
->procadr
);
1131 b
->set_superblock (top_stack
->cur_block
);
1132 top_stack
->cur_block
= b
;
1133 add_block (b
, top_stack
->cur_st
);
1136 case stEnd
: /* end (of anything) */
1137 if (sh
->sc
== scInfo
|| SC_IS_COMMON (sh
->sc
))
1139 /* Finished with type */
1140 top_stack
->cur_type
= 0;
1142 else if (sh
->sc
== scText
&&
1143 (top_stack
->blocktype
== stProc
||
1144 top_stack
->blocktype
== stStaticProc
))
1146 /* Finished with procedure */
1147 const struct blockvector
*bv
1148 = top_stack
->cur_st
->compunit ()->blockvector ();
1149 struct mdebug_extra_func_info
*e
;
1150 struct block
*cblock
= top_stack
->cur_block
;
1151 struct type
*ftype
= top_stack
->cur_type
;
1154 top_stack
->cur_block
->set_end
1155 (top_stack
->cur_block
->end () + sh
->value
); /* size */
1157 /* Make up special symbol to contain procedure specific info. */
1158 s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
1159 s
->set_domain (LABEL_DOMAIN
);
1160 s
->set_aclass_index (LOC_CONST
);
1161 s
->set_type (objfile_type (mdebugread_objfile
)->builtin_void
);
1162 e
= OBSTACK_ZALLOC (&mdebugread_objfile
->objfile_obstack
,
1163 mdebug_extra_func_info
);
1164 s
->set_value_bytes ((gdb_byte
*) e
);
1165 e
->numargs
= top_stack
->numargs
;
1166 e
->pdr
.framereg
= -1;
1167 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1169 /* f77 emits proc-level with address bounds==[0,0],
1170 So look for such child blocks, and patch them. */
1171 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1173 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1175 if (b_bad
->superblock () == cblock
1176 && b_bad
->start () == top_stack
->procadr
1177 && b_bad
->end () == top_stack
->procadr
)
1179 b_bad
->set_start (cblock
->start ());
1180 b_bad
->set_end (cblock
->end ());
1184 if (ftype
->num_fields () <= 0)
1186 /* No parameter type information is recorded with the function's
1187 type. Set that from the type of the parameter symbols. */
1188 int nparams
= top_stack
->numargs
;
1194 struct block_iterator iter
;
1196 ftype
->set_num_fields (nparams
);
1199 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
)));
1202 ALL_BLOCK_SYMBOLS (cblock
, iter
, sym
)
1204 if (iparams
== nparams
)
1207 if (sym
->is_argument ())
1209 ftype
->field (iparams
).set_type (sym
->type ());
1210 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
1217 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1219 /* End of (code) block. The value of the symbol is the
1220 displacement from the procedure`s start address of the
1221 end of this block. */
1222 top_stack
->cur_block
->set_end (sh
->value
+ top_stack
->procadr
);
1224 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1226 /* End of outermost block. Pop parse stack and ignore. The
1227 following stEnd of stProc will take care of the block. */
1230 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1232 /* End of file. Pop parse stack and ignore. Higher
1233 level code deals with this. */
1237 complaint (_("stEnd with storage class %d not handled"), sh
->sc
);
1239 pop_parse_stack (); /* Restore previous lexical context. */
1242 case stMember
: /* member of struct or union */
1244 struct field
*f
= &top_stack
->cur_type
->field (top_stack
->cur_field
);
1245 top_stack
->cur_field
++;
1247 f
->set_loc_bitpos (sh
->value
);
1249 f
->set_type (parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
,
1251 FIELD_BITSIZE (*f
) = bitsize
;
1255 case stIndirect
: /* forward declaration on Irix5 */
1256 /* Forward declarations from Irix5 cc are handled by cross_ref,
1260 case stTypedef
: /* type definition */
1261 found_ecoff_debugging_info
= 1;
1263 /* Typedefs for forward declarations and opaque structs from alpha cc
1264 are handled by cross_ref, skip them. */
1268 /* Parse the type or use the pending type. */
1269 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1272 t
= parse_type (cur_fd
, ax
, sh
->index
, NULL
, bigend
, name
);
1273 add_pending (cur_fdr
, ext_sh
, t
);
1278 /* Mips cc puts out a typedef with the name of the struct for forward
1279 declarations. These should not go into the symbol table and
1280 TYPE_NAME should not be set for them.
1281 They can't be distinguished from an intentional typedef to
1282 the same name however:
1284 struct x { int ix; int jx; };
1288 struct xx {int ixx; int jxx; };
1289 generates a cross referencing stTypedef for x and xx.
1290 The user visible effect of this is that the type of a pointer
1291 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1292 The problem is fixed with alpha cc and Irix5 cc. */
1294 /* However if the typedef cross references to an opaque aggregate, it
1295 is safe to omit it from the symbol table. */
1297 if (has_opaque_xref (cur_fdr
, sh
))
1299 s
= new_symbol (name
);
1300 s
->set_domain (VAR_DOMAIN
);
1301 s
->set_aclass_index (LOC_TYPEDEF
);
1302 s
->set_value_block (top_stack
->cur_block
);
1304 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1306 /* Incomplete definitions of structs should not get a name. */
1307 if (s
->type ()->name () == NULL
1308 && (s
->type ()->num_fields () != 0
1309 || (s
->type ()->code () != TYPE_CODE_STRUCT
1310 && s
->type ()->code () != TYPE_CODE_UNION
)))
1312 if (s
->type ()->code () == TYPE_CODE_PTR
1313 || s
->type ()->code () == TYPE_CODE_FUNC
)
1315 /* If we are giving a name to a type such as "pointer to
1316 foo" or "function returning foo", we better not set
1317 the TYPE_NAME. If the program contains "typedef char
1318 *caddr_t;", we don't want all variables of type char
1319 * to print as caddr_t. This is not just a
1320 consequence of GDB's type management; CC and GCC (at
1321 least through version 2.4) both output variables of
1322 either type char * or caddr_t with the type
1323 refering to the stTypedef symbol for caddr_t. If a future
1324 compiler cleans this up it GDB is not ready for it
1325 yet, but if it becomes ready we somehow need to
1326 disable this check (without breaking the PCC/GCC2.4
1331 Fortunately, this check seems not to be necessary
1332 for anything except pointers or functions. */
1335 s
->type ()->set_name (s
->linkage_name ());
1339 case stFile
: /* file name */
1340 push_parse_stack ();
1341 top_stack
->blocktype
= sh
->st
;
1344 /* I`ve never seen these for C */
1346 break; /* register relocation */
1348 break; /* forwarding address */
1350 break; /* constant */
1352 complaint (_("unknown symbol type 0x%x"), sh
->st
);
1361 static const struct objfile_key
<struct type
*,
1362 gdb::noop_deleter
<struct type
*>>
1365 static struct type
*
1366 basic_type (int bt
, struct objfile
*objfile
)
1368 struct gdbarch
*gdbarch
= objfile
->arch ();
1369 struct type
**map_bt
= basic_type_data
.get (objfile
);
1377 map_bt
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
1378 btMax
, struct type
*);
1379 basic_type_data
.set (objfile
, map_bt
);
1388 tp
= objfile_type (objfile
)->builtin_void
;
1392 tp
= init_pointer_type (objfile
, 32, "adr_32",
1393 objfile_type (objfile
)->builtin_void
);
1397 tp
= init_integer_type (objfile
, 8, 0, "char");
1398 tp
->set_has_no_signedness (true);
1402 tp
= init_integer_type (objfile
, 8, 1, "unsigned char");
1406 tp
= init_integer_type (objfile
, 16, 0, "short");
1410 tp
= init_integer_type (objfile
, 16, 1, "unsigned short");
1414 tp
= init_integer_type (objfile
, 32, 0, "int");
1418 tp
= init_integer_type (objfile
, 32, 1, "unsigned int");
1422 tp
= init_integer_type (objfile
, 32, 0, "long");
1426 tp
= init_integer_type (objfile
, 32, 1, "unsigned long");
1430 tp
= init_float_type (objfile
, gdbarch_float_bit (gdbarch
),
1431 "float", gdbarch_float_format (gdbarch
));
1435 tp
= init_float_type (objfile
, gdbarch_double_bit (gdbarch
),
1436 "double", gdbarch_double_format (gdbarch
));
1440 tp
= init_complex_type ("complex", basic_type (btFloat
, objfile
));
1444 tp
= init_complex_type ("double complex", basic_type (btFloat
, objfile
));
1448 /* We use TYPE_CODE_INT to print these as integers. Does this do any
1449 good? Would we be better off with TYPE_CODE_ERROR? Should
1450 TYPE_CODE_ERROR print things in hex if it knows the size? */
1451 tp
= init_integer_type (objfile
, gdbarch_int_bit (gdbarch
), 0,
1456 tp
= init_type (objfile
, TYPE_CODE_ERROR
,
1457 gdbarch_double_bit (gdbarch
), "floating decimal");
1461 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
1463 tp
= init_type (objfile
, TYPE_CODE_STRING
, TARGET_CHAR_BIT
, "string");
1467 tp
= objfile_type (objfile
)->builtin_void
;
1471 tp
= init_integer_type (objfile
, 64, 0, "long");
1475 tp
= init_integer_type (objfile
, 64, 1, "unsigned long");
1479 tp
= init_integer_type (objfile
, 64, 0, "long long");
1483 tp
= init_integer_type (objfile
, 64, 1, "unsigned long long");
1487 tp
= init_pointer_type (objfile
, 64, "adr_64",
1488 objfile_type (objfile
)->builtin_void
);
1492 tp
= init_integer_type (objfile
, 64, 0, "int");
1496 tp
= init_integer_type (objfile
, 64, 1, "unsigned int");
1508 /* Parse the type information provided in the raw AX entries for
1509 the symbol SH. Return the bitfield size in BS, in case.
1510 We must byte-swap the AX entries before we use them; BIGEND says whether
1511 they are big-endian or little-endian (from fh->fBigendian). */
1513 static struct type
*
1514 parse_type (int fd
, union aux_ext
*ax
, unsigned int aux_index
, int *bs
,
1515 int bigend
, const char *sym_name
)
1518 struct type
*tp
= 0;
1519 enum type_code type_code
= TYPE_CODE_UNDEF
;
1521 /* Handle undefined types, they have indexNil. */
1522 if (aux_index
== indexNil
)
1523 return basic_type (btInt
, mdebugread_objfile
);
1525 /* Handle corrupt aux indices. */
1526 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1528 index_complaint (sym_name
);
1529 return basic_type (btInt
, mdebugread_objfile
);
1533 /* Use aux as a type information record, map its basic type. */
1534 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1535 tp
= basic_type (t
->bt
, mdebugread_objfile
);
1538 /* Cannot use builtin types -- build our own. */
1542 type_code
= TYPE_CODE_STRUCT
;
1545 type_code
= TYPE_CODE_UNION
;
1548 type_code
= TYPE_CODE_ENUM
;
1551 type_code
= TYPE_CODE_RANGE
;
1554 type_code
= TYPE_CODE_SET
;
1557 /* alpha cc -migrate uses this for typedefs. The true type will
1558 be obtained by crossreferencing below. */
1559 type_code
= TYPE_CODE_ERROR
;
1562 /* alpha cc uses this for typedefs. The true type will be
1563 obtained by crossreferencing below. */
1564 type_code
= TYPE_CODE_ERROR
;
1567 basic_type_complaint (t
->bt
, sym_name
);
1568 return basic_type (btInt
, mdebugread_objfile
);
1572 /* Move on to next aux. */
1577 int width
= AUX_GET_WIDTH (bigend
, ax
);
1579 /* Inhibit core dumps if TIR is corrupted. */
1582 /* Alpha cc -migrate encodes char and unsigned char types
1583 as short and unsigned short types with a field width of 8.
1584 Enum types also have a field width which we ignore for now. */
1585 if (t
->bt
== btShort
&& width
== 8)
1586 tp
= basic_type (btChar
, mdebugread_objfile
);
1587 else if (t
->bt
== btUShort
&& width
== 8)
1588 tp
= basic_type (btUChar
, mdebugread_objfile
);
1589 else if (t
->bt
== btEnum
)
1592 complaint (_("can't handle TIR fBitfield for %s"),
1600 /* A btIndirect entry cross references to an aux entry containing
1602 if (t
->bt
== btIndirect
)
1609 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1611 if (rn
->rfd
== 0xfff)
1613 rf
= AUX_GET_ISYM (bigend
, ax
);
1621 complaint (_("unable to cross ref btIndirect for %s"), sym_name
);
1622 return basic_type (btInt
, mdebugread_objfile
);
1624 xref_fh
= get_rfd (fd
, rf
);
1625 xref_fd
= xref_fh
- debug_info
->fdr
;
1626 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1627 rn
->index
, NULL
, xref_fh
->fBigendian
, sym_name
);
1630 /* All these types really point to some (common) MIPS type
1631 definition, and only the type-qualifiers fully identify
1632 them. We'll make the same effort at sharing. */
1633 if (t
->bt
== btStruct
||
1637 /* btSet (I think) implies that the name is a tag name, not a typedef
1638 name. This apparently is a MIPS extension for C sets. */
1643 /* Try to cross reference this type, build new type on failure. */
1644 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1646 tp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
1648 /* DEC c89 produces cross references to qualified aggregate types,
1649 dereference them. */
1650 while (tp
->code () == TYPE_CODE_PTR
1651 || tp
->code () == TYPE_CODE_ARRAY
)
1652 tp
= TYPE_TARGET_TYPE (tp
);
1654 /* Make sure that TYPE_CODE(tp) has an expected type code.
1655 Any type may be returned from cross_ref if file indirect entries
1657 if (tp
->code () != TYPE_CODE_STRUCT
1658 && tp
->code () != TYPE_CODE_UNION
1659 && tp
->code () != TYPE_CODE_ENUM
)
1661 unexpected_type_code_complaint (sym_name
);
1665 /* Usually, TYPE_CODE(tp) is already type_code. The main
1666 exception is if we guessed wrong re struct/union/enum.
1667 But for struct vs. union a wrong guess is harmless, so
1668 don't complain(). */
1669 if ((tp
->code () == TYPE_CODE_ENUM
1670 && type_code
!= TYPE_CODE_ENUM
)
1671 || (tp
->code () != TYPE_CODE_ENUM
1672 && type_code
== TYPE_CODE_ENUM
))
1674 bad_tag_guess_complaint (sym_name
);
1677 if (tp
->code () != type_code
)
1679 tp
->set_code (type_code
);
1682 /* Do not set the tag name if it is a compiler generated tag name
1683 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1684 if (name
[0] == '.' || name
[0] == '\0')
1685 tp
->set_name (NULL
);
1686 else if (tp
->name () == NULL
1687 || strcmp (tp
->name (), name
) != 0)
1688 tp
->set_name (obstack_strdup (&mdebugread_objfile
->objfile_obstack
,
1693 /* All these types really point to some (common) MIPS type
1694 definition, and only the type-qualifiers fully identify
1695 them. We'll make the same effort at sharing.
1696 FIXME: We are not doing any guessing on range types. */
1697 if (t
->bt
== btRange
)
1701 /* Try to cross reference this type, build new type on failure. */
1702 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1704 tp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
1706 /* Make sure that TYPE_CODE(tp) has an expected type code.
1707 Any type may be returned from cross_ref if file indirect entries
1709 if (tp
->code () != TYPE_CODE_RANGE
)
1711 unexpected_type_code_complaint (sym_name
);
1715 /* Usually, TYPE_CODE(tp) is already type_code. The main
1716 exception is if we guessed wrong re struct/union/enum. */
1717 if (tp
->code () != type_code
)
1719 bad_tag_guess_complaint (sym_name
);
1720 tp
->set_code (type_code
);
1722 if (tp
->name () == NULL
1723 || strcmp (tp
->name (), name
) != 0)
1724 tp
->set_name (obstack_strdup (&mdebugread_objfile
->objfile_obstack
,
1728 if (t
->bt
== btTypedef
)
1732 /* Try to cross reference this type, it should succeed. */
1733 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1736 complaint (_("unable to cross ref btTypedef for %s"), sym_name
);
1737 tp
= basic_type (btInt
, mdebugread_objfile
);
1741 /* Deal with range types. */
1742 if (t
->bt
== btRange
)
1744 tp
->set_num_fields (0);
1745 tp
->set_bounds (((struct range_bounds
*)
1746 TYPE_ZALLOC (tp
, sizeof (struct range_bounds
))));
1747 tp
->bounds ()->low
.set_const_val (AUX_GET_DNLOW (bigend
, ax
));
1749 tp
->bounds ()->high
.set_const_val (AUX_GET_DNHIGH (bigend
, ax
));
1753 /* Parse all the type qualifiers now. If there are more
1754 than 6 the game will continue in the next aux. */
1758 #define PARSE_TQ(tq) \
1759 if (t->tq != tqNil) \
1760 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1772 /* mips cc 2.x and gcc never put out continued aux entries. */
1776 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1780 /* Complain for illegal continuations due to corrupt aux entries. */
1782 complaint (_("illegal TIR continued for %s"), sym_name
);
1787 /* Make up a complex type from a basic one. Type is passed by
1788 reference in TPP and side-effected as necessary. The type
1789 qualifier TQ says how to handle the aux symbols at AX for
1790 the symbol SX we are currently analyzing. BIGEND says whether
1791 aux symbols are big-endian or little-endian.
1792 Returns the number of aux symbols we parsed. */
1795 upgrade_type (int fd
, struct type
**tpp
, int tq
, union aux_ext
*ax
, int bigend
,
1796 const char *sym_name
)
1801 /* Used in array processing. */
1812 t
= lookup_pointer_type (*tpp
);
1817 t
= lookup_function_type (*tpp
);
1824 /* Determine and record the domain type (type of index). */
1825 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1831 rf
= AUX_GET_ISYM (bigend
, ax
);
1834 fh
= get_rfd (fd
, rf
);
1836 indx
= parse_type (fh
- debug_info
->fdr
,
1837 debug_info
->external_aux
+ fh
->iauxBase
,
1838 id
, NULL
, bigend
, sym_name
);
1840 /* The bounds type should be an integer type, but might be anything
1841 else due to corrupt aux entries. */
1842 if (indx
->code () != TYPE_CODE_INT
)
1844 complaint (_("illegal array index type for %s, assuming int"),
1846 indx
= objfile_type (mdebugread_objfile
)->builtin_int
;
1849 /* Get the bounds, and create the array type. */
1851 lower
= AUX_GET_DNLOW (bigend
, ax
);
1853 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1855 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1857 range
= create_static_range_type (NULL
, indx
, lower
, upper
);
1859 t
= create_array_type (NULL
, *tpp
, range
);
1861 /* We used to fill in the supplied array element bitsize
1862 here if the TYPE_LENGTH of the target type was zero.
1863 This happens for a `pointer to an array of anonymous structs',
1864 but in this case the array element bitsize is also zero,
1865 so nothing is gained.
1866 And we used to check the TYPE_LENGTH of the target type against
1867 the supplied array element bitsize.
1868 gcc causes a mismatch for `pointer to array of object',
1869 since the sdb directives it uses do not have a way of
1870 specifying the bitsize, but it does no harm (the
1871 TYPE_LENGTH should be correct) and we should be able to
1872 ignore the erroneous bitsize from the auxiliary entry safely.
1873 dbx seems to ignore it too. */
1875 /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */
1876 if (TYPE_LENGTH (*tpp
) == 0)
1877 t
->set_target_is_stub (true);
1883 /* Volatile -- currently ignored */
1887 /* Const -- currently ignored */
1891 complaint (_("unknown type qualifier 0x%x"), tq
);
1897 /* Parse a procedure descriptor record PR. Note that the procedure is
1898 parsed _after_ the local symbols, now we just insert the extra
1899 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1900 already been placed in the procedure's main block. Note also that
1901 images that have been partially stripped (ld -x) have been deprived
1902 of local symbols, and we have to cope with them here. FIRST_OFF is
1903 the offset of the first procedure for this FDR; we adjust the
1904 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1905 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1906 in question, or NULL to use top_stack->cur_block. */
1909 parse_procedure (PDR
*pr
, struct compunit_symtab
*search_symtab
,
1910 legacy_psymtab
*pst
)
1912 struct symbol
*s
, *i
;
1913 const struct block
*b
;
1916 /* Simple rule to find files linked "-x". */
1917 if (cur_fdr
->rss
== -1)
1921 /* Static procedure at address pr->adr. Sigh. */
1922 /* FIXME-32x64. assuming pr->adr fits in long. */
1923 complaint (_("can't handle PDR for static proc at 0x%lx"),
1924 (unsigned long) pr
->adr
);
1932 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1933 ((char *) debug_info
->external_ext
1935 * debug_swap
->external_ext_size
)),
1937 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1945 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1946 ((char *) debug_info
->external_sym
1947 + ((cur_fdr
->isymBase
+ pr
->isym
)
1948 * debug_swap
->external_sym_size
)),
1950 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1953 if (search_symtab
!= NULL
)
1956 /* This loses both in the case mentioned (want a static, find a global),
1957 but also if we are looking up a non-mangled name which happens to
1958 match the name of a mangled function. */
1959 /* We have to save the cur_fdr across the call to lookup_symbol.
1960 If the pdr is for a static function and if a global function with
1961 the same name exists, lookup_symbol will eventually read in the symtab
1962 for the global function and clobber cur_fdr. */
1963 FDR
*save_cur_fdr
= cur_fdr
;
1965 s
= lookup_symbol (sh_name
, NULL
, VAR_DOMAIN
, 0);
1966 cur_fdr
= save_cur_fdr
;
1970 BLOCKVECTOR_BLOCK (search_symtab
->blockvector (),
1977 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1978 VAR_DOMAIN
, LOC_BLOCK
);
1982 b
= s
->value_block ();
1986 complaint (_("PDR for %s, but no symbol"), sh_name
);
1990 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1991 s
= new_symbol (sh_name
);
1992 s
->set_domain (VAR_DOMAIN
);
1993 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1994 /* Don't know its type, hope int is ok. */
1996 = lookup_function_type (objfile_type (pst
->objfile
)->builtin_int
);
1997 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1998 /* Won't have symbols for this one. */
2000 SYMBOL_BLOCK_VALUE (s
) = b
;
2001 BLOCK_FUNCTION (b
) = s
;
2002 BLOCK_START (b
) = pr
->adr
;
2003 /* BOUND used to be the end of procedure's text, but the
2004 argument is no longer passed in. */
2005 BLOCK_END (b
) = bound
;
2006 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
2007 add_block (b
, top_stack
->cur_st
);
2011 i
= mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME
, b
, LABEL_DOMAIN
, LOC_CONST
);
2015 struct mdebug_extra_func_info
*e
;
2017 e
= (struct mdebug_extra_func_info
*) i
->value_bytes ();
2020 /* GDB expects the absolute function start address for the
2021 procedure descriptor in e->pdr.adr.
2022 As the address in the procedure descriptor is usually relative,
2023 we would have to relocate e->pdr.adr with cur_fdr->adr.
2024 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2025 in shared libraries on some systems, and on other systems
2026 e->pdr.adr is sometimes offset by a bogus value.
2027 To work around these problems, we replace e->pdr.adr with
2028 the start address of the function. */
2029 e
->pdr
.adr
= b
->start ();
2032 /* It would be reasonable that functions that have been compiled
2033 without debugging info have a btNil type for their return value,
2034 and functions that are void and are compiled with debugging info
2036 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2037 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2039 The glevel field in cur_fdr could be used to determine the presence
2040 of debugging info, but GCC doesn't always pass the -g switch settings
2041 to the assembler and GAS doesn't set the glevel field from the -g switch
2043 To work around these problems, the return value type of a TYPE_CODE_VOID
2044 function is adjusted accordingly if no debugging info was found in the
2045 compilation unit. */
2047 if (processing_gcc_compilation
== 0
2048 && found_ecoff_debugging_info
== 0
2049 && TYPE_TARGET_TYPE (s
->type ())->code () == TYPE_CODE_VOID
)
2050 s
->set_type (objfile_type (mdebugread_objfile
)->nodebug_text_symbol
);
2053 /* Parse the external symbol ES. Just call parse_symbol() after
2054 making sure we know where the aux are for it.
2055 BIGEND says whether aux entries are big-endian or little-endian.
2057 This routine clobbers top_stack->cur_block and ->cur_st. */
2060 parse_external (EXTR
*es
, int bigend
, const section_offsets
§ion_offsets
,
2061 struct objfile
*objfile
)
2065 if (es
->ifd
!= ifdNil
)
2068 cur_fdr
= debug_info
->fdr
+ cur_fd
;
2069 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
2073 cur_fdr
= debug_info
->fdr
;
2077 /* Reading .o files */
2078 if (SC_IS_UNDEF (es
->asym
.sc
) || es
->asym
.sc
== scNil
)
2081 switch (es
->asym
.st
)
2084 /* These are generated for static symbols in .o files,
2105 /* FIXME: Turn this into a complaint? */
2107 gdb_printf (_("Warning: %s `%s' is undefined (in %s)\n"),
2108 what
, debug_info
->ssext
+ es
->asym
.iss
,
2109 fdr_name (cur_fdr
));
2113 switch (es
->asym
.st
)
2117 /* There is no need to parse the external procedure symbols.
2118 If they are from objects compiled without -g, their index will
2119 be indexNil, and the symbol definition from the minimal symbol
2120 is preferrable (yielding a function returning int instead of int).
2121 If the index points to a local procedure symbol, the local
2122 symbol already provides the correct type.
2123 Note that the index of the external procedure symbol points
2124 to the local procedure symbol in the local symbol table, and
2125 _not_ to the auxiliary symbol info. */
2129 /* Global common symbols are resolved by the runtime loader,
2131 if (SC_IS_COMMON (es
->asym
.sc
))
2134 /* Note that the case of a symbol with indexNil must be handled
2135 anyways by parse_symbol(). */
2136 parse_symbol (&es
->asym
, ax
, NULL
,
2137 bigend
, section_offsets
, objfile
);
2144 /* Parse the line number info for file descriptor FH into
2145 GDB's linetable LT. MIPS' encoding requires a little bit
2146 of magic to get things out. Note also that MIPS' line
2147 numbers can go back and forth, apparently we can live
2148 with that and do not need to reorder our linetables. */
2151 parse_lines (FDR
*fh
, PDR
*pr
, struct linetable
*lt
, int maxlines
,
2152 CORE_ADDR textlow
, CORE_ADDR lowest_pdr_addr
)
2154 unsigned char *base
;
2156 int delta
, count
, lineno
= 0;
2158 if (fh
->cbLine
== 0)
2161 /* Scan by procedure descriptors. */
2163 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2167 unsigned char *halt
;
2169 /* No code for this one. */
2170 if (pr
->iline
== ilineNil
||
2171 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2174 /* Determine start and end address of compressed line bytes for
2176 base
= debug_info
->line
+ fh
->cbLineOffset
;
2177 if (j
!= (fh
->cpd
- 1))
2178 halt
= base
+ pr
[1].cbLineOffset
;
2180 halt
= base
+ fh
->cbLine
;
2181 base
+= pr
->cbLineOffset
;
2183 adr
= textlow
+ pr
->adr
- lowest_pdr_addr
;
2185 l
= adr
>> 2; /* in words */
2186 for (lineno
= pr
->lnLow
; base
< halt
;)
2188 count
= *base
& 0x0f;
2189 delta
= *base
++ >> 4;
2194 delta
= (base
[0] << 8) | base
[1];
2195 if (delta
>= 0x8000)
2199 lineno
+= delta
; /* first delta is 0 */
2201 /* Complain if the line table overflows. Could happen
2202 with corrupt binaries. */
2203 if (lt
->nitems
>= maxlines
)
2205 complaint (_("guessed size of linetable for %s incorrectly"),
2209 k
= add_line (lt
, lineno
, l
, k
);
2216 function_outside_compilation_unit_complaint (const char *arg1
)
2218 complaint (_("function `%s' appears to be defined "
2219 "outside of all compilation units"),
2223 /* Use the STORAGE_CLASS to compute which section the given symbol
2224 belongs to, and then records this new minimal symbol. */
2227 record_minimal_symbol (minimal_symbol_reader
&reader
,
2228 const char *name
, const CORE_ADDR address
,
2229 enum minimal_symbol_type ms_type
, int storage_class
,
2230 struct objfile
*objfile
)
2234 switch (storage_class
)
2237 section
= SECT_OFF_TEXT (objfile
);
2240 section
= SECT_OFF_DATA (objfile
);
2243 section
= SECT_OFF_BSS (objfile
);
2246 section
= get_section_index (objfile
, ".sdata");
2249 section
= get_section_index (objfile
, ".sbss");
2252 section
= get_section_index (objfile
, ".rdata");
2255 section
= get_section_index (objfile
, ".init");
2258 section
= get_section_index (objfile
, ".xdata");
2261 section
= get_section_index (objfile
, ".pdata");
2264 section
= get_section_index (objfile
, ".fini");
2267 section
= get_section_index (objfile
, ".rconst");
2271 section
= get_section_index (objfile
, ".tlsdata");
2276 section
= get_section_index (objfile
, ".tlsbss");
2280 /* This kind of symbol is not associated to a section. */
2284 reader
.record_with_info (name
, address
, ms_type
, section
);
2287 /* Master parsing procedure for first-pass reading of file symbols
2288 into a partial_symtab. */
2291 parse_partial_symbols (minimal_symbol_reader
&reader
,
2292 psymtab_storage
*partial_symtabs
,
2293 struct objfile
*objfile
)
2295 struct gdbarch
*gdbarch
= objfile
->arch ();
2296 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2297 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2298 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2299 void (*const swap_ext_in
) (bfd
*, void *, EXTR
*) = debug_swap
->swap_ext_in
;
2300 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
2301 void (*const swap_rfd_in
) (bfd
*, void *, RFDT
*) = debug_swap
->swap_rfd_in
;
2303 HDRR
*hdr
= &debug_info
->symbolic_header
;
2304 /* Running pointers */
2311 legacy_psymtab
*pst
;
2312 int textlow_not_set
= 1;
2314 /* List of current psymtab's include files. */
2315 const char **psymtab_include_list
;
2316 int includes_allocated
;
2319 struct pst_map
*fdr_to_pst
;
2320 /* Index within current psymtab dependency list. */
2321 legacy_psymtab
**dependency_list
;
2322 int dependencies_used
, dependencies_allocated
;
2324 enum language prev_language
;
2325 asection
*text_sect
;
2326 int relocatable
= 0;
2328 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2329 the shared libraries are prelinked at a high memory address.
2330 We have to adjust the start address of the object file for this case,
2331 by setting it to the start address of the first procedure in the file.
2332 But we should do no adjustments if we are debugging a .o file, where
2333 the text section (and fh->adr) really starts at zero. */
2334 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2335 if (text_sect
!= NULL
2336 && (bfd_section_flags (text_sect
) & SEC_RELOC
))
2339 extern_tab
= XOBNEWVEC (&objfile
->objfile_obstack
, EXTR
, hdr
->iextMax
);
2341 includes_allocated
= 30;
2343 psymtab_include_list
= (const char **) alloca (includes_allocated
*
2344 sizeof (const char *));
2345 next_symbol_text_func
= mdebug_next_symbol_text
;
2347 dependencies_allocated
= 30;
2348 dependencies_used
= 0;
2350 (legacy_psymtab
**) alloca (dependencies_allocated
*
2351 sizeof (legacy_psymtab
*));
2353 set_last_source_file (NULL
);
2358 * Only parse the Local and External symbols, and the Relative FDR.
2359 * Fixup enough of the loader symtab to be able to use it.
2360 * Allocate space only for the file's portions we need to
2365 max_glevel
= MIN_GLEVEL
;
2367 /* Allocate the map FDR -> PST.
2368 Minor hack: -O3 images might claim some global data belongs
2369 to FDR -1. We`ll go along with that. */
2370 std::vector
<struct pst_map
> fdr_to_pst_holder (hdr
->ifdMax
+ 1);
2371 fdr_to_pst
= fdr_to_pst_holder
.data ();
2374 legacy_psymtab
*new_pst
= new_psymtab ("", partial_symtabs
, objfile
);
2376 fdr_to_pst
[-1].pst
= new_pst
;
2377 FDR_IDX (new_pst
) = -1;
2380 /* Allocate the global pending list. */
2381 pending_list
= XOBNEWVEC (&objfile
->objfile_obstack
, mdebug_pending
*,
2383 memset (pending_list
, 0,
2384 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2386 /* Pass 0 over external syms: swap them in. */
2387 gdb::def_vector
<EXTR
> ext_block (hdr
->iextMax
);
2389 ext_out
= (char *) debug_info
->external_ext
;
2390 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2391 ext_in
= ext_block
.data ();
2392 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2393 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2395 /* Pass 1 over external syms: Presize and partition the list. */
2396 ext_in
= ext_block
.data ();
2397 ext_in_end
= ext_in
+ hdr
->iextMax
;
2398 for (; ext_in
< ext_in_end
; ext_in
++)
2400 /* See calls to complain below. */
2401 if (ext_in
->ifd
>= -1
2402 && ext_in
->ifd
< hdr
->ifdMax
2403 && ext_in
->asym
.iss
>= 0
2404 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2405 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2408 /* Pass 1.5 over files: partition out global symbol space. */
2410 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2412 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2413 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2414 fdr_to_pst
[f_idx
].n_globals
= 0;
2419 For ECOFF in ELF, we skip the creation of the minimal symbols.
2420 The ECOFF symbols should be a subset of the Elf symbols, and the
2421 section information of the elf symbols will be more accurate.
2422 FIXME! What about Irix 5's native linker?
2424 By default, Elf sections which don't exist in ECOFF
2425 get put in ECOFF's absolute section by the gnu linker.
2426 Since absolute sections don't get relocated, we
2427 end up calculating an address different from that of
2428 the symbol's minimal symbol (created earlier from the
2431 To fix this, either :
2432 1) don't create the duplicate symbol
2433 (assumes ECOFF symtab is a subset of the ELF symtab;
2434 assumes no side-effects result from ignoring ECOFF symbol)
2435 2) create it, only if lookup for existing symbol in ELF's minimal
2438 assumes no side-effects result from ignoring ECOFF symbol)
2439 3) create it, but lookup ELF's minimal symbol and use it's section
2440 during relocation, then modify "uniquify" phase to merge and
2441 eliminate the duplicate symbol
2442 (highly inefficient)
2444 I've implemented #1 here...
2445 Skip the creation of the minimal symbols based on the ECOFF
2448 /* Pass 2 over external syms: fill in external symbols. */
2449 ext_in
= ext_block
.data ();
2450 ext_in_end
= ext_in
+ hdr
->iextMax
;
2451 for (; ext_in
< ext_in_end
; ext_in
++)
2453 enum minimal_symbol_type ms_type
= mst_text
;
2454 CORE_ADDR svalue
= ext_in
->asym
.value
;
2456 /* The Irix 5 native tools seem to sometimes generate bogus
2457 external symbols. */
2458 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2460 complaint (_("bad ifd for external symbol: %d (max %ld)"),
2461 ext_in
->ifd
, hdr
->ifdMax
);
2464 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2466 complaint (_("bad iss for external symbol: %ld (max %ld)"),
2467 ext_in
->asym
.iss
, hdr
->issExtMax
);
2471 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2472 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2475 if (SC_IS_UNDEF (ext_in
->asym
.sc
) || ext_in
->asym
.sc
== scNil
)
2479 /* Pass 3 over files, over local syms: fill in static symbols. */
2480 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2482 /* Process ECOFF Symbol Types and Storage Classes. */
2483 switch (ext_in
->asym
.st
)
2486 /* Beginnning of Procedure */
2489 /* Load time only static procs */
2490 ms_type
= mst_file_text
;
2493 /* External symbol */
2494 if (SC_IS_COMMON (ext_in
->asym
.sc
))
2496 /* The value of a common symbol is its size, not its address.
2500 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2504 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2508 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2518 /* On certain platforms, some extra label symbols can be
2519 generated by the linker. One possible usage for this kind
2520 of symbols is to represent the address of the begining of a
2521 given section. For instance, on Tru64 5.1, the address of
2522 the _ftext label is the start address of the .text section.
2524 The storage class of these symbols is usually directly
2525 related to the section to which the symbol refers. For
2526 instance, on Tru64 5.1, the storage class for the _fdata
2527 label is scData, refering to the .data section.
2529 It is actually possible that the section associated to the
2530 storage class of the label does not exist. On True64 5.1
2531 for instance, the libm.so shared library does not contain
2532 any .data section, although it contains a _fpdata label
2533 which storage class is scData... Since these symbols are
2534 usually useless for the debugger user anyway, we just
2535 discard these symbols. */
2537 if (SC_IS_TEXT (ext_in
->asym
.sc
))
2539 if (objfile
->sect_index_text
== -1)
2542 ms_type
= mst_file_text
;
2544 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2546 if (objfile
->sect_index_data
== -1)
2549 ms_type
= mst_file_data
;
2551 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2553 if (objfile
->sect_index_bss
== -1)
2556 ms_type
= mst_file_bss
;
2558 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2560 const int sbss_sect_index
= get_section_index (objfile
, ".sbss");
2562 if (sbss_sect_index
== -1)
2565 ms_type
= mst_file_bss
;
2572 /* The alpha has the section start addresses in stLocal symbols
2573 whose name starts with a `.'. Skip those but complain for all
2574 other stLocal symbols.
2575 Irix6 puts the section start addresses in stNil symbols, skip
2581 ms_type
= mst_unknown
;
2582 unknown_ext_complaint (name
);
2584 if (!ECOFF_IN_ELF (cur_bfd
))
2585 record_minimal_symbol (reader
, name
, svalue
, ms_type
, ext_in
->asym
.sc
,
2589 /* Pass 3 over files, over local syms: fill in static symbols. */
2590 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2592 legacy_psymtab
*save_pst
;
2596 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2600 fdr_to_pst
[f_idx
].pst
= NULL
;
2604 /* Determine the start address for this object file from the
2605 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2610 pst
= new legacy_psymtab (fdr_name (fh
), partial_symtabs
,
2611 objfile
->per_bfd
, textlow
);
2612 pst
->read_symtab_private
= XOBNEW (&objfile
->objfile_obstack
, symloc
);
2613 memset (pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2616 FDR_IDX (pst
) = f_idx
;
2617 CUR_BFD (pst
) = cur_bfd
;
2618 DEBUG_SWAP (pst
) = debug_swap
;
2619 DEBUG_INFO (pst
) = debug_info
;
2620 PENDING_LIST (pst
) = pending_list
;
2622 /* The way to turn this into a symtab is to call... */
2623 pst
->legacy_read_symtab
= mdebug_read_symtab
;
2624 pst
->legacy_expand_psymtab
= mdebug_expand_psymtab
;
2626 /* Set up language for the pst.
2627 The language from the FDR is used if it is unambigious (e.g. cfront
2628 with native cc and g++ will set the language to C).
2629 Otherwise we have to deduce the language from the filename.
2630 Native ecoff has every header file in a separate FDR, so
2631 deduce_language_from_filename will return language_unknown for
2632 a header file, which is not what we want.
2633 But the FDRs for the header files are after the FDR for the source
2634 file, so we can assign the language of the source file to the
2635 following header files. Then we save the language in the private
2636 pst data so that we can reuse it when building symtabs. */
2637 prev_language
= psymtab_language
;
2641 case langCplusplusV2
:
2642 psymtab_language
= language_cplus
;
2645 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2648 if (psymtab_language
== language_unknown
)
2649 psymtab_language
= prev_language
;
2650 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2652 pst
->set_text_high (pst
->raw_text_low ());
2654 /* For stabs-in-ecoff files, the second symbol must be @stab.
2655 This symbol is emitted by mips-tfile to signal that the
2656 current object file uses encapsulated stabs instead of mips
2657 ecoff for local symbols. (It is the second symbol because
2658 the first symbol is the stFile used to signal the start of a
2660 processing_gcc_compilation
= 0;
2663 (*swap_sym_in
) (cur_bfd
,
2664 ((char *) debug_info
->external_sym
2665 + (fh
->isymBase
+ 1) * external_sym_size
),
2667 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2669 processing_gcc_compilation
= 2;
2672 if (processing_gcc_compilation
!= 0)
2674 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2677 const char *namestring
;
2679 (*swap_sym_in
) (cur_bfd
,
2680 (((char *) debug_info
->external_sym
)
2681 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2683 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2684 if (!ECOFF_IS_STAB (&sh
))
2686 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2691 if (sh
.st
== stStaticProc
)
2693 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2694 record_minimal_symbol (reader
, namestring
, sh
.value
,
2695 mst_file_text
, sh
.sc
,
2698 procaddr
= sh
.value
;
2700 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2701 (debug_info
->external_aux
2704 (*swap_sym_in
) (cur_bfd
,
2705 ((char *) debug_info
->external_sym
2706 + ((fh
->isymBase
+ isym
- 1)
2707 * external_sym_size
)),
2711 CORE_ADDR high
= procaddr
+ sh
.value
;
2713 /* Kludge for Irix 5.2 zero fh->adr. */
2715 && (!pst
->text_low_valid
2716 || procaddr
< pst
->raw_text_low ()))
2717 pst
->set_text_low (procaddr
);
2718 if (high
> pst
->raw_text_high ())
2719 pst
->set_text_high (high
);
2722 else if (sh
.st
== stStatic
)
2737 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2738 record_minimal_symbol (reader
, namestring
, sh
.value
,
2739 mst_file_data
, sh
.sc
,
2744 /* FIXME! Shouldn't this use cases for bss,
2745 then have the default be abs? */
2746 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2747 record_minimal_symbol (reader
, namestring
, sh
.value
,
2748 mst_file_bss
, sh
.sc
,
2755 /* Handle stabs continuation. */
2757 char *stabstring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2758 /* If we need to heap-allocate STABSTRING, this owns
2760 gdb::unique_xmalloc_ptr
<char> stabstring_storage
;
2761 int len
= strlen (stabstring
);
2763 while (stabstring
[len
- 1] == '\\')
2766 char *stabstring1
= stabstring
;
2770 /* Ignore continuation char from 1st string. */
2773 /* Read next stabstring. */
2775 (*swap_sym_in
) (cur_bfd
,
2776 (((char *) debug_info
->external_sym
)
2777 + (fh
->isymBase
+ cur_sdx
)
2778 * external_sym_size
),
2780 stabstring2
= debug_info
->ss
+ fh
->issBase
+ sh2
.iss
;
2781 len2
= strlen (stabstring2
);
2783 /* Concatenate stabstring2 with stabstring1. */
2784 if (stabstring_storage
!= nullptr)
2786 stabstring_storage
.reset
2787 ((char *) xrealloc (stabstring_storage
.release (),
2789 stabstring
= stabstring_storage
.get ();
2793 stabstring_storage
.reset
2794 ((char *) xmalloc (len
+ len2
+ 1));
2795 stabstring
= stabstring_storage
.get ();
2796 strcpy (stabstring
, stabstring1
);
2798 strcpy (stabstring
+ len
, stabstring2
);
2806 /* Standard, external, non-debugger, symbols. */
2808 case N_TEXT
| N_EXT
:
2809 case N_NBTEXT
| N_EXT
:
2812 case N_DATA
| N_EXT
:
2813 case N_NBDATA
| N_EXT
:
2818 case N_NBBSS
| N_EXT
:
2819 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
2826 /* Standard, local, non-debugger, symbols. */
2830 /* We need to be able to deal with both N_FN or
2831 N_TEXT, because we have no way of knowing
2832 whether the sys-supplied ld or GNU ld was used
2833 to make the executable. Sequents throw in
2834 another wrinkle -- they renumbered N_FN. */
2844 case N_UNDF
| N_EXT
:
2845 continue; /* Just undefined, not COMMON. */
2850 /* Lots of symbol types we can just ignore. */
2857 /* Keep going . . . */
2860 * Special symbol types for GNU
2863 case N_INDR
| N_EXT
:
2865 case N_SETA
| N_EXT
:
2867 case N_SETT
| N_EXT
:
2869 case N_SETD
| N_EXT
:
2871 case N_SETB
| N_EXT
:
2881 static int prev_so_symnum
= -10;
2882 const char *basename
;
2884 /* A zero value is probably an indication for the
2885 SunPRO 3.0 compiler. dbx_end_psymtab explicitly tests
2886 for zero, so don't relocate it. */
2889 && gdbarch_sofun_address_maybe_missing (gdbarch
))
2890 textlow_not_set
= 1;
2892 textlow_not_set
= 0;
2894 if (prev_so_symnum
!= symnum
- 1)
2895 { /* Here if prev stab wasn't N_SO. */
2898 pst
= (legacy_psymtab
*) 0;
2900 dependencies_used
= 0;
2904 prev_so_symnum
= symnum
;
2906 /* End the current partial symtab and start a
2909 /* SET_NAMESTRING ();*/
2910 namestring
= stabstring
;
2912 /* Null name means end of .o file. Don't start a new
2914 if (*namestring
== '\000')
2917 /* Some compilers (including gcc) emit a pair of
2918 initial N_SOs. The first one is a directory name;
2919 the second the file name. If pst exists, is
2920 empty, and has a filename ending in '/', we assume
2921 the previous N_SO was a directory name. */
2922 basename
= lbasename (namestring
);
2923 if (basename
!= namestring
&& *basename
== '\000')
2924 continue; /* Simply ignore directory
2927 /* Some other compilers (C++ ones in particular) emit
2928 useless SOs for non-existant .c files. We ignore
2929 all subsequent SOs that immediately follow the
2942 enum language tmp_language
;
2944 /* Mark down an include file in the current psymtab. */
2946 /* SET_NAMESTRING (); */
2947 namestring
= stabstring
;
2950 = deduce_language_from_filename (namestring
);
2952 /* Only change the psymtab's language if we've
2953 learned something useful (eg. tmp_language is not
2954 language_unknown). In addition, to match what
2955 start_subfile does, never change from C++ to
2957 if (tmp_language
!= language_unknown
2958 && (tmp_language
!= language_c
2959 || psymtab_language
!= language_cplus
))
2960 psymtab_language
= tmp_language
;
2962 /* In C++, one may expect the same filename to come
2963 round many times, when code is coming alternately
2964 from the main file and from inline functions in
2965 other files. So I check to see if this is a file
2966 we've seen before -- either the main source file,
2967 or a previously included file.
2969 This seems to be a lot of time to be spending on
2970 N_SOL, but things like "break c-exp.y:435" need to
2971 work (I suppose the psymtab_include_list could be
2972 hashed or put in a binary tree, if profiling shows
2973 this is a major hog). */
2974 if (pst
&& filename_cmp (namestring
, pst
->filename
) == 0)
2980 for (i
= 0; i
< includes_used
; i
++)
2981 if (filename_cmp (namestring
,
2982 psymtab_include_list
[i
]) == 0)
2991 psymtab_include_list
[includes_used
++] = namestring
;
2992 if (includes_used
>= includes_allocated
)
2994 const char **orig
= psymtab_include_list
;
2996 psymtab_include_list
= (const char **)
2997 alloca ((includes_allocated
*= 2) *
2998 sizeof (const char *));
2999 memcpy (psymtab_include_list
, orig
,
3000 includes_used
* sizeof (const char *));
3004 case N_LSYM
: /* Typedef or automatic variable. */
3005 case N_STSYM
: /* Data seg var -- static */
3006 case N_LCSYM
: /* BSS " */
3007 case N_ROSYM
: /* Read-only data seg var -- static. */
3008 case N_NBSTS
: /* Gould nobase. */
3009 case N_NBLCS
: /* symbols. */
3011 case N_GSYM
: /* Global (extern) variable; can be
3012 data or bss (sigh FIXME). */
3014 /* Following may probably be ignored; I'll leave them here
3015 for now (until I do Pascal and Modula 2 extensions). */
3017 case N_PC
: /* I may or may not need this; I
3019 case N_M2C
: /* I suspect that I can ignore this
3021 case N_SCOPE
: /* Same. */
3023 /* SET_NAMESTRING (); */
3024 namestring
= stabstring
;
3025 p
= (char *) strchr (namestring
, ':');
3027 continue; /* Not a debugging symbol. */
3031 /* Main processing section for debugging symbols which
3032 the initial read through the symbol tables needs to
3033 worry about. If we reach this point, the symbol
3034 which we are considering is definitely one we are
3035 interested in. p must also contain the (valid)
3036 index into the namestring which indicates the
3037 debugging type symbol. */
3042 pst
->add_psymbol (gdb::string_view (namestring
,
3044 true, VAR_DOMAIN
, LOC_STATIC
,
3045 SECT_OFF_DATA (objfile
),
3046 psymbol_placement::STATIC
,
3049 partial_symtabs
, objfile
);
3052 /* The addresses in these entries are reported
3053 to be wrong. See the code that reads 'G's
3055 pst
->add_psymbol (gdb::string_view (namestring
,
3057 true, VAR_DOMAIN
, LOC_STATIC
,
3058 SECT_OFF_DATA (objfile
),
3059 psymbol_placement::GLOBAL
,
3062 partial_symtabs
, objfile
);
3066 /* When a 'T' entry is defining an anonymous enum, it
3067 may have a name which is the empty string, or a
3068 single space. Since they're not really defining a
3069 symbol, those shouldn't go in the partial symbol
3070 table. We do pick up the elements of such enums at
3071 'check_enum:', below. */
3072 if (p
>= namestring
+ 2
3073 || (p
== namestring
+ 1
3074 && namestring
[0] != ' '))
3077 (gdb::string_view (namestring
, p
- namestring
),
3078 true, STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
3079 psymbol_placement::STATIC
, 0, psymtab_language
,
3080 partial_symtabs
, objfile
);
3083 /* Also a typedef with the same name. */
3085 (gdb::string_view (namestring
,
3087 true, VAR_DOMAIN
, LOC_TYPEDEF
, -1,
3088 psymbol_placement::STATIC
, 0,
3090 partial_symtabs
, objfile
);
3096 if (p
!= namestring
) /* a name is there, not
3100 (gdb::string_view (namestring
,
3102 true, VAR_DOMAIN
, LOC_TYPEDEF
, -1,
3103 psymbol_placement::STATIC
, 0, psymtab_language
,
3104 partial_symtabs
, objfile
);
3107 /* If this is an enumerated type, we need to add
3108 all the enum constants to the partial symbol
3109 table. This does not cover enums without names,
3110 e.g. "enum {a, b} c;" in C, but fortunately
3111 those are rare. There is no way for GDB to find
3112 those from the enum type without spending too
3113 much time on it. Thus to solve this problem,
3114 the compiler needs to put out the enum in a
3115 nameless type. GCC2 does this. */
3117 /* We are looking for something of the form
3118 <name> ":" ("t" | "T") [<number> "="] "e"
3119 {<constant> ":" <value> ","} ";". */
3121 /* Skip over the colon and the 't' or 'T'. */
3123 /* This type may be given a number. Also, numbers
3124 can come in pairs like (0,26). Skip over it. */
3125 while ((*p
>= '0' && *p
<= '9')
3126 || *p
== '(' || *p
== ',' || *p
== ')'
3132 /* The aix4 compiler emits extra crud before
3136 /* Skip over the type (?). */
3140 /* Skip over the colon. */
3144 /* We have found an enumerated type. */
3145 /* According to comments in read_enum_type
3146 a comma could end it instead of a semicolon.
3147 I don't know where that happens.
3149 while (*p
&& *p
!= ';' && *p
!= ',')
3153 /* Check for and handle cretinous dbx
3154 symbol name continuation! */
3155 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
3156 p
= next_symbol_text (objfile
);
3158 /* Point to the character after the name
3159 of the enum constant. */
3160 for (q
= p
; *q
&& *q
!= ':'; q
++)
3162 /* Note that the value doesn't matter for
3163 enum constants in psymtabs, just in
3165 pst
->add_psymbol (gdb::string_view (p
,
3169 psymbol_placement::STATIC
,
3170 0, psymtab_language
,
3171 partial_symtabs
, objfile
);
3172 /* Point past the name. */
3174 /* Skip over the value. */
3175 while (*p
&& *p
!= ',')
3177 /* Advance past the comma. */
3184 /* Constant, e.g. from "const" in Pascal. */
3185 pst
->add_psymbol (gdb::string_view (namestring
,
3187 true, VAR_DOMAIN
, LOC_CONST
, -1,
3188 psymbol_placement::STATIC
,
3189 0, psymtab_language
,
3190 partial_symtabs
, objfile
);
3196 std::string
copy (namestring
, p
);
3197 function_outside_compilation_unit_complaint
3200 pst
->add_psymbol (gdb::string_view (namestring
,
3202 true, VAR_DOMAIN
, LOC_BLOCK
,
3203 SECT_OFF_TEXT (objfile
),
3204 psymbol_placement::STATIC
,
3207 partial_symtabs
, objfile
);
3210 /* Global functions were ignored here, but now they
3211 are put into the global psymtab like one would
3212 expect. They're also in the minimal symbol
3217 std::string
copy (namestring
, p
);
3218 function_outside_compilation_unit_complaint
3221 pst
->add_psymbol (gdb::string_view (namestring
,
3223 true, VAR_DOMAIN
, LOC_BLOCK
,
3224 SECT_OFF_TEXT (objfile
),
3225 psymbol_placement::GLOBAL
,
3228 partial_symtabs
, objfile
);
3231 /* Two things show up here (hopefully); static
3232 symbols of local scope (static used inside
3233 braces) or extensions of structure symbols. We
3248 case '#': /* For symbol identification (used
3253 /* It is a C++ nested symbol. We don't need to
3254 record it (I don't think); if we try to look up
3255 foo::bar::baz, then symbols for the symtab
3256 containing foo should get read in, I think. */
3257 /* Someone says sun cc puts out symbols like
3258 /foo/baz/maclib::/usr/local/bin/maclib,
3259 which would get here with a symbol type of ':'. */
3263 /* Unexpected symbol descriptor. The second and
3264 subsequent stabs of a continued stab can show up
3265 here. The question is whether they ever can
3266 mimic a normal stab--it would be nice if not,
3267 since we certainly don't want to spend the time
3268 searching to the end of every string looking for
3271 complaint (_("unknown symbol descriptor `%c'"), p
[1]);
3273 /* Ignore it; perhaps it is an extension that we don't
3282 /* Solaris 2 end of module, finish current partial
3283 symbol table. dbx_end_psymtab will set the
3284 high text address of PST to the proper value,
3285 which is necessary if a module compiled without
3286 debugging info follows this module. */
3288 && gdbarch_sofun_address_maybe_missing (gdbarch
))
3290 pst
= (legacy_psymtab
*) 0;
3292 dependencies_used
= 0;
3297 if (sh
.value
> save_pst
->raw_text_high ())
3298 save_pst
->set_text_high (sh
.value
);
3303 case N_SSYM
: /* Claim: Structure or union
3304 element. Hopefully, I can
3306 case N_ENTRY
: /* Alternate entry point; can
3308 case N_MAIN
: /* Can definitely ignore this. */
3309 case N_CATCH
: /* These are GNU C++ extensions. */
3310 case N_EHDECL
: /* that can safely be ignored here. */
3320 case N_NSYMS
: /* Ultrix 4.0: symbol count */
3321 case N_DEFD
: /* GNU Modula-2 */
3322 case N_ALIAS
: /* SunPro F77: alias name, ignore
3325 case N_OBJ
: /* Useless types from Solaris. */
3327 /* These symbols aren't interesting; don't worry about
3333 /* If we haven't found it yet, ignore it. It's
3334 probably some new type we don't know about yet. */
3335 complaint (_("unknown symbol type %s"),
3336 hex_string (type_code
)); /* CUR_SYMBOL_TYPE */
3340 /* end - Handle continuation */
3345 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
3348 enum address_class theclass
;
3349 CORE_ADDR minsym_value
;
3352 (*swap_sym_in
) (cur_bfd
,
3353 ((char *) debug_info
->external_sym
3354 + ((fh
->isymBase
+ cur_sdx
)
3355 * external_sym_size
)),
3358 if (ECOFF_IS_STAB (&sh
))
3364 /* Non absolute static symbols go into the minimal table. */
3365 if (SC_IS_UNDEF (sh
.sc
) || sh
.sc
== scNil
3366 || (sh
.index
== indexNil
3367 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
3369 /* FIXME, premature? */
3374 sym_name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3376 minsym_value
= sh
.value
;
3382 /* The value of a stEnd symbol is the displacement from the
3383 corresponding start symbol value, do not relocate it. */
3385 section
= SECT_OFF_TEXT (objfile
);
3392 section
= SECT_OFF_DATA (objfile
);
3396 section
= SECT_OFF_BSS (objfile
);
3407 reader
.record_with_info (sym_name
, minsym_value
,
3409 SECT_OFF_TEXT (objfile
));
3414 /* Ignore all parameter symbol records. */
3415 if (sh
.index
>= hdr
->iauxMax
)
3417 /* Should not happen, but does when cross-compiling
3418 with the MIPS compiler. FIXME -- pull later. */
3419 index_complaint (sym_name
);
3420 new_sdx
= cur_sdx
+ 1; /* Don't skip at all. */
3423 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
3424 (debug_info
->external_aux
3428 if (new_sdx
<= cur_sdx
)
3430 /* This should not happen either... FIXME. */
3431 complaint (_("bad proc end in aux found from symbol %s"),
3433 new_sdx
= cur_sdx
+ 1; /* Don't skip backward. */
3436 /* For stProc symbol records, we need to check the
3437 storage class as well, as only (stProc, scText)
3438 entries represent "real" procedures - See the
3439 Compaq document titled "Object File / Symbol Table
3440 Format Specification" for more information. If the
3441 storage class is not scText, we discard the whole
3442 block of symbol records for this stProc. */
3443 if (sh
.st
== stProc
&& sh
.sc
!= scText
)
3446 /* Usually there is a local and a global stProc symbol
3447 for a function. This means that the function name
3448 has already been entered into the minimal symbol table
3449 while processing the global symbols in pass 2 above.
3450 One notable exception is the PROGRAM name from
3451 f77 compiled executables, it is only put out as
3452 local stProc symbol, and a global MAIN__ stProc symbol
3453 points to it. It doesn't matter though, as gdb is
3454 still able to find the PROGRAM name via the partial
3455 symbol table, and the MAIN__ symbol via the minimal
3457 if (sh
.st
== stProc
)
3458 pst
->add_psymbol (sym_name
, true,
3459 VAR_DOMAIN
, LOC_BLOCK
,
3461 psymbol_placement::GLOBAL
,
3462 sh
.value
, psymtab_language
,
3463 partial_symtabs
, objfile
);
3465 pst
->add_psymbol (sym_name
, true,
3466 VAR_DOMAIN
, LOC_BLOCK
,
3468 psymbol_placement::STATIC
,
3469 sh
.value
, psymtab_language
,
3470 partial_symtabs
, objfile
);
3472 procaddr
= sh
.value
;
3475 (*swap_sym_in
) (cur_bfd
,
3476 ((char *) debug_info
->external_sym
3477 + ((fh
->isymBase
+ cur_sdx
- 1)
3478 * external_sym_size
)),
3483 /* Kludge for Irix 5.2 zero fh->adr. */
3485 && (!pst
->text_low_valid
3486 || procaddr
< pst
->raw_text_low ()))
3487 pst
->set_text_low (procaddr
);
3489 high
= procaddr
+ sh
.value
;
3490 if (high
> pst
->raw_text_high ())
3491 pst
->set_text_high (high
);
3494 case stStatic
: /* Variable */
3495 if (SC_IS_DATA (sh
.sc
))
3496 reader
.record_with_info (sym_name
, minsym_value
,
3498 SECT_OFF_DATA (objfile
));
3500 reader
.record_with_info (sym_name
, minsym_value
,
3502 SECT_OFF_BSS (objfile
));
3503 theclass
= LOC_STATIC
;
3506 case stIndirect
: /* Irix5 forward declaration */
3507 /* Skip forward declarations from Irix5 cc. */
3510 case stTypedef
: /* Typedef */
3511 /* Skip typedefs for forward declarations and opaque
3512 structs from alpha and mips cc. */
3513 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
3515 theclass
= LOC_TYPEDEF
;
3518 case stConstant
: /* Constant decl */
3519 theclass
= LOC_CONST
;
3525 case stBlock
: /* { }, str, un, enum */
3526 /* Do not create a partial symbol for cc unnamed aggregates
3527 and gcc empty aggregates. */
3528 if ((sh
.sc
== scInfo
3529 || SC_IS_COMMON (sh
.sc
))
3531 && sh
.index
!= cur_sdx
+ 2)
3533 pst
->add_psymbol (sym_name
, true,
3534 STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
3535 psymbol_placement::STATIC
,
3536 0, psymtab_language
,
3537 partial_symtabs
, objfile
);
3539 handle_psymbol_enumerators (objfile
, partial_symtabs
,
3540 pst
, fh
, sh
.st
, sh
.value
);
3542 /* Skip over the block. */
3544 if (new_sdx
<= cur_sdx
)
3546 /* This happens with the Ultrix kernel. */
3547 complaint (_("bad aux index at block symbol %s"),
3549 new_sdx
= cur_sdx
+ 1; /* Don't skip backward. */
3554 case stFile
: /* File headers */
3555 case stLabel
: /* Labels */
3556 case stEnd
: /* Ends of files */
3559 case stLocal
: /* Local variables */
3560 /* Normally these are skipped because we skip over
3561 all blocks we see. However, these can occur
3562 as visible symbols in a .h file that contains code. */
3566 /* Both complaints are valid: one gives symbol sym_name,
3567 the other the offending symbol type. */
3568 complaint (_("unknown local symbol %s"),
3570 complaint (_("with type %d"), sh
.st
);
3574 /* Use this gdb symbol. */
3575 pst
->add_psymbol (sym_name
, true,
3576 VAR_DOMAIN
, theclass
, section
,
3577 psymbol_placement::STATIC
,
3578 sh
.value
, psymtab_language
,
3579 partial_symtabs
, objfile
);
3581 cur_sdx
++; /* Go to next file symbol. */
3584 /* Now do enter the external symbols. */
3585 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
3586 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
3587 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
3588 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
3589 for (; --cur_sdx
>= 0; ext_ptr
++)
3591 enum address_class theclass
;
3596 gdb_assert (ext_ptr
->ifd
== f_idx
);
3598 psh
= &ext_ptr
->asym
;
3600 /* Do not add undefined symbols to the partial symbol table. */
3601 if (SC_IS_UNDEF (psh
->sc
) || psh
->sc
== scNil
)
3604 svalue
= psh
->value
;
3610 section
= SECT_OFF_TEXT (objfile
);
3617 section
= SECT_OFF_DATA (objfile
);
3621 section
= SECT_OFF_BSS (objfile
);
3628 /* These are generated for static symbols in .o files,
3633 /* External procedure symbols have been entered
3634 into the minimal symbol table in pass 2 above.
3635 Ignore them, as parse_external will ignore them too. */
3638 theclass
= LOC_LABEL
;
3641 unknown_ext_complaint (debug_info
->ssext
+ psh
->iss
);
3642 /* Pretend it's global. */
3645 /* Global common symbols are resolved by the runtime loader,
3647 if (SC_IS_COMMON (psh
->sc
))
3650 theclass
= LOC_STATIC
;
3653 char *sym_name
= debug_info
->ssext
+ psh
->iss
;
3654 pst
->add_psymbol (sym_name
, true,
3655 VAR_DOMAIN
, theclass
,
3657 psymbol_placement::GLOBAL
,
3658 svalue
, psymtab_language
,
3659 partial_symtabs
, objfile
);
3663 /* Link pst to FDR. dbx_end_psymtab returns NULL if the psymtab was
3664 empty and put on the free list. */
3665 fdr_to_pst
[f_idx
].pst
3666 = dbx_end_psymtab (objfile
, partial_symtabs
, save_pst
,
3667 psymtab_include_list
, includes_used
,
3668 -1, save_pst
->raw_text_high (),
3669 dependency_list
, dependencies_used
,
3672 dependencies_used
= 0;
3674 /* The objfile has its functions reordered if this partial symbol
3675 table overlaps any other partial symbol table.
3676 We cannot assume a reordered objfile if a partial symbol table
3677 is contained within another partial symbol table, as partial symbol
3678 tables for include files with executable code are contained
3679 within the partial symbol table for the including source file,
3680 and we do not want to flag the objfile reordered for these cases.
3682 This strategy works well for Irix-5.2 shared libraries, but we
3683 might have to use a more elaborate (and slower) algorithm for
3685 save_pst
= fdr_to_pst
[f_idx
].pst
;
3686 if (save_pst
!= NULL
3687 && save_pst
->text_low_valid
3688 && !(objfile
->flags
& OBJF_REORDERED
))
3690 for (partial_symtab
*iter
: partial_symtabs
->range ())
3692 if (save_pst
!= iter
3693 && save_pst
->raw_text_low () >= iter
->raw_text_low ()
3694 && save_pst
->raw_text_low () < iter
->raw_text_high ()
3695 && save_pst
->raw_text_high () > iter
->raw_text_high ())
3697 objfile
->flags
|= OBJF_REORDERED
;
3704 /* Now scan the FDRs for dependencies. */
3705 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3707 fh
= f_idx
+ debug_info
->fdr
;
3708 pst
= fdr_to_pst
[f_idx
].pst
;
3713 /* This should catch stabs-in-ecoff. */
3717 /* Skip the first file indirect entry as it is a self dependency for
3718 source files or a reverse .h -> .c dependency for header files. */
3719 pst
->number_of_dependencies
= 0;
3721 = partial_symtabs
->allocate_dependencies (fh
->crfd
- 1);
3722 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3726 (*swap_rfd_in
) (cur_bfd
,
3727 ((char *) debug_info
->external_rfd
3728 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3730 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3732 complaint (_("bad file number %ld"), rh
);
3736 /* Skip self dependencies of header files. */
3740 /* Do not add to dependency list if psymtab was empty. */
3741 if (fdr_to_pst
[rh
].pst
== NULL
)
3743 pst
->dependencies
[pst
->number_of_dependencies
++]
3744 = fdr_to_pst
[rh
].pst
;
3748 /* Remove the dummy psymtab created for -O3 images above, if it is
3749 still empty, to enable the detection of stripped executables. */
3750 partial_symtab
*pst_del
= partial_symtabs
->psymtabs
;
3751 if (pst_del
->next
== NULL
3752 && pst_del
->number_of_dependencies
== 0
3753 && pst_del
->empty ())
3754 partial_symtabs
->discard_psymtab (pst_del
);
3757 /* If the current psymbol has an enumerated type, we need to add
3758 all the enum constants to the partial symbol table. */
3761 handle_psymbol_enumerators (struct objfile
*objfile
,
3762 psymtab_storage
*partial_symtabs
,
3763 partial_symtab
*pst
,
3764 FDR
*fh
, int stype
, CORE_ADDR svalue
)
3766 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3767 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
3768 char *ext_sym
= ((char *) debug_info
->external_sym
3769 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3779 /* It is an enumerated type if the next symbol entry is a stMember
3780 and its auxiliary index is indexNil or its auxiliary entry
3781 is a plain btNil or btVoid.
3782 Alpha cc -migrate enums are recognized by a zero index and
3783 a zero symbol value.
3784 DU 4.0 cc enums are recognized by a member type of btEnum without
3785 qualifiers and a zero symbol value. */
3786 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3787 if (sh
.st
!= stMember
)
3790 if (sh
.index
== indexNil
3791 || (sh
.index
== 0 && svalue
== 0))
3793 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3794 &(debug_info
->external_aux
3795 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3797 if ((tir
.bt
!= btNil
3799 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3800 || tir
.tq0
!= tqNil
)
3812 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3813 if (sh
.st
!= stMember
)
3815 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3817 /* Note that the value doesn't matter for enum constants
3818 in psymtabs, just in symtabs. */
3819 pst
->add_psymbol (name
, true,
3820 VAR_DOMAIN
, LOC_CONST
, -1,
3821 psymbol_placement::STATIC
, 0,
3822 psymtab_language
, partial_symtabs
, objfile
);
3823 ext_sym
+= external_sym_size
;
3827 /* Get the next symbol. OBJFILE is unused. */
3830 mdebug_next_symbol_text (struct objfile
*objfile
)
3835 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3836 ((char *) debug_info
->external_sym
3837 + ((cur_fdr
->isymBase
+ cur_sdx
)
3838 * debug_swap
->external_sym_size
)),
3840 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3843 /* Ancillary function to psymtab_to_symtab(). Does all the work
3844 for turning the partial symtab PST into a symtab, recurring
3845 first on all dependent psymtabs. The argument FILENAME is
3846 only passed so we can see in debug stack traces what file
3849 This function has a split personality, based on whether the
3850 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3851 The flow of control and even the memory allocation differs. FIXME. */
3854 mdebug_expand_psymtab (legacy_psymtab
*pst
, struct objfile
*objfile
)
3856 bfd_size_type external_sym_size
;
3857 bfd_size_type external_pdr_size
;
3858 void (*swap_sym_in
) (bfd
*, void *, SYMR
*);
3859 void (*swap_pdr_in
) (bfd
*, void *, PDR
*);
3861 struct compunit_symtab
*cust
= NULL
;
3863 struct linetable
*lines
;
3864 CORE_ADDR lowest_pdr_addr
= 0;
3865 int last_symtab_ended
= 0;
3866 const section_offsets
§ion_offsets
= objfile
->section_offsets
;
3872 /* Read in all partial symtabs on which this one is dependent.
3873 NOTE that we do have circular dependencies, sigh. We solved
3874 that by setting pst->readin before this point. */
3875 pst
->expand_dependencies (objfile
);
3877 /* Do nothing if this is a dummy psymtab. */
3879 if (pst
->empty () && !pst
->text_low_valid
&& !pst
->text_high_valid
)
3882 /* Now read the symbols for this symtab. */
3884 cur_bfd
= CUR_BFD (pst
);
3885 debug_swap
= DEBUG_SWAP (pst
);
3886 debug_info
= DEBUG_INFO (pst
);
3887 pending_list
= PENDING_LIST (pst
);
3888 external_sym_size
= debug_swap
->external_sym_size
;
3889 external_pdr_size
= debug_swap
->external_pdr_size
;
3890 swap_sym_in
= debug_swap
->swap_sym_in
;
3891 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3892 mdebugread_objfile
= objfile
;
3893 cur_fd
= FDR_IDX (pst
);
3894 fh
= ((cur_fd
== -1)
3896 : debug_info
->fdr
+ cur_fd
);
3899 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3900 processing_gcc_compilation
= 0;
3901 if (fh
!= NULL
&& fh
->csym
>= 2)
3905 (*swap_sym_in
) (cur_bfd
,
3906 ((char *) debug_info
->external_sym
3907 + (fh
->isymBase
+ 1) * external_sym_size
),
3909 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3912 /* We indicate that this is a GCC compilation so that certain
3913 features will be enabled in stabsread/dbxread. */
3914 processing_gcc_compilation
= 2;
3918 if (processing_gcc_compilation
!= 0)
3920 struct gdbarch
*gdbarch
= objfile
->arch ();
3922 /* This symbol table contains stabs-in-ecoff entries. */
3924 /* Parse local symbols first. */
3926 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr. */
3928 mdebugread_objfile
= NULL
;
3931 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3937 (*swap_sym_in
) (cur_bfd
,
3938 (((char *) debug_info
->external_sym
)
3939 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3941 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3943 /* XXX This is a hack. It will go away! */
3944 if (ECOFF_IS_STAB (&sh
) || (name
[0] == '#'))
3946 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3947 enum language language
= PST_PRIVATE (pst
)->pst_language
;
3949 /* We should never get non N_STAB symbols here, but they
3950 should be harmless, so keep process_one_symbol from
3951 complaining about them. */
3952 if (type_code
& N_STAB
)
3954 /* If we found a trailing N_SO with no name, process
3955 it here instead of in process_one_symbol, so we
3956 can keep a handle to its symtab. The symtab
3957 would otherwise be ended twice, once in
3958 process_one_symbol, and once after this loop. */
3959 if (type_code
== N_SO
3960 && get_last_source_file ()
3961 && previous_stab_code
!= (unsigned char) N_SO
3964 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
3965 previous_stab_code
= N_SO
;
3966 cust
= end_compunit_symtab (valu
, SECT_OFF_TEXT (objfile
));
3968 last_symtab_ended
= 1;
3972 last_symtab_ended
= 0;
3973 process_one_symbol (type_code
, 0, valu
, name
,
3974 section_offsets
, objfile
, language
);
3977 /* Similarly a hack. */
3978 else if (name
[0] == '#')
3980 process_one_symbol (N_SLINE
, 0, valu
, name
,
3981 section_offsets
, objfile
, language
);
3983 if (type_code
== N_FUN
)
3985 /* Make up special symbol to contain
3986 procedure specific info. */
3987 mdebug_extra_func_info
*e
3988 = OBSTACK_ZALLOC (&mdebugread_objfile
->objfile_obstack
,
3989 mdebug_extra_func_info
);
3990 struct symbol
*s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
3992 s
->set_domain (LABEL_DOMAIN
);
3993 s
->set_aclass_index (LOC_CONST
);
3994 s
->set_type (objfile_type (objfile
)->builtin_void
);
3995 s
->set_value_bytes ((gdb_byte
*) e
);
3996 e
->pdr
.framereg
= -1;
3997 add_symbol_to_list (s
, get_local_symbols ());
4000 else if (sh
.st
== stLabel
)
4002 if (sh
.index
== indexNil
)
4004 /* This is what the gcc2_compiled and __gnu_compiled_*
4005 show up as. So don't complain. */
4010 /* Handle encoded stab line number. */
4011 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
4012 record_line (get_current_subfile (), sh
.index
,
4013 gdbarch_addr_bits_remove (gdbarch
, valu
));
4016 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
4017 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
4018 /* These are generated by gcc-2.x, do not complain. */
4021 complaint (_("unknown stabs symbol %s"), name
);
4024 if (! last_symtab_ended
)
4026 cust
= end_compunit_symtab (pst
->raw_text_high (),
4027 SECT_OFF_TEXT (objfile
));
4031 /* There used to be a call to sort_blocks here, but this should not
4032 be necessary for stabs symtabs. And as sort_blocks modifies the
4033 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
4034 it did the wrong thing if the first procedure in a file was
4035 generated via asm statements. */
4037 /* Fill in procedure info next. */
4045 gdb::def_vector
<PDR
> pr_block (fh
->cpd
);
4047 pdr_ptr
= ((char *) debug_info
->external_pdr
4048 + fh
->ipdFirst
* external_pdr_size
);
4049 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4050 pdr_in
= pr_block
.data ();
4053 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4055 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4057 /* Determine lowest PDR address, the PDRs are not always
4059 if (pdr_in
== pr_block
.data ())
4060 lowest_pdr_addr
= pdr_in
->adr
;
4061 else if (pdr_in
->adr
< lowest_pdr_addr
)
4062 lowest_pdr_addr
= pdr_in
->adr
;
4065 pdr_in
= pr_block
.data ();
4066 pdr_in_end
= pdr_in
+ fh
->cpd
;
4067 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4068 parse_procedure (pdr_in
, cust
, pst
);
4073 /* This symbol table contains ordinary ecoff entries. */
4081 cust
= new_symtab ("unknown", 0, objfile
);
4085 maxlines
= 2 * fh
->cline
;
4086 cust
= new_symtab (pst
->filename
, maxlines
, objfile
);
4088 /* The proper language was already determined when building
4089 the psymtab, use it. */
4090 cust
->primary_filetab ()->set_language
4091 (PST_PRIVATE (pst
)->pst_language
);
4094 psymtab_language
= cust
->primary_filetab ()->language ();
4096 lines
= cust
->primary_filetab ()->linetable ();
4098 /* Get a new lexical context. */
4100 push_parse_stack ();
4101 top_stack
->cur_st
= cust
->primary_filetab ();
4102 top_stack
->cur_block
4103 = BLOCKVECTOR_BLOCK (cust
->blockvector (), STATIC_BLOCK
);
4104 top_stack
->cur_block
->set_start (pst
->text_low (objfile
));
4105 top_stack
->cur_block
->set_end (0);
4106 top_stack
->blocktype
= stFile
;
4107 top_stack
->cur_type
= 0;
4108 top_stack
->procadr
= 0;
4109 top_stack
->numargs
= 0;
4110 found_ecoff_debugging_info
= 0;
4117 /* Parse local symbols first. */
4118 sym_ptr
= ((char *) debug_info
->external_sym
4119 + fh
->isymBase
* external_sym_size
);
4120 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
4121 while (sym_ptr
< sym_end
)
4126 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
4127 c
= parse_symbol (&sh
,
4128 debug_info
->external_aux
+ fh
->iauxBase
,
4129 sym_ptr
, fh
->fBigendian
,
4130 section_offsets
, objfile
);
4131 sym_ptr
+= c
* external_sym_size
;
4134 /* Linenumbers. At the end, check if we can save memory.
4135 parse_lines has to look ahead an arbitrary number of PDR
4136 structures, so we swap them all first. */
4144 gdb::def_vector
<PDR
> pr_block (fh
->cpd
);
4146 pdr_ptr
= ((char *) debug_info
->external_pdr
4147 + fh
->ipdFirst
* external_pdr_size
);
4148 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4149 pdr_in
= pr_block
.data ();
4152 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4154 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4156 /* Determine lowest PDR address, the PDRs are not always
4158 if (pdr_in
== pr_block
.data ())
4159 lowest_pdr_addr
= pdr_in
->adr
;
4160 else if (pdr_in
->adr
< lowest_pdr_addr
)
4161 lowest_pdr_addr
= pdr_in
->adr
;
4164 parse_lines (fh
, pr_block
.data (), lines
, maxlines
,
4165 pst
->text_low (objfile
), lowest_pdr_addr
);
4166 if (lines
->nitems
< fh
->cline
)
4167 lines
= shrink_linetable (lines
);
4169 /* Fill in procedure info next. */
4170 pdr_in
= pr_block
.data ();
4171 pdr_in_end
= pdr_in
+ fh
->cpd
;
4172 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4173 parse_procedure (pdr_in
, NULL
, pst
);
4177 size
= lines
->nitems
;
4180 cust
->primary_filetab ()->set_linetable
4181 ((struct linetable
*)
4182 obstack_copy (&mdebugread_objfile
->objfile_obstack
,
4183 lines
, (sizeof (struct linetable
)
4184 + size
* sizeof (lines
->item
))));
4187 /* .. and our share of externals.
4188 XXX use the global list to speed up things here. How?
4189 FIXME, Maybe quit once we have found the right number of ext's? */
4190 top_stack
->cur_st
= cust
->primary_filetab ();
4191 top_stack
->cur_block
4192 = BLOCKVECTOR_BLOCK (top_stack
->cur_st
->compunit ()->blockvector (),
4194 top_stack
->blocktype
= stFile
;
4196 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
4197 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
4198 parse_external (ext_ptr
, fh
->fBigendian
,
4199 section_offsets
, objfile
);
4201 /* If there are undefined symbols, tell the user.
4202 The alpha has an undefined symbol for every symbol that is
4203 from a shared library, so tell the user only if verbose is on. */
4204 if (info_verbose
&& n_undef_symbols
)
4206 gdb_printf (_("File %s contains %d unresolved references:"),
4207 symtab_to_filename_for_display
4208 (cust
->primary_filetab ()),
4210 gdb_printf ("\n\t%4d variables\n\t%4d "
4211 "procedures\n\t%4d labels\n",
4212 n_undef_vars
, n_undef_procs
, n_undef_labels
);
4213 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
4218 sort_blocks (cust
->primary_filetab ());
4221 /* Now link the psymtab and the symtab. */
4222 pst
->compunit_symtab
= cust
;
4224 mdebugread_objfile
= NULL
;
4227 /* Ancillary parsing procedures. */
4229 /* Return 1 if the symbol pointed to by SH has a cross reference
4230 to an opaque aggregate type, else 0. */
4233 has_opaque_xref (FDR
*fh
, SYMR
*sh
)
4240 if (sh
->index
== indexNil
)
4243 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
4244 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
4245 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
4249 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
4250 if (rn
->rfd
== 0xfff)
4251 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
4259 /* Lookup the type at relative index RN. Return it in TPP
4260 if found and in any event come up with its name PNAME.
4261 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4262 Return value says how many aux symbols we ate. */
4265 cross_ref (int fd
, union aux_ext
*ax
, struct type
**tpp
,
4266 enum type_code type_code
,
4267 /* Use to alloc new type if none is found. */
4268 const char **pname
, int bigend
, const char *sym_name
)
4277 struct mdebug_pending
*pend
;
4281 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
4283 /* Escape index means 'the next one'. */
4284 if (rn
->rfd
== 0xfff)
4287 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
4294 /* mips cc uses a rf of -1 for opaque struct definitions.
4295 Set TYPE_STUB for these types so that check_typedef will
4296 resolve them if the struct gets defined in another compilation unit. */
4299 *pname
= "<undefined>";
4300 *tpp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
4301 (*tpp
)->set_is_stub (true);
4305 /* mips cc uses an escaped rn->index of 0 for struct return types
4306 of procedures that were compiled without -g. These will always remain
4308 if (rn
->rfd
== 0xfff && rn
->index
== 0)
4310 *pname
= "<undefined>";
4314 /* Find the relative file descriptor and the symbol in it. */
4315 fh
= get_rfd (fd
, rf
);
4316 xref_fd
= fh
- debug_info
->fdr
;
4318 if (rn
->index
>= fh
->csym
)
4320 /* File indirect entry is corrupt. */
4321 *pname
= "<illegal>";
4322 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4326 /* If we have processed this symbol then we left a forwarding
4327 pointer to the type in the pending list. If not, we`ll put
4328 it in a list of pending types, to be processed later when
4329 the file will be. In any event, we collect the name for the
4332 esh
= ((char *) debug_info
->external_sym
4333 + ((fh
->isymBase
+ rn
->index
)
4334 * debug_swap
->external_sym_size
));
4335 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
4337 /* Make sure that this type of cross reference can be handled. */
4338 if ((sh
.sc
!= scInfo
4339 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
4340 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
4341 && sh
.st
!= stEnum
))
4342 && (sh
.st
!= stBlock
|| !SC_IS_COMMON (sh
.sc
)))
4344 /* File indirect entry is corrupt. */
4345 *pname
= "<illegal>";
4346 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4350 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4352 pend
= is_pending_symbol (fh
, esh
);
4357 /* We have not yet seen this type. */
4359 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
4363 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4365 a) forward declarations of structs/unions/enums which are not
4366 defined in this compilation unit.
4367 For these the type will be void. This is a bad design decision
4368 as cross referencing across compilation units is impossible
4369 due to the missing name.
4370 b) forward declarations of structs/unions/enums/typedefs which
4371 are defined later in this file or in another file in the same
4372 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4373 Simply cross reference those again to get the true type.
4374 The forward references are not entered in the pending list and
4375 in the symbol table. */
4377 (*debug_swap
->swap_tir_in
) (bigend
,
4378 &(debug_info
->external_aux
4379 + fh
->iauxBase
+ sh
.index
)->a_ti
,
4381 if (tir
.tq0
!= tqNil
)
4382 complaint (_("illegal tq0 in forward typedef for %s"), sym_name
);
4386 *tpp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
4387 *pname
= "<undefined>";
4394 (debug_info
->external_aux
4395 + fh
->iauxBase
+ sh
.index
+ 1),
4396 tpp
, type_code
, pname
,
4397 fh
->fBigendian
, sym_name
);
4401 /* Follow a forward typedef. This might recursively
4402 call cross_ref till we get a non typedef'ed type.
4403 FIXME: This is not correct behaviour, but gdb currently
4404 cannot handle typedefs without type copying. Type
4405 copying is impossible as we might have mutual forward
4406 references between two files and the copied type would not
4407 get filled in when we later parse its definition. */
4408 *tpp
= parse_type (xref_fd
,
4409 debug_info
->external_aux
+ fh
->iauxBase
,
4413 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4414 add_pending (fh
, esh
, *tpp
);
4418 complaint (_("illegal bt %d in forward typedef for %s"), tir
.bt
,
4420 *tpp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
4425 else if (sh
.st
== stTypedef
)
4427 /* Parse the type for a normal typedef. This might recursively call
4428 cross_ref till we get a non typedef'ed type.
4429 FIXME: This is not correct behaviour, but gdb currently
4430 cannot handle typedefs without type copying. But type copying is
4431 impossible as we might have mutual forward references between
4432 two files and the copied type would not get filled in when
4433 we later parse its definition. */
4434 *tpp
= parse_type (xref_fd
,
4435 debug_info
->external_aux
+ fh
->iauxBase
,
4439 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4443 /* Cross reference to a struct/union/enum which is defined
4444 in another file in the same compilation unit but that file
4445 has not been parsed yet.
4446 Initialize the type only, it will be filled in when
4447 it's definition is parsed. */
4448 *tpp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
4450 add_pending (fh
, esh
, *tpp
);
4453 /* We used one auxent normally, two if we got a "next one" rf. */
4458 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4459 keeping the symtab sorted. */
4461 static struct symbol
*
4462 mylookup_symbol (const char *name
, const struct block
*block
,
4463 domain_enum domain
, enum address_class theclass
)
4465 struct block_iterator iter
;
4470 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
4472 if (sym
->linkage_name ()[0] == inc
4473 && sym
->domain () == domain
4474 && sym
->aclass () == theclass
4475 && strcmp (sym
->linkage_name (), name
) == 0)
4479 block
= block
->superblock ();
4481 return mylookup_symbol (name
, block
, domain
, theclass
);
4486 /* Add a new symbol S to a block B. */
4489 add_symbol (struct symbol
*s
, struct symtab
*symtab
, struct block
*b
)
4491 s
->set_symtab (symtab
);
4492 mdict_add_symbol (BLOCK_MULTIDICT (b
), s
);
4495 /* Add a new block B to a symtab S. */
4498 add_block (struct block
*b
, struct symtab
*s
)
4500 /* Cast away "const", but that's ok because we're building the
4501 symtab and blockvector here. */
4502 struct blockvector
*bv
4503 = (struct blockvector
*) s
->compunit ()->blockvector ();
4505 bv
= (struct blockvector
*) xrealloc ((void *) bv
,
4506 (sizeof (struct blockvector
)
4507 + BLOCKVECTOR_NBLOCKS (bv
)
4508 * sizeof (bv
->block
)));
4509 if (bv
!= s
->compunit ()->blockvector ())
4510 s
->compunit ()->set_blockvector (bv
);
4512 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
4515 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4516 MIPS' linenumber encoding might need more than one byte
4517 to describe it, LAST is used to detect these continuation lines.
4519 Combining lines with the same line number seems like a bad idea.
4520 E.g: There could be a line number entry with the same line number after the
4521 prologue and GDB should not ignore it (this is a better way to find
4522 a prologue than mips_skip_prologue).
4523 But due to the compressed line table format there are line number entries
4524 for the same line which are needed to bridge the gap to the next
4525 line number entry. These entries have a bogus address info with them
4526 and we are unable to tell them from intended duplicate line number
4528 This is another reason why -ggdb debugging format is preferable. */
4531 add_line (struct linetable
*lt
, int lineno
, CORE_ADDR adr
, int last
)
4533 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4534 Change them to something sensible. */
4538 last
= -2; /* Make sure we record first line. */
4540 if (last
== lineno
) /* Skip continuation lines. */
4543 lt
->item
[lt
->nitems
].line
= lineno
;
4544 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
4548 /* Sorting and reordering procedures. */
4550 /* Blocks with a smaller low bound should come first. */
4553 block_is_less_than (const struct block
*b1
, const struct block
*b2
)
4555 CORE_ADDR start1
= b1
->start ();
4556 CORE_ADDR start2
= b2
->start ();
4558 if (start1
!= start2
)
4559 return start1
< start2
;
4561 return (b2
->end ()) < (b1
->end ());
4564 /* Sort the blocks of a symtab S.
4565 Reorder the blocks in the blockvector by code-address,
4566 as required by some MI search routines. */
4569 sort_blocks (struct symtab
*s
)
4571 /* We have to cast away const here, but this is ok because we're
4572 constructing the blockvector in this code. */
4573 struct blockvector
*bv
4574 = (struct blockvector
*) s
->compunit ()->blockvector ();
4576 if (BLOCKVECTOR_NBLOCKS (bv
) <= FIRST_LOCAL_BLOCK
)
4579 if (BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
)->end () == 0)
4580 BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
)->set_start (0);
4581 if (BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
)->end () == 0)
4582 BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
)->set_start (0);
4586 * This is very unfortunate: normally all functions are compiled in
4587 * the order they are found, but if the file is compiled -O3 things
4588 * are very different. It would be nice to find a reliable test
4589 * to detect -O3 images in advance.
4591 if (BLOCKVECTOR_NBLOCKS (bv
) > FIRST_LOCAL_BLOCK
+ 1)
4592 std::sort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
4593 &BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)),
4594 block_is_less_than
);
4598 int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
4600 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
4601 if (high
< BLOCKVECTOR_BLOCK(bv
, i
)->end ())
4602 high
= BLOCKVECTOR_BLOCK(bv
, i
)->end ();
4603 BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
)->set_end (high
);
4606 BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
)->set_start
4607 (BLOCKVECTOR_BLOCK(bv
, FIRST_LOCAL_BLOCK
)->start ());
4609 BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
)->set_start
4610 (BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
)->start ());
4612 BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
)->set_end
4613 (BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
)->end ());
4617 /* Constructor/restructor/destructor procedures. */
4619 /* Allocate a new symtab for NAME. Needs an estimate of how many
4620 linenumbers MAXLINES we'll put in it. */
4622 static struct compunit_symtab
*
4623 new_symtab (const char *name
, int maxlines
, struct objfile
*objfile
)
4625 struct compunit_symtab
*cust
= allocate_compunit_symtab (objfile
, name
);
4626 struct symtab
*symtab
;
4627 struct blockvector
*bv
;
4630 add_compunit_symtab_to_objfile (cust
);
4631 symtab
= allocate_symtab (cust
, name
);
4633 symtab
->set_linetable (new_linetable (maxlines
));
4634 lang
= compunit_language (cust
);
4636 /* All symtabs must have at least two blocks. */
4638 BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
) = new_block (NON_FUNCTION_BLOCK
, lang
);
4639 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
) = new_block (NON_FUNCTION_BLOCK
, lang
);
4640 BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
)->set_superblock
4641 (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4642 cust
->set_blockvector (bv
);
4644 cust
->set_debugformat ("ECOFF");
4648 /* Allocate a new partial_symtab NAME. */
4650 static legacy_psymtab
*
4651 new_psymtab (const char *name
, psymtab_storage
*partial_symtabs
,
4652 struct objfile
*objfile
)
4654 legacy_psymtab
*psymtab
;
4656 psymtab
= new legacy_psymtab (name
, partial_symtabs
, objfile
->per_bfd
);
4658 /* Keep a backpointer to the file's symbols. */
4660 psymtab
->read_symtab_private
4661 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, symloc
);
4662 CUR_BFD (psymtab
) = cur_bfd
;
4663 DEBUG_SWAP (psymtab
) = debug_swap
;
4664 DEBUG_INFO (psymtab
) = debug_info
;
4665 PENDING_LIST (psymtab
) = pending_list
;
4667 /* The way to turn this into a symtab is to call... */
4668 psymtab
->legacy_read_symtab
= mdebug_read_symtab
;
4669 psymtab
->legacy_expand_psymtab
= mdebug_expand_psymtab
;
4674 /* Allocate a linetable array of the given SIZE. Since the struct
4675 already includes one item, we subtract one when calculating the
4676 proper size to allocate. */
4678 static struct linetable
*
4679 new_linetable (int size
)
4681 struct linetable
*l
;
4685 size
= size
* sizeof (l
->item
) + sizeof (struct linetable
);
4686 l
= (struct linetable
*) xmalloc (size
);
4691 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4692 I am not so sure about the 3.4 ones.
4694 Since the struct linetable already includes one item, we subtract one when
4695 calculating the proper size to allocate. */
4697 static struct linetable
*
4698 shrink_linetable (struct linetable
*lt
)
4700 return (struct linetable
*) xrealloc ((void *) lt
,
4701 (sizeof (struct linetable
)
4703 * sizeof (lt
->item
))));
4706 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4708 static struct blockvector
*
4709 new_bvect (int nblocks
)
4711 struct blockvector
*bv
;
4714 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4715 bv
= (struct blockvector
*) xzalloc (size
);
4717 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4722 /* Allocate and zero a new block of language LANGUAGE, and set its
4723 BLOCK_MULTIDICT. If function is non-zero, assume the block is
4724 associated to a function, and make sure that the symbols are stored
4725 linearly; otherwise, store them hashed. */
4727 static struct block
*
4728 new_block (enum block_type type
, enum language language
)
4730 /* FIXME: carlton/2003-09-11: This should use allocate_block to
4731 allocate the block. Which, in turn, suggests that the block
4732 should be allocated on an obstack. */
4733 struct block
*retval
= XCNEW (struct block
);
4735 if (type
== FUNCTION_BLOCK
)
4736 BLOCK_MULTIDICT (retval
) = mdict_create_linear_expandable (language
);
4738 BLOCK_MULTIDICT (retval
) = mdict_create_hashed_expandable (language
);
4743 /* Create a new symbol with printname NAME. */
4745 static struct symbol
*
4746 new_symbol (const char *name
)
4748 struct symbol
*s
= new (&mdebugread_objfile
->objfile_obstack
) symbol
;
4750 s
->set_language (psymtab_language
, &mdebugread_objfile
->objfile_obstack
);
4751 s
->compute_and_set_names (name
, true, mdebugread_objfile
->per_bfd
);
4755 /* Create a new type with printname NAME. */
4757 static struct type
*
4758 new_type (char *name
)
4762 t
= alloc_type (mdebugread_objfile
);
4764 INIT_CPLUS_SPECIFIC (t
);
4768 /* Read ECOFF debugging information from a BFD section. This is
4769 called from elfread.c. It parses the section into a
4770 ecoff_debug_info struct, and then lets the rest of the file handle
4774 elfmdebug_build_psymtabs (struct objfile
*objfile
,
4775 const struct ecoff_debug_swap
*swap
, asection
*sec
)
4777 bfd
*abfd
= objfile
->obfd
;
4778 struct ecoff_debug_info
*info
;
4780 /* FIXME: It's not clear whether we should be getting minimal symbol
4781 information from .mdebug in an ELF file, or whether we will.
4782 Re-initialize the minimal symbol reader in case we do. */
4784 minimal_symbol_reader
reader (objfile
);
4786 info
= XOBNEW (&objfile
->objfile_obstack
, ecoff_debug_info
);
4788 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4789 error (_("Error reading ECOFF debugging information: %s"),
4790 bfd_errmsg (bfd_get_error ()));
4792 mdebug_build_psymtabs (reader
, objfile
, swap
, info
);
4797 void _initialize_mdebugread ();
4799 _initialize_mdebugread ()
4801 mdebug_register_index
4802 = register_symbol_register_impl (LOC_REGISTER
, &mdebug_register_funcs
);
4803 mdebug_regparm_index
4804 = register_symbol_register_impl (LOC_REGPARM_ADDR
, &mdebug_register_funcs
);