1 /* Read a symbol table in ECOFF format (Third-Eye).
3 Copyright (C) 1986-2021 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 "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 *, struct objfile
*);
257 static void mdebug_expand_psymtab (legacy_psymtab
*pst
,
258 struct objfile
*objfile
);
260 static void add_block (struct block
*, struct symtab
*);
262 static void add_symbol (struct symbol
*, struct symtab
*, struct block
*);
264 static int add_line (struct linetable
*, int, CORE_ADDR
, int);
266 static struct linetable
*shrink_linetable (struct linetable
*);
268 static void handle_psymbol_enumerators (struct objfile
*, partial_symtab
*,
269 FDR
*, int, CORE_ADDR
);
271 static const char *mdebug_next_symbol_text (struct objfile
*);
273 /* Exported procedure: Builds a symtab from the partial symtab SELF.
274 Restores the environment in effect when SELF was created, delegates
275 most of the work to an ancillary procedure, and sorts
276 and reorders the symtab list at the end. SELF is not NULL. */
279 mdebug_read_symtab (legacy_psymtab
*self
, struct objfile
*objfile
)
281 next_symbol_text_func
= mdebug_next_symbol_text
;
283 self
->expand_psymtab (objfile
);
285 /* Match with global symbols. This only needs to be done once,
286 after all of the symtabs and dependencies have been read in. */
287 scan_file_globals (objfile
);
290 /* File-level interface functions. */
292 /* Find a file descriptor given its index RF relative to a file CF. */
295 get_rfd (int cf
, int rf
)
301 fdrs
= debug_info
->fdr
;
303 /* Object files do not have the RFD table, all refs are absolute. */
306 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
307 ((char *) debug_info
->external_rfd
309 * debug_swap
->external_rfd_size
)),
314 /* Return a safer print NAME for a file descriptor. */
320 return "<stripped file>";
323 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
327 /* Read in and parse the symtab of the file OBJFILE. Symbols from
328 different sections are relocated via the SECTION_OFFSETS. */
331 mdebug_build_psymtabs (minimal_symbol_reader
&reader
,
332 struct objfile
*objfile
,
333 const struct ecoff_debug_swap
*swap
,
334 struct ecoff_debug_info
*info
)
336 cur_bfd
= objfile
->obfd
;
340 stabsread_new_init ();
341 free_header_files ();
342 init_header_files ();
344 /* Make sure all the FDR information is swapped in. */
345 if (info
->fdr
== NULL
)
351 info
->fdr
= (FDR
*) XOBNEWVEC (&objfile
->objfile_obstack
, FDR
,
352 info
->symbolic_header
.ifdMax
);
353 fdr_src
= (char *) info
->external_fdr
;
355 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
357 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
358 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
361 psymtab_storage
*partial_symtabs
= objfile
->partial_symtabs
.get ();
362 parse_partial_symbols (reader
, partial_symtabs
, objfile
);
365 /* Check to make sure file was compiled with -g. If not, warn the
366 user of this limitation. */
367 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
369 if (max_gdbinfo
== 0)
370 printf_unfiltered (_("\n%s not compiled with -g, "
371 "debugging support is limited.\n"),
373 printf_unfiltered (_("You should compile with -g2 or "
374 "-g3 for best debugging support.\n"));
379 /* Local utilities */
381 /* Map of FDR indexes to partial symtabs. */
385 legacy_psymtab
*pst
; /* the psymtab proper */
386 long n_globals
; /* exported globals (external symbols) */
387 long globals_offset
; /* cumulative */
391 /* Utility stack, used to nest procedures and blocks properly.
392 It is a doubly linked list, to avoid too many alloc/free.
393 Since we might need it quite a few times it is NOT deallocated
396 static struct parse_stack
398 struct parse_stack
*next
, *prev
;
399 struct symtab
*cur_st
; /* Current symtab. */
400 struct block
*cur_block
; /* Block in it. */
402 /* What are we parsing. stFile, or stBlock are for files and
403 blocks. stProc or stStaticProc means we have seen the start of a
404 procedure, but not the start of the block within in. When we see
405 the start of that block, we change it to stNil, without pushing a
406 new block, i.e. stNil means both a procedure and a block. */
410 struct type
*cur_type
; /* Type we parse fields for. */
411 int cur_field
; /* Field number in cur_type. */
412 CORE_ADDR procadr
; /* Start addres of this procedure. */
413 int numargs
; /* Its argument count. */
416 *top_stack
; /* Top stack ptr */
419 /* Enter a new lexical context. */
422 push_parse_stack (void)
424 struct parse_stack
*newobj
;
426 /* Reuse frames if possible. */
427 if (top_stack
&& top_stack
->prev
)
428 newobj
= top_stack
->prev
;
430 newobj
= XCNEW (struct parse_stack
);
431 /* Initialize new frame with previous content. */
434 struct parse_stack
*prev
= newobj
->prev
;
436 *newobj
= *top_stack
;
437 top_stack
->prev
= newobj
;
439 newobj
->next
= top_stack
;
444 /* Exit a lexical context. */
447 pop_parse_stack (void)
452 top_stack
= top_stack
->next
;
456 /* Cross-references might be to things we haven't looked at
457 yet, e.g. type references. To avoid too many type
458 duplications we keep a quick fixup table, an array
459 of lists of references indexed by file descriptor. */
461 struct mdebug_pending
463 struct mdebug_pending
*next
; /* link */
464 char *s
; /* the unswapped symbol */
465 struct type
*t
; /* its partial type descriptor */
469 /* The pending information is kept for an entire object file. We
470 allocate the pending information table when we create the partial
471 symbols, and we store a pointer to the single table in each
474 static struct mdebug_pending
**pending_list
;
476 /* Check whether we already saw symbol SH in file FH. */
478 static struct mdebug_pending
*
479 is_pending_symbol (FDR
*fh
, char *sh
)
481 int f_idx
= fh
- debug_info
->fdr
;
482 struct mdebug_pending
*p
;
484 /* Linear search is ok, list is typically no more than 10 deep. */
485 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
491 /* Add a new symbol SH of type T. */
494 add_pending (FDR
*fh
, char *sh
, struct type
*t
)
496 int f_idx
= fh
- debug_info
->fdr
;
497 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
499 /* Make sure we do not make duplicates. */
502 p
= XOBNEW (&mdebugread_objfile
->objfile_obstack
, mdebug_pending
);
505 p
->next
= pending_list
[f_idx
];
506 pending_list
[f_idx
] = p
;
511 /* Parsing Routines proper. */
514 reg_value_complaint (int regnum
, int num_regs
, const char *sym
)
516 complaint (_("bad register number %d (max %d) in symbol %s"),
517 regnum
, num_regs
- 1, sym
);
520 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
521 For blocks, procedures and types we open a new lexical context.
522 This is basically just a big switch on the symbol's type. Argument
523 AX is the base pointer of aux symbols for this file (fh->iauxBase).
524 EXT_SH points to the unswapped symbol, which is needed for struct,
525 union, etc., types; it is NULL for an EXTR. BIGEND says whether
526 aux symbols are big-endian or little-endian. Return count of
527 SYMR's handled (normally one). */
530 mdebug_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
532 int regno
= gdbarch_ecoff_reg_to_regnum (gdbarch
, SYMBOL_VALUE (sym
));
534 if (regno
< 0 || regno
>= gdbarch_num_cooked_regs (gdbarch
))
536 reg_value_complaint (regno
, gdbarch_num_cooked_regs (gdbarch
),
539 regno
= gdbarch_sp_regnum (gdbarch
); /* Known safe, though useless. */
545 static const struct symbol_register_ops mdebug_register_funcs
= {
549 /* The "aclass" indices for computed symbols. */
551 static int mdebug_register_index
;
552 static int mdebug_regparm_index
;
554 /* Common code for symbols describing data. */
557 add_data_symbol (SYMR
*sh
, union aux_ext
*ax
, int bigend
,
558 struct symbol
*s
, int aclass_index
, struct block
*b
,
559 struct objfile
*objfile
, const char *name
)
561 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
562 SYMBOL_ACLASS_INDEX (s
) = aclass_index
;
563 add_symbol (s
, top_stack
->cur_st
, b
);
565 /* Type could be missing if file is compiled without debugging info. */
566 if (SC_IS_UNDEF (sh
->sc
)
567 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
568 SYMBOL_TYPE (s
) = objfile_type (objfile
)->nodebug_data_symbol
;
570 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
571 /* Value of a data symbol is its memory address. */
575 parse_symbol (SYMR
*sh
, union aux_ext
*ax
, char *ext_sh
, int bigend
,
576 const section_offsets
§ion_offsets
, struct objfile
*objfile
)
578 struct gdbarch
*gdbarch
= objfile
->arch ();
579 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
580 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
584 struct mdebug_pending
*pend
;
588 long svalue
= sh
->value
;
592 name
= debug_info
->ssext
+ sh
->iss
;
594 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
600 /* Do not relocate relative values.
601 The value of a stEnd symbol is the displacement from the
602 corresponding start symbol value.
603 The value of a stBlock symbol is the displacement from the
604 procedure address. */
605 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
606 sh
->value
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
613 sh
->value
+= section_offsets
[SECT_OFF_DATA (objfile
)];
617 sh
->value
+= section_offsets
[SECT_OFF_BSS (objfile
)];
626 case stGlobal
: /* External symbol, goes into global block. */
627 b
= BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack
->cur_st
),
629 s
= new_symbol (name
);
630 SET_SYMBOL_VALUE_ADDRESS (s
, (CORE_ADDR
) sh
->value
);
631 add_data_symbol (sh
, ax
, bigend
, s
, LOC_STATIC
, b
, objfile
, name
);
634 case stStatic
: /* Static data, goes into current block. */
635 b
= top_stack
->cur_block
;
636 s
= new_symbol (name
);
637 if (SC_IS_COMMON (sh
->sc
))
639 /* It is a FORTRAN common block. At least for SGI Fortran the
640 address is not in the symbol; we need to fix it later in
641 scan_file_globals. */
642 int bucket
= hashname (s
->linkage_name ());
643 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
644 global_sym_chain
[bucket
] = s
;
647 SET_SYMBOL_VALUE_ADDRESS (s
, (CORE_ADDR
) sh
->value
);
648 add_data_symbol (sh
, ax
, bigend
, s
, LOC_STATIC
, b
, objfile
, name
);
651 case stLocal
: /* Local variable, goes into current block. */
652 b
= top_stack
->cur_block
;
653 s
= new_symbol (name
);
654 SYMBOL_VALUE (s
) = svalue
;
655 if (sh
->sc
== scRegister
)
656 add_data_symbol (sh
, ax
, bigend
, s
, mdebug_register_index
,
659 add_data_symbol (sh
, ax
, bigend
, s
, LOC_LOCAL
,
663 case stParam
: /* Arg to procedure, goes into current
666 found_ecoff_debugging_info
= 1;
667 top_stack
->numargs
++;
669 /* Special GNU C++ name. */
670 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
671 name
= "this"; /* FIXME, not alloc'd in obstack. */
672 s
= new_symbol (name
);
674 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
675 SYMBOL_IS_ARGUMENT (s
) = 1;
679 /* Pass by value in register. */
680 SYMBOL_ACLASS_INDEX (s
) = mdebug_register_index
;
683 /* Pass by reference on stack. */
684 SYMBOL_ACLASS_INDEX (s
) = LOC_REF_ARG
;
687 /* Pass by reference in register. */
688 SYMBOL_ACLASS_INDEX (s
) = mdebug_regparm_index
;
691 /* Pass by value on stack. */
692 SYMBOL_ACLASS_INDEX (s
) = LOC_ARG
;
695 SYMBOL_VALUE (s
) = svalue
;
696 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
697 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
700 case stLabel
: /* label, goes into current block. */
701 s
= new_symbol (name
);
702 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
; /* So that it can be used */
703 SYMBOL_ACLASS_INDEX (s
) = LOC_LABEL
; /* but not misused. */
704 SET_SYMBOL_VALUE_ADDRESS (s
, (CORE_ADDR
) sh
->value
);
705 SYMBOL_TYPE (s
) = objfile_type (objfile
)->builtin_int
;
706 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
709 case stProc
: /* Procedure, usually goes into global block. */
710 case stStaticProc
: /* Static procedure, goes into current block. */
711 /* For stProc symbol records, we need to check the storage class
712 as well, as only (stProc, scText) entries represent "real"
713 procedures - See the Compaq document titled "Object File /
714 Symbol Table Format Specification" for more information.
715 If the storage class is not scText, we discard the whole block
716 of symbol records for this stProc. */
717 if (sh
->st
== stProc
&& sh
->sc
!= scText
)
719 char *ext_tsym
= ext_sh
;
720 int keep_counting
= 1;
723 while (keep_counting
)
725 ext_tsym
+= external_sym_size
;
726 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
736 complaint (_("unknown symbol type 0x%x"), sh
->st
);
742 s
= new_symbol (name
);
743 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
744 SYMBOL_ACLASS_INDEX (s
) = LOC_BLOCK
;
745 /* Type of the return value. */
746 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
747 t
= objfile_type (objfile
)->builtin_int
;
750 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
751 if (strcmp (name
, "malloc") == 0
752 && t
->code () == TYPE_CODE_VOID
)
754 /* I don't know why, but, at least under Alpha GNU/Linux,
755 when linking against a malloc without debugging
756 symbols, its read as a function returning void---this
757 is bad because it means we cannot call functions with
758 string arguments interactively; i.e., "call
759 printf("howdy\n")" would fail with the error message
760 "program has no memory available". To avoid this, we
761 patch up the type and make it void*
762 instead. (davidm@azstarnet.com). */
763 t
= make_pointer_type (t
, NULL
);
766 b
= top_stack
->cur_block
;
767 if (sh
->st
== stProc
)
769 const struct blockvector
*bv
770 = SYMTAB_BLOCKVECTOR (top_stack
->cur_st
);
772 /* The next test should normally be true, but provides a
773 hook for nested functions (which we don't want to make
775 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
776 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
777 /* Irix 5 sometimes has duplicate names for the same
778 function. We want to add such names up at the global
779 level, not as a nested function. */
780 else if (sh
->value
== top_stack
->procadr
)
781 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
783 add_symbol (s
, top_stack
->cur_st
, b
);
785 /* Make a type for the procedure itself. */
786 SYMBOL_TYPE (s
) = lookup_function_type (t
);
788 /* All functions in C++ have prototypes. For C we don't have enough
789 information in the debug info. */
790 if (s
->language () == language_cplus
)
791 SYMBOL_TYPE (s
)->set_is_prototyped (true);
793 /* Create and enter a new lexical context. */
794 b
= new_block (FUNCTION_BLOCK
, s
->language ());
795 SYMBOL_BLOCK_VALUE (s
) = b
;
796 BLOCK_FUNCTION (b
) = s
;
797 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
798 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
799 add_block (b
, top_stack
->cur_st
);
801 /* Not if we only have partial info. */
802 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
806 top_stack
->cur_block
= b
;
807 top_stack
->blocktype
= sh
->st
;
808 top_stack
->cur_type
= SYMBOL_TYPE (s
);
809 top_stack
->cur_field
= -1;
810 top_stack
->procadr
= sh
->value
;
811 top_stack
->numargs
= 0;
814 /* Beginning of code for structure, union, and enum definitions.
815 They all share a common set of local variables, defined here. */
817 enum type_code type_code
;
823 case stStruct
: /* Start a block defining a struct type. */
824 type_code
= TYPE_CODE_STRUCT
;
825 goto structured_common
;
827 case stUnion
: /* Start a block defining a union type. */
828 type_code
= TYPE_CODE_UNION
;
829 goto structured_common
;
831 case stEnum
: /* Start a block defining an enum type. */
832 type_code
= TYPE_CODE_ENUM
;
833 goto structured_common
;
835 case stBlock
: /* Either a lexical block, or some type. */
836 if (sh
->sc
!= scInfo
&& !SC_IS_COMMON (sh
->sc
))
837 goto case_stBlock_code
; /* Lexical block */
839 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
841 /* Common code for handling struct, union, enum, and/or as-yet-
842 unknown-type blocks of info about structured data. `type_code'
843 has been set to the proper TYPE_CODE, if we know it. */
845 found_ecoff_debugging_info
= 1;
847 top_stack
->blocktype
= stBlock
;
849 /* First count the number of fields and the highest value. */
852 for (ext_tsym
= ext_sh
+ external_sym_size
;
854 ext_tsym
+= external_sym_size
)
858 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
863 /* C++ encodes class types as structures where there the
864 methods are encoded as stProc. The scope of stProc
865 symbols also ends with stEnd, thus creating a risk of
866 taking the wrong stEnd symbol record as the end of
867 the current struct, which would cause GDB to undercount
868 the real number of fields in this struct. To make sure
869 we really reached the right stEnd symbol record, we
870 check the associated name, and match it against the
871 struct name. Since method names are mangled while
872 the class name is not, there is no risk of having a
873 method whose name is identical to the class name
874 (in particular constructor method names are different
875 from the class name). There is therefore no risk that
876 this check stops the count on the StEnd of a method.
878 Also, assume that we're really at the end when tsym.iss
880 if (tsym
.iss
== issNull
881 || strcmp (debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
,
887 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
889 /* If the type of the member is Nil (or Void),
890 without qualifiers, assume the tag is an
892 Alpha cc -migrate enums are recognized by a zero
893 index and a zero symbol value.
894 DU 4.0 cc enums are recognized by a member type of
895 btEnum without qualifiers and a zero symbol value. */
896 if (tsym
.index
== indexNil
897 || (tsym
.index
== 0 && sh
->value
== 0))
898 type_code
= TYPE_CODE_ENUM
;
901 (*debug_swap
->swap_tir_in
) (bigend
,
902 &ax
[tsym
.index
].a_ti
,
904 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
905 || (tir
.bt
== btEnum
&& sh
->value
== 0))
907 type_code
= TYPE_CODE_ENUM
;
911 if (tsym
.value
> max_value
)
912 max_value
= tsym
.value
;
921 /* This is a no-op; is it trying to tell us something
922 we should be checking? */
923 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED */
927 /* This is something like a struct within a
928 struct. Skip over the fields of the inner
929 struct. The -1 is because the for loop will
930 increment ext_tsym. */
931 ext_tsym
= ((char *) debug_info
->external_sym
932 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
933 * external_sym_size
));
939 /* mips cc puts out a typedef for struct x if it is not yet
940 defined when it encounters
941 struct y { struct x *xp; };
946 /* Irix5 cc puts out a stIndirect for struct x if it is not
947 yet defined when it encounters
948 struct y { struct x *xp; };
953 complaint (_("declaration block contains "
954 "unhandled symbol type %d"),
960 /* In an stBlock, there is no way to distinguish structs,
961 unions, and enums at this point. This is a bug in the
962 original design (that has been fixed with the recent
963 addition of the stStruct, stUnion, and stEnum symbol
964 types.) The way you can tell is if/when you see a variable
965 or field of that type. In that case the variable's type
966 (in the AUX table) says if the type is struct, union, or
967 enum, and points back to the stBlock here. So you can
968 patch the tag kind up later - but only if there actually is
969 a variable or field of that type.
971 So until we know for sure, we will guess at this point.
973 If the first member has index==indexNil or a void type,
974 assume we have an enumeration.
975 Otherwise, if there is more than one member, and all
976 the members have offset 0, assume we have a union.
977 Otherwise, assume we have a struct.
979 The heuristic could guess wrong in the case of of an
980 enumeration with no members or a union with one (or zero)
981 members, or when all except the last field of a struct have
982 width zero. These are uncommon and/or illegal situations,
983 and in any case guessing wrong probably doesn't matter
986 But if we later do find out we were wrong, we fixup the tag
987 kind. Members of an enumeration must be handled
988 differently from struct/union fields, and that is harder to
989 patch up, but luckily we shouldn't need to. (If there are
990 any enumeration members, we can tell for sure it's an enum
993 if (type_code
== TYPE_CODE_UNDEF
)
995 if (nfields
> 1 && max_value
== 0)
996 type_code
= TYPE_CODE_UNION
;
998 type_code
= TYPE_CODE_STRUCT
;
1001 /* Create a new type or use the pending type. */
1002 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1005 t
= new_type (NULL
);
1006 add_pending (cur_fdr
, ext_sh
, t
);
1011 /* Do not set the tag name if it is a compiler generated tag name
1012 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1013 Alpha cc puts out an sh->iss of zero for those. */
1014 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1017 t
->set_name (obconcat (&mdebugread_objfile
->objfile_obstack
,
1018 name
, (char *) NULL
));
1020 t
->set_code (type_code
);
1021 TYPE_LENGTH (t
) = sh
->value
;
1022 t
->set_num_fields (nfields
);
1023 f
= ((struct field
*) TYPE_ALLOC (t
, nfields
* sizeof (struct field
)));
1026 if (type_code
== TYPE_CODE_ENUM
)
1028 int unsigned_enum
= 1;
1030 /* This is a non-empty enum. */
1032 /* DEC c89 has the number of enumerators in the sh.value field,
1033 not the type length, so we have to compensate for that
1034 incompatibility quirk.
1035 This might do the wrong thing for an enum with one or two
1036 enumerators and gcc -gcoff -fshort-enums, but these cases
1037 are hopefully rare enough.
1038 Alpha cc -migrate has a sh.value field of zero, we adjust
1040 if (TYPE_LENGTH (t
) == t
->num_fields ()
1041 || TYPE_LENGTH (t
) == 0)
1042 TYPE_LENGTH (t
) = gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
1043 for (ext_tsym
= ext_sh
+ external_sym_size
;
1045 ext_tsym
+= external_sym_size
)
1048 struct symbol
*enum_sym
;
1050 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1052 if (tsym
.st
!= stMember
)
1055 SET_FIELD_ENUMVAL (*f
, tsym
.value
);
1057 FIELD_NAME (*f
) = debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1058 FIELD_BITSIZE (*f
) = 0;
1060 enum_sym
= new (&mdebugread_objfile
->objfile_obstack
) symbol
;
1061 enum_sym
->set_linkage_name
1062 (obstack_strdup (&mdebugread_objfile
->objfile_obstack
,
1064 SYMBOL_ACLASS_INDEX (enum_sym
) = LOC_CONST
;
1065 SYMBOL_TYPE (enum_sym
) = t
;
1066 SYMBOL_DOMAIN (enum_sym
) = VAR_DOMAIN
;
1067 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1068 if (SYMBOL_VALUE (enum_sym
) < 0)
1070 add_symbol (enum_sym
, top_stack
->cur_st
, top_stack
->cur_block
);
1072 /* Skip the stMembers that we've handled. */
1077 t
->set_is_unsigned (true);
1079 /* Make this the current type. */
1080 top_stack
->cur_type
= t
;
1081 top_stack
->cur_field
= 0;
1083 /* Do not create a symbol for alpha cc unnamed structs. */
1087 /* gcc puts out an empty struct for an opaque struct definitions,
1088 do not create a symbol for it either. */
1089 if (t
->num_fields () == 0)
1091 t
->set_is_stub (true);
1095 s
= new_symbol (name
);
1096 SYMBOL_DOMAIN (s
) = STRUCT_DOMAIN
;
1097 SYMBOL_ACLASS_INDEX (s
) = LOC_TYPEDEF
;
1098 SYMBOL_VALUE (s
) = 0;
1099 SYMBOL_TYPE (s
) = t
;
1100 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1103 /* End of local variables shared by struct, union, enum, and
1104 block (as yet unknown struct/union/enum) processing. */
1108 found_ecoff_debugging_info
= 1;
1109 /* Beginnning of (code) block. Value of symbol
1110 is the displacement from procedure start. */
1111 push_parse_stack ();
1113 /* Do not start a new block if this is the outermost block of a
1114 procedure. This allows the LOC_BLOCK symbol to point to the
1115 block with the local variables, so funcname::var works. */
1116 if (top_stack
->blocktype
== stProc
1117 || top_stack
->blocktype
== stStaticProc
)
1119 top_stack
->blocktype
= stNil
;
1123 top_stack
->blocktype
= stBlock
;
1124 b
= new_block (NON_FUNCTION_BLOCK
, psymtab_language
);
1125 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1126 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1127 top_stack
->cur_block
= b
;
1128 add_block (b
, top_stack
->cur_st
);
1131 case stEnd
: /* end (of anything) */
1132 if (sh
->sc
== scInfo
|| SC_IS_COMMON (sh
->sc
))
1134 /* Finished with type */
1135 top_stack
->cur_type
= 0;
1137 else if (sh
->sc
== scText
&&
1138 (top_stack
->blocktype
== stProc
||
1139 top_stack
->blocktype
== stStaticProc
))
1141 /* Finished with procedure */
1142 const struct blockvector
*bv
1143 = SYMTAB_BLOCKVECTOR (top_stack
->cur_st
);
1144 struct mdebug_extra_func_info
*e
;
1145 struct block
*cblock
= top_stack
->cur_block
;
1146 struct type
*ftype
= top_stack
->cur_type
;
1149 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1151 /* Make up special symbol to contain procedure specific info. */
1152 s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
1153 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
1154 SYMBOL_ACLASS_INDEX (s
) = LOC_CONST
;
1155 SYMBOL_TYPE (s
) = objfile_type (mdebugread_objfile
)->builtin_void
;
1156 e
= OBSTACK_ZALLOC (&mdebugread_objfile
->objfile_obstack
,
1157 mdebug_extra_func_info
);
1158 SYMBOL_VALUE_BYTES (s
) = (gdb_byte
*) e
;
1159 e
->numargs
= top_stack
->numargs
;
1160 e
->pdr
.framereg
= -1;
1161 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1163 /* f77 emits proc-level with address bounds==[0,0],
1164 So look for such child blocks, and patch them. */
1165 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1167 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1169 if (BLOCK_SUPERBLOCK (b_bad
) == cblock
1170 && BLOCK_START (b_bad
) == top_stack
->procadr
1171 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1173 BLOCK_START (b_bad
) = BLOCK_START (cblock
);
1174 BLOCK_END (b_bad
) = BLOCK_END (cblock
);
1178 if (ftype
->num_fields () <= 0)
1180 /* No parameter type information is recorded with the function's
1181 type. Set that from the type of the parameter symbols. */
1182 int nparams
= top_stack
->numargs
;
1188 struct block_iterator iter
;
1190 ftype
->set_num_fields (nparams
);
1193 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
)));
1196 ALL_BLOCK_SYMBOLS (cblock
, iter
, sym
)
1198 if (iparams
== nparams
)
1201 if (SYMBOL_IS_ARGUMENT (sym
))
1203 ftype
->field (iparams
).set_type (SYMBOL_TYPE (sym
));
1204 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
1211 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1213 /* End of (code) block. The value of the symbol is the
1214 displacement from the procedure`s start address of the
1215 end of this block. */
1216 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1218 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1220 /* End of outermost block. Pop parse stack and ignore. The
1221 following stEnd of stProc will take care of the block. */
1224 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1226 /* End of file. Pop parse stack and ignore. Higher
1227 level code deals with this. */
1231 complaint (_("stEnd with storage class %d not handled"), sh
->sc
);
1233 pop_parse_stack (); /* Restore previous lexical context. */
1236 case stMember
: /* member of struct or union */
1238 struct field
*f
= &top_stack
->cur_type
->field (top_stack
->cur_field
);
1239 top_stack
->cur_field
++;
1240 FIELD_NAME (*f
) = name
;
1241 SET_FIELD_BITPOS (*f
, sh
->value
);
1243 f
->set_type (parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
,
1245 FIELD_BITSIZE (*f
) = bitsize
;
1249 case stIndirect
: /* forward declaration on Irix5 */
1250 /* Forward declarations from Irix5 cc are handled by cross_ref,
1254 case stTypedef
: /* type definition */
1255 found_ecoff_debugging_info
= 1;
1257 /* Typedefs for forward declarations and opaque structs from alpha cc
1258 are handled by cross_ref, skip them. */
1262 /* Parse the type or use the pending type. */
1263 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1266 t
= parse_type (cur_fd
, ax
, sh
->index
, NULL
, bigend
, name
);
1267 add_pending (cur_fdr
, ext_sh
, t
);
1272 /* Mips cc puts out a typedef with the name of the struct for forward
1273 declarations. These should not go into the symbol table and
1274 TYPE_NAME should not be set for them.
1275 They can't be distinguished from an intentional typedef to
1276 the same name however:
1278 struct x { int ix; int jx; };
1282 struct xx {int ixx; int jxx; };
1283 generates a cross referencing stTypedef for x and xx.
1284 The user visible effect of this is that the type of a pointer
1285 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1286 The problem is fixed with alpha cc and Irix5 cc. */
1288 /* However if the typedef cross references to an opaque aggregate, it
1289 is safe to omit it from the symbol table. */
1291 if (has_opaque_xref (cur_fdr
, sh
))
1293 s
= new_symbol (name
);
1294 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1295 SYMBOL_ACLASS_INDEX (s
) = LOC_TYPEDEF
;
1296 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1297 SYMBOL_TYPE (s
) = t
;
1298 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1300 /* Incomplete definitions of structs should not get a name. */
1301 if (SYMBOL_TYPE (s
)->name () == NULL
1302 && (SYMBOL_TYPE (s
)->num_fields () != 0
1303 || (SYMBOL_TYPE (s
)->code () != TYPE_CODE_STRUCT
1304 && SYMBOL_TYPE (s
)->code () != TYPE_CODE_UNION
)))
1306 if (SYMBOL_TYPE (s
)->code () == TYPE_CODE_PTR
1307 || SYMBOL_TYPE (s
)->code () == TYPE_CODE_FUNC
)
1309 /* If we are giving a name to a type such as "pointer to
1310 foo" or "function returning foo", we better not set
1311 the TYPE_NAME. If the program contains "typedef char
1312 *caddr_t;", we don't want all variables of type char
1313 * to print as caddr_t. This is not just a
1314 consequence of GDB's type management; CC and GCC (at
1315 least through version 2.4) both output variables of
1316 either type char * or caddr_t with the type
1317 refering to the stTypedef symbol for caddr_t. If a future
1318 compiler cleans this up it GDB is not ready for it
1319 yet, but if it becomes ready we somehow need to
1320 disable this check (without breaking the PCC/GCC2.4
1325 Fortunately, this check seems not to be necessary
1326 for anything except pointers or functions. */
1329 SYMBOL_TYPE (s
)->set_name (s
->linkage_name ());
1333 case stFile
: /* file name */
1334 push_parse_stack ();
1335 top_stack
->blocktype
= sh
->st
;
1338 /* I`ve never seen these for C */
1340 break; /* register relocation */
1342 break; /* forwarding address */
1344 break; /* constant */
1346 complaint (_("unknown symbol type 0x%x"), sh
->st
);
1355 static const struct objfile_key
<struct type
*,
1356 gdb::noop_deleter
<struct type
*>>
1359 static struct type
*
1360 basic_type (int bt
, struct objfile
*objfile
)
1362 struct gdbarch
*gdbarch
= objfile
->arch ();
1363 struct type
**map_bt
= basic_type_data
.get (objfile
);
1371 map_bt
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
1372 btMax
, struct type
*);
1373 basic_type_data
.set (objfile
, map_bt
);
1382 tp
= objfile_type (objfile
)->builtin_void
;
1386 tp
= init_pointer_type (objfile
, 32, "adr_32",
1387 objfile_type (objfile
)->builtin_void
);
1391 tp
= init_integer_type (objfile
, 8, 0, "char");
1392 tp
->set_has_no_signedness (true);
1396 tp
= init_integer_type (objfile
, 8, 1, "unsigned char");
1400 tp
= init_integer_type (objfile
, 16, 0, "short");
1404 tp
= init_integer_type (objfile
, 16, 1, "unsigned short");
1408 tp
= init_integer_type (objfile
, 32, 0, "int");
1412 tp
= init_integer_type (objfile
, 32, 1, "unsigned int");
1416 tp
= init_integer_type (objfile
, 32, 0, "long");
1420 tp
= init_integer_type (objfile
, 32, 1, "unsigned long");
1424 tp
= init_float_type (objfile
, gdbarch_float_bit (gdbarch
),
1425 "float", gdbarch_float_format (gdbarch
));
1429 tp
= init_float_type (objfile
, gdbarch_double_bit (gdbarch
),
1430 "double", gdbarch_double_format (gdbarch
));
1434 tp
= init_complex_type ("complex", basic_type (btFloat
, objfile
));
1438 tp
= init_complex_type ("double complex", basic_type (btFloat
, objfile
));
1442 /* We use TYPE_CODE_INT to print these as integers. Does this do any
1443 good? Would we be better off with TYPE_CODE_ERROR? Should
1444 TYPE_CODE_ERROR print things in hex if it knows the size? */
1445 tp
= init_integer_type (objfile
, gdbarch_int_bit (gdbarch
), 0,
1450 tp
= init_type (objfile
, TYPE_CODE_ERROR
,
1451 gdbarch_double_bit (gdbarch
), "floating decimal");
1455 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
1457 tp
= init_type (objfile
, TYPE_CODE_STRING
, TARGET_CHAR_BIT
, "string");
1461 tp
= objfile_type (objfile
)->builtin_void
;
1465 tp
= init_integer_type (objfile
, 64, 0, "long");
1469 tp
= init_integer_type (objfile
, 64, 1, "unsigned long");
1473 tp
= init_integer_type (objfile
, 64, 0, "long long");
1477 tp
= init_integer_type (objfile
, 64, 1, "unsigned long long");
1481 tp
= init_pointer_type (objfile
, 64, "adr_64",
1482 objfile_type (objfile
)->builtin_void
);
1486 tp
= init_integer_type (objfile
, 64, 0, "int");
1490 tp
= init_integer_type (objfile
, 64, 1, "unsigned int");
1502 /* Parse the type information provided in the raw AX entries for
1503 the symbol SH. Return the bitfield size in BS, in case.
1504 We must byte-swap the AX entries before we use them; BIGEND says whether
1505 they are big-endian or little-endian (from fh->fBigendian). */
1507 static struct type
*
1508 parse_type (int fd
, union aux_ext
*ax
, unsigned int aux_index
, int *bs
,
1509 int bigend
, const char *sym_name
)
1512 struct type
*tp
= 0;
1513 enum type_code type_code
= TYPE_CODE_UNDEF
;
1515 /* Handle undefined types, they have indexNil. */
1516 if (aux_index
== indexNil
)
1517 return basic_type (btInt
, mdebugread_objfile
);
1519 /* Handle corrupt aux indices. */
1520 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1522 index_complaint (sym_name
);
1523 return basic_type (btInt
, mdebugread_objfile
);
1527 /* Use aux as a type information record, map its basic type. */
1528 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1529 tp
= basic_type (t
->bt
, mdebugread_objfile
);
1532 /* Cannot use builtin types -- build our own. */
1536 type_code
= TYPE_CODE_STRUCT
;
1539 type_code
= TYPE_CODE_UNION
;
1542 type_code
= TYPE_CODE_ENUM
;
1545 type_code
= TYPE_CODE_RANGE
;
1548 type_code
= TYPE_CODE_SET
;
1551 /* alpha cc -migrate uses this for typedefs. The true type will
1552 be obtained by crossreferencing below. */
1553 type_code
= TYPE_CODE_ERROR
;
1556 /* alpha cc uses this for typedefs. The true type will be
1557 obtained by crossreferencing below. */
1558 type_code
= TYPE_CODE_ERROR
;
1561 basic_type_complaint (t
->bt
, sym_name
);
1562 return basic_type (btInt
, mdebugread_objfile
);
1566 /* Move on to next aux. */
1571 int width
= AUX_GET_WIDTH (bigend
, ax
);
1573 /* Inhibit core dumps if TIR is corrupted. */
1576 /* Alpha cc -migrate encodes char and unsigned char types
1577 as short and unsigned short types with a field width of 8.
1578 Enum types also have a field width which we ignore for now. */
1579 if (t
->bt
== btShort
&& width
== 8)
1580 tp
= basic_type (btChar
, mdebugread_objfile
);
1581 else if (t
->bt
== btUShort
&& width
== 8)
1582 tp
= basic_type (btUChar
, mdebugread_objfile
);
1583 else if (t
->bt
== btEnum
)
1586 complaint (_("can't handle TIR fBitfield for %s"),
1594 /* A btIndirect entry cross references to an aux entry containing
1596 if (t
->bt
== btIndirect
)
1603 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1605 if (rn
->rfd
== 0xfff)
1607 rf
= AUX_GET_ISYM (bigend
, ax
);
1615 complaint (_("unable to cross ref btIndirect for %s"), sym_name
);
1616 return basic_type (btInt
, mdebugread_objfile
);
1618 xref_fh
= get_rfd (fd
, rf
);
1619 xref_fd
= xref_fh
- debug_info
->fdr
;
1620 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1621 rn
->index
, NULL
, xref_fh
->fBigendian
, sym_name
);
1624 /* All these types really point to some (common) MIPS type
1625 definition, and only the type-qualifiers fully identify
1626 them. We'll make the same effort at sharing. */
1627 if (t
->bt
== btStruct
||
1631 /* btSet (I think) implies that the name is a tag name, not a typedef
1632 name. This apparently is a MIPS extension for C sets. */
1637 /* Try to cross reference this type, build new type on failure. */
1638 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1640 tp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
1642 /* DEC c89 produces cross references to qualified aggregate types,
1643 dereference them. */
1644 while (tp
->code () == TYPE_CODE_PTR
1645 || tp
->code () == TYPE_CODE_ARRAY
)
1646 tp
= TYPE_TARGET_TYPE (tp
);
1648 /* Make sure that TYPE_CODE(tp) has an expected type code.
1649 Any type may be returned from cross_ref if file indirect entries
1651 if (tp
->code () != TYPE_CODE_STRUCT
1652 && tp
->code () != TYPE_CODE_UNION
1653 && tp
->code () != TYPE_CODE_ENUM
)
1655 unexpected_type_code_complaint (sym_name
);
1659 /* Usually, TYPE_CODE(tp) is already type_code. The main
1660 exception is if we guessed wrong re struct/union/enum.
1661 But for struct vs. union a wrong guess is harmless, so
1662 don't complain(). */
1663 if ((tp
->code () == TYPE_CODE_ENUM
1664 && type_code
!= TYPE_CODE_ENUM
)
1665 || (tp
->code () != TYPE_CODE_ENUM
1666 && type_code
== TYPE_CODE_ENUM
))
1668 bad_tag_guess_complaint (sym_name
);
1671 if (tp
->code () != type_code
)
1673 tp
->set_code (type_code
);
1676 /* Do not set the tag name if it is a compiler generated tag name
1677 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1678 if (name
[0] == '.' || name
[0] == '\0')
1679 tp
->set_name (NULL
);
1680 else if (tp
->name () == NULL
1681 || strcmp (tp
->name (), name
) != 0)
1682 tp
->set_name (obstack_strdup (&mdebugread_objfile
->objfile_obstack
,
1687 /* All these types really point to some (common) MIPS type
1688 definition, and only the type-qualifiers fully identify
1689 them. We'll make the same effort at sharing.
1690 FIXME: We are not doing any guessing on range types. */
1691 if (t
->bt
== btRange
)
1695 /* Try to cross reference this type, build new type on failure. */
1696 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1698 tp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
1700 /* Make sure that TYPE_CODE(tp) has an expected type code.
1701 Any type may be returned from cross_ref if file indirect entries
1703 if (tp
->code () != TYPE_CODE_RANGE
)
1705 unexpected_type_code_complaint (sym_name
);
1709 /* Usually, TYPE_CODE(tp) is already type_code. The main
1710 exception is if we guessed wrong re struct/union/enum. */
1711 if (tp
->code () != type_code
)
1713 bad_tag_guess_complaint (sym_name
);
1714 tp
->set_code (type_code
);
1716 if (tp
->name () == NULL
1717 || strcmp (tp
->name (), name
) != 0)
1718 tp
->set_name (obstack_strdup (&mdebugread_objfile
->objfile_obstack
,
1722 if (t
->bt
== btTypedef
)
1726 /* Try to cross reference this type, it should succeed. */
1727 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1730 complaint (_("unable to cross ref btTypedef for %s"), sym_name
);
1731 tp
= basic_type (btInt
, mdebugread_objfile
);
1735 /* Deal with range types. */
1736 if (t
->bt
== btRange
)
1738 tp
->set_num_fields (0);
1739 tp
->set_bounds (((struct range_bounds
*)
1740 TYPE_ZALLOC (tp
, sizeof (struct range_bounds
))));
1741 tp
->bounds ()->low
.set_const_val (AUX_GET_DNLOW (bigend
, ax
));
1743 tp
->bounds ()->high
.set_const_val (AUX_GET_DNHIGH (bigend
, ax
));
1747 /* Parse all the type qualifiers now. If there are more
1748 than 6 the game will continue in the next aux. */
1752 #define PARSE_TQ(tq) \
1753 if (t->tq != tqNil) \
1754 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1766 /* mips cc 2.x and gcc never put out continued aux entries. */
1770 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1774 /* Complain for illegal continuations due to corrupt aux entries. */
1776 complaint (_("illegal TIR continued for %s"), sym_name
);
1781 /* Make up a complex type from a basic one. Type is passed by
1782 reference in TPP and side-effected as necessary. The type
1783 qualifier TQ says how to handle the aux symbols at AX for
1784 the symbol SX we are currently analyzing. BIGEND says whether
1785 aux symbols are big-endian or little-endian.
1786 Returns the number of aux symbols we parsed. */
1789 upgrade_type (int fd
, struct type
**tpp
, int tq
, union aux_ext
*ax
, int bigend
,
1790 const char *sym_name
)
1795 /* Used in array processing. */
1806 t
= lookup_pointer_type (*tpp
);
1811 t
= lookup_function_type (*tpp
);
1818 /* Determine and record the domain type (type of index). */
1819 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1825 rf
= AUX_GET_ISYM (bigend
, ax
);
1828 fh
= get_rfd (fd
, rf
);
1830 indx
= parse_type (fh
- debug_info
->fdr
,
1831 debug_info
->external_aux
+ fh
->iauxBase
,
1832 id
, NULL
, bigend
, sym_name
);
1834 /* The bounds type should be an integer type, but might be anything
1835 else due to corrupt aux entries. */
1836 if (indx
->code () != TYPE_CODE_INT
)
1838 complaint (_("illegal array index type for %s, assuming int"),
1840 indx
= objfile_type (mdebugread_objfile
)->builtin_int
;
1843 /* Get the bounds, and create the array type. */
1845 lower
= AUX_GET_DNLOW (bigend
, ax
);
1847 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1849 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1851 range
= create_static_range_type (NULL
, indx
, lower
, upper
);
1853 t
= create_array_type (NULL
, *tpp
, range
);
1855 /* We used to fill in the supplied array element bitsize
1856 here if the TYPE_LENGTH of the target type was zero.
1857 This happens for a `pointer to an array of anonymous structs',
1858 but in this case the array element bitsize is also zero,
1859 so nothing is gained.
1860 And we used to check the TYPE_LENGTH of the target type against
1861 the supplied array element bitsize.
1862 gcc causes a mismatch for `pointer to array of object',
1863 since the sdb directives it uses do not have a way of
1864 specifying the bitsize, but it does no harm (the
1865 TYPE_LENGTH should be correct) and we should be able to
1866 ignore the erroneous bitsize from the auxiliary entry safely.
1867 dbx seems to ignore it too. */
1869 /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */
1870 if (TYPE_LENGTH (*tpp
) == 0)
1871 t
->set_target_is_stub (true);
1877 /* Volatile -- currently ignored */
1881 /* Const -- currently ignored */
1885 complaint (_("unknown type qualifier 0x%x"), tq
);
1891 /* Parse a procedure descriptor record PR. Note that the procedure is
1892 parsed _after_ the local symbols, now we just insert the extra
1893 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1894 already been placed in the procedure's main block. Note also that
1895 images that have been partially stripped (ld -x) have been deprived
1896 of local symbols, and we have to cope with them here. FIRST_OFF is
1897 the offset of the first procedure for this FDR; we adjust the
1898 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1899 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1900 in question, or NULL to use top_stack->cur_block. */
1903 parse_procedure (PDR
*pr
, struct compunit_symtab
*search_symtab
,
1904 legacy_psymtab
*pst
)
1906 struct symbol
*s
, *i
;
1907 const struct block
*b
;
1910 /* Simple rule to find files linked "-x". */
1911 if (cur_fdr
->rss
== -1)
1915 /* Static procedure at address pr->adr. Sigh. */
1916 /* FIXME-32x64. assuming pr->adr fits in long. */
1917 complaint (_("can't handle PDR for static proc at 0x%lx"),
1918 (unsigned long) pr
->adr
);
1926 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1927 ((char *) debug_info
->external_ext
1929 * debug_swap
->external_ext_size
)),
1931 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1939 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1940 ((char *) debug_info
->external_sym
1941 + ((cur_fdr
->isymBase
+ pr
->isym
)
1942 * debug_swap
->external_sym_size
)),
1944 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1947 if (search_symtab
!= NULL
)
1950 /* This loses both in the case mentioned (want a static, find a global),
1951 but also if we are looking up a non-mangled name which happens to
1952 match the name of a mangled function. */
1953 /* We have to save the cur_fdr across the call to lookup_symbol.
1954 If the pdr is for a static function and if a global function with
1955 the same name exists, lookup_symbol will eventually read in the symtab
1956 for the global function and clobber cur_fdr. */
1957 FDR
*save_cur_fdr
= cur_fdr
;
1959 s
= lookup_symbol (sh_name
, NULL
, VAR_DOMAIN
, 0);
1960 cur_fdr
= save_cur_fdr
;
1964 BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (search_symtab
),
1971 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1972 VAR_DOMAIN
, LOC_BLOCK
);
1976 b
= SYMBOL_BLOCK_VALUE (s
);
1980 complaint (_("PDR for %s, but no symbol"), sh_name
);
1984 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1985 s
= new_symbol (sh_name
);
1986 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1987 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1988 /* Don't know its type, hope int is ok. */
1990 = lookup_function_type (objfile_type (pst
->objfile
)->builtin_int
);
1991 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1992 /* Won't have symbols for this one. */
1994 SYMBOL_BLOCK_VALUE (s
) = b
;
1995 BLOCK_FUNCTION (b
) = s
;
1996 BLOCK_START (b
) = pr
->adr
;
1997 /* BOUND used to be the end of procedure's text, but the
1998 argument is no longer passed in. */
1999 BLOCK_END (b
) = bound
;
2000 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
2001 add_block (b
, top_stack
->cur_st
);
2005 i
= mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME
, b
, LABEL_DOMAIN
, LOC_CONST
);
2009 struct mdebug_extra_func_info
*e
;
2011 e
= (struct mdebug_extra_func_info
*) SYMBOL_VALUE_BYTES (i
);
2014 /* GDB expects the absolute function start address for the
2015 procedure descriptor in e->pdr.adr.
2016 As the address in the procedure descriptor is usually relative,
2017 we would have to relocate e->pdr.adr with cur_fdr->adr.
2018 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2019 in shared libraries on some systems, and on other systems
2020 e->pdr.adr is sometimes offset by a bogus value.
2021 To work around these problems, we replace e->pdr.adr with
2022 the start address of the function. */
2023 e
->pdr
.adr
= BLOCK_START (b
);
2026 /* It would be reasonable that functions that have been compiled
2027 without debugging info have a btNil type for their return value,
2028 and functions that are void and are compiled with debugging info
2030 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2031 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2033 The glevel field in cur_fdr could be used to determine the presence
2034 of debugging info, but GCC doesn't always pass the -g switch settings
2035 to the assembler and GAS doesn't set the glevel field from the -g switch
2037 To work around these problems, the return value type of a TYPE_CODE_VOID
2038 function is adjusted accordingly if no debugging info was found in the
2039 compilation unit. */
2041 if (processing_gcc_compilation
== 0
2042 && found_ecoff_debugging_info
== 0
2043 && TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))->code () == TYPE_CODE_VOID
)
2044 SYMBOL_TYPE (s
) = objfile_type (mdebugread_objfile
)->nodebug_text_symbol
;
2047 /* Parse the external symbol ES. Just call parse_symbol() after
2048 making sure we know where the aux are for it.
2049 BIGEND says whether aux entries are big-endian or little-endian.
2051 This routine clobbers top_stack->cur_block and ->cur_st. */
2054 parse_external (EXTR
*es
, int bigend
, const section_offsets
§ion_offsets
,
2055 struct objfile
*objfile
)
2059 if (es
->ifd
!= ifdNil
)
2062 cur_fdr
= debug_info
->fdr
+ cur_fd
;
2063 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
2067 cur_fdr
= debug_info
->fdr
;
2071 /* Reading .o files */
2072 if (SC_IS_UNDEF (es
->asym
.sc
) || es
->asym
.sc
== scNil
)
2075 switch (es
->asym
.st
)
2078 /* These are generated for static symbols in .o files,
2099 /* FIXME: Turn this into a complaint? */
2101 printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
2102 what
, debug_info
->ssext
+ es
->asym
.iss
,
2103 fdr_name (cur_fdr
));
2107 switch (es
->asym
.st
)
2111 /* There is no need to parse the external procedure symbols.
2112 If they are from objects compiled without -g, their index will
2113 be indexNil, and the symbol definition from the minimal symbol
2114 is preferrable (yielding a function returning int instead of int).
2115 If the index points to a local procedure symbol, the local
2116 symbol already provides the correct type.
2117 Note that the index of the external procedure symbol points
2118 to the local procedure symbol in the local symbol table, and
2119 _not_ to the auxiliary symbol info. */
2123 /* Global common symbols are resolved by the runtime loader,
2125 if (SC_IS_COMMON (es
->asym
.sc
))
2128 /* Note that the case of a symbol with indexNil must be handled
2129 anyways by parse_symbol(). */
2130 parse_symbol (&es
->asym
, ax
, NULL
,
2131 bigend
, section_offsets
, objfile
);
2138 /* Parse the line number info for file descriptor FH into
2139 GDB's linetable LT. MIPS' encoding requires a little bit
2140 of magic to get things out. Note also that MIPS' line
2141 numbers can go back and forth, apparently we can live
2142 with that and do not need to reorder our linetables. */
2145 parse_lines (FDR
*fh
, PDR
*pr
, struct linetable
*lt
, int maxlines
,
2146 CORE_ADDR textlow
, CORE_ADDR lowest_pdr_addr
)
2148 unsigned char *base
;
2150 int delta
, count
, lineno
= 0;
2152 if (fh
->cbLine
== 0)
2155 /* Scan by procedure descriptors. */
2157 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2161 unsigned char *halt
;
2163 /* No code for this one. */
2164 if (pr
->iline
== ilineNil
||
2165 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2168 /* Determine start and end address of compressed line bytes for
2170 base
= debug_info
->line
+ fh
->cbLineOffset
;
2171 if (j
!= (fh
->cpd
- 1))
2172 halt
= base
+ pr
[1].cbLineOffset
;
2174 halt
= base
+ fh
->cbLine
;
2175 base
+= pr
->cbLineOffset
;
2177 adr
= textlow
+ pr
->adr
- lowest_pdr_addr
;
2179 l
= adr
>> 2; /* in words */
2180 for (lineno
= pr
->lnLow
; base
< halt
;)
2182 count
= *base
& 0x0f;
2183 delta
= *base
++ >> 4;
2188 delta
= (base
[0] << 8) | base
[1];
2189 if (delta
>= 0x8000)
2193 lineno
+= delta
; /* first delta is 0 */
2195 /* Complain if the line table overflows. Could happen
2196 with corrupt binaries. */
2197 if (lt
->nitems
>= maxlines
)
2199 complaint (_("guessed size of linetable for %s incorrectly"),
2203 k
= add_line (lt
, lineno
, l
, k
);
2210 function_outside_compilation_unit_complaint (const char *arg1
)
2212 complaint (_("function `%s' appears to be defined "
2213 "outside of all compilation units"),
2217 /* Use the STORAGE_CLASS to compute which section the given symbol
2218 belongs to, and then records this new minimal symbol. */
2221 record_minimal_symbol (minimal_symbol_reader
&reader
,
2222 const char *name
, const CORE_ADDR address
,
2223 enum minimal_symbol_type ms_type
, int storage_class
,
2224 struct objfile
*objfile
)
2228 switch (storage_class
)
2231 section
= SECT_OFF_TEXT (objfile
);
2234 section
= SECT_OFF_DATA (objfile
);
2237 section
= SECT_OFF_BSS (objfile
);
2240 section
= get_section_index (objfile
, ".sdata");
2243 section
= get_section_index (objfile
, ".sbss");
2246 section
= get_section_index (objfile
, ".rdata");
2249 section
= get_section_index (objfile
, ".init");
2252 section
= get_section_index (objfile
, ".xdata");
2255 section
= get_section_index (objfile
, ".pdata");
2258 section
= get_section_index (objfile
, ".fini");
2261 section
= get_section_index (objfile
, ".rconst");
2265 section
= get_section_index (objfile
, ".tlsdata");
2270 section
= get_section_index (objfile
, ".tlsbss");
2274 /* This kind of symbol is not associated to a section. */
2278 reader
.record_with_info (name
, address
, ms_type
, section
);
2281 /* Master parsing procedure for first-pass reading of file symbols
2282 into a partial_symtab. */
2285 parse_partial_symbols (minimal_symbol_reader
&reader
,
2286 psymtab_storage
*partial_symtabs
,
2287 struct objfile
*objfile
)
2289 struct gdbarch
*gdbarch
= objfile
->arch ();
2290 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2291 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2292 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2293 void (*const swap_ext_in
) (bfd
*, void *, EXTR
*) = debug_swap
->swap_ext_in
;
2294 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
2295 void (*const swap_rfd_in
) (bfd
*, void *, RFDT
*) = debug_swap
->swap_rfd_in
;
2297 HDRR
*hdr
= &debug_info
->symbolic_header
;
2298 /* Running pointers */
2305 legacy_psymtab
*pst
;
2306 int textlow_not_set
= 1;
2308 /* List of current psymtab's include files. */
2309 const char **psymtab_include_list
;
2310 int includes_allocated
;
2313 struct pst_map
*fdr_to_pst
;
2314 /* Index within current psymtab dependency list. */
2315 legacy_psymtab
**dependency_list
;
2316 int dependencies_used
, dependencies_allocated
;
2318 enum language prev_language
;
2319 asection
*text_sect
;
2320 int relocatable
= 0;
2322 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2323 the shared libraries are prelinked at a high memory address.
2324 We have to adjust the start address of the object file for this case,
2325 by setting it to the start address of the first procedure in the file.
2326 But we should do no adjustments if we are debugging a .o file, where
2327 the text section (and fh->adr) really starts at zero. */
2328 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2329 if (text_sect
!= NULL
2330 && (bfd_section_flags (text_sect
) & SEC_RELOC
))
2333 extern_tab
= XOBNEWVEC (&objfile
->objfile_obstack
, EXTR
, hdr
->iextMax
);
2335 includes_allocated
= 30;
2337 psymtab_include_list
= (const char **) alloca (includes_allocated
*
2338 sizeof (const char *));
2339 next_symbol_text_func
= mdebug_next_symbol_text
;
2341 dependencies_allocated
= 30;
2342 dependencies_used
= 0;
2344 (legacy_psymtab
**) alloca (dependencies_allocated
*
2345 sizeof (legacy_psymtab
*));
2347 set_last_source_file (NULL
);
2352 * Only parse the Local and External symbols, and the Relative FDR.
2353 * Fixup enough of the loader symtab to be able to use it.
2354 * Allocate space only for the file's portions we need to
2359 max_glevel
= MIN_GLEVEL
;
2361 /* Allocate the map FDR -> PST.
2362 Minor hack: -O3 images might claim some global data belongs
2363 to FDR -1. We`ll go along with that. */
2364 gdb::def_vector
<struct pst_map
> fdr_to_pst_holder (hdr
->ifdMax
+ 1);
2365 fdr_to_pst
= fdr_to_pst_holder
.data ();
2368 legacy_psymtab
*new_pst
= new_psymtab ("", objfile
);
2370 fdr_to_pst
[-1].pst
= new_pst
;
2371 FDR_IDX (new_pst
) = -1;
2374 /* Allocate the global pending list. */
2375 pending_list
= XOBNEWVEC (&objfile
->objfile_obstack
, mdebug_pending
*,
2377 memset (pending_list
, 0,
2378 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2380 /* Pass 0 over external syms: swap them in. */
2381 gdb::def_vector
<EXTR
> ext_block (hdr
->iextMax
);
2383 ext_out
= (char *) debug_info
->external_ext
;
2384 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2385 ext_in
= ext_block
.data ();
2386 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2387 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2389 /* Pass 1 over external syms: Presize and partition the list. */
2390 ext_in
= ext_block
.data ();
2391 ext_in_end
= ext_in
+ hdr
->iextMax
;
2392 for (; ext_in
< ext_in_end
; ext_in
++)
2394 /* See calls to complain below. */
2395 if (ext_in
->ifd
>= -1
2396 && ext_in
->ifd
< hdr
->ifdMax
2397 && ext_in
->asym
.iss
>= 0
2398 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2399 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2402 /* Pass 1.5 over files: partition out global symbol space. */
2404 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2406 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2407 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2408 fdr_to_pst
[f_idx
].n_globals
= 0;
2413 For ECOFF in ELF, we skip the creation of the minimal symbols.
2414 The ECOFF symbols should be a subset of the Elf symbols, and the
2415 section information of the elf symbols will be more accurate.
2416 FIXME! What about Irix 5's native linker?
2418 By default, Elf sections which don't exist in ECOFF
2419 get put in ECOFF's absolute section by the gnu linker.
2420 Since absolute sections don't get relocated, we
2421 end up calculating an address different from that of
2422 the symbol's minimal symbol (created earlier from the
2425 To fix this, either :
2426 1) don't create the duplicate symbol
2427 (assumes ECOFF symtab is a subset of the ELF symtab;
2428 assumes no side-effects result from ignoring ECOFF symbol)
2429 2) create it, only if lookup for existing symbol in ELF's minimal
2432 assumes no side-effects result from ignoring ECOFF symbol)
2433 3) create it, but lookup ELF's minimal symbol and use it's section
2434 during relocation, then modify "uniquify" phase to merge and
2435 eliminate the duplicate symbol
2436 (highly inefficient)
2438 I've implemented #1 here...
2439 Skip the creation of the minimal symbols based on the ECOFF
2442 /* Pass 2 over external syms: fill in external symbols. */
2443 ext_in
= ext_block
.data ();
2444 ext_in_end
= ext_in
+ hdr
->iextMax
;
2445 for (; ext_in
< ext_in_end
; ext_in
++)
2447 enum minimal_symbol_type ms_type
= mst_text
;
2448 CORE_ADDR svalue
= ext_in
->asym
.value
;
2450 /* The Irix 5 native tools seem to sometimes generate bogus
2451 external symbols. */
2452 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2454 complaint (_("bad ifd for external symbol: %d (max %ld)"),
2455 ext_in
->ifd
, hdr
->ifdMax
);
2458 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2460 complaint (_("bad iss for external symbol: %ld (max %ld)"),
2461 ext_in
->asym
.iss
, hdr
->issExtMax
);
2465 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2466 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2469 if (SC_IS_UNDEF (ext_in
->asym
.sc
) || ext_in
->asym
.sc
== scNil
)
2473 /* Pass 3 over files, over local syms: fill in static symbols. */
2474 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2476 /* Process ECOFF Symbol Types and Storage Classes. */
2477 switch (ext_in
->asym
.st
)
2480 /* Beginnning of Procedure */
2483 /* Load time only static procs */
2484 ms_type
= mst_file_text
;
2487 /* External symbol */
2488 if (SC_IS_COMMON (ext_in
->asym
.sc
))
2490 /* The value of a common symbol is its size, not its address.
2494 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2498 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2502 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2512 /* On certain platforms, some extra label symbols can be
2513 generated by the linker. One possible usage for this kind
2514 of symbols is to represent the address of the begining of a
2515 given section. For instance, on Tru64 5.1, the address of
2516 the _ftext label is the start address of the .text section.
2518 The storage class of these symbols is usually directly
2519 related to the section to which the symbol refers. For
2520 instance, on Tru64 5.1, the storage class for the _fdata
2521 label is scData, refering to the .data section.
2523 It is actually possible that the section associated to the
2524 storage class of the label does not exist. On True64 5.1
2525 for instance, the libm.so shared library does not contain
2526 any .data section, although it contains a _fpdata label
2527 which storage class is scData... Since these symbols are
2528 usually useless for the debugger user anyway, we just
2529 discard these symbols. */
2531 if (SC_IS_TEXT (ext_in
->asym
.sc
))
2533 if (objfile
->sect_index_text
== -1)
2536 ms_type
= mst_file_text
;
2538 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2540 if (objfile
->sect_index_data
== -1)
2543 ms_type
= mst_file_data
;
2545 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2547 if (objfile
->sect_index_bss
== -1)
2550 ms_type
= mst_file_bss
;
2552 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2554 const int sbss_sect_index
= get_section_index (objfile
, ".sbss");
2556 if (sbss_sect_index
== -1)
2559 ms_type
= mst_file_bss
;
2566 /* The alpha has the section start addresses in stLocal symbols
2567 whose name starts with a `.'. Skip those but complain for all
2568 other stLocal symbols.
2569 Irix6 puts the section start addresses in stNil symbols, skip
2575 ms_type
= mst_unknown
;
2576 unknown_ext_complaint (name
);
2578 if (!ECOFF_IN_ELF (cur_bfd
))
2579 record_minimal_symbol (reader
, name
, svalue
, ms_type
, ext_in
->asym
.sc
,
2583 /* Pass 3 over files, over local syms: fill in static symbols. */
2584 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2586 legacy_psymtab
*save_pst
;
2590 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2594 fdr_to_pst
[f_idx
].pst
= NULL
;
2598 /* Determine the start address for this object file from the
2599 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2604 pst
= new legacy_psymtab (fdr_name (fh
), objfile
, textlow
);
2605 pst
->read_symtab_private
= XOBNEW (&objfile
->objfile_obstack
, symloc
);
2606 memset (pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2609 FDR_IDX (pst
) = f_idx
;
2610 CUR_BFD (pst
) = cur_bfd
;
2611 DEBUG_SWAP (pst
) = debug_swap
;
2612 DEBUG_INFO (pst
) = debug_info
;
2613 PENDING_LIST (pst
) = pending_list
;
2615 /* The way to turn this into a symtab is to call... */
2616 pst
->legacy_read_symtab
= mdebug_read_symtab
;
2617 pst
->legacy_expand_psymtab
= mdebug_expand_psymtab
;
2619 /* Set up language for the pst.
2620 The language from the FDR is used if it is unambigious (e.g. cfront
2621 with native cc and g++ will set the language to C).
2622 Otherwise we have to deduce the language from the filename.
2623 Native ecoff has every header file in a separate FDR, so
2624 deduce_language_from_filename will return language_unknown for
2625 a header file, which is not what we want.
2626 But the FDRs for the header files are after the FDR for the source
2627 file, so we can assign the language of the source file to the
2628 following header files. Then we save the language in the private
2629 pst data so that we can reuse it when building symtabs. */
2630 prev_language
= psymtab_language
;
2634 case langCplusplusV2
:
2635 psymtab_language
= language_cplus
;
2638 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2641 if (psymtab_language
== language_unknown
)
2642 psymtab_language
= prev_language
;
2643 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2645 pst
->set_text_high (pst
->raw_text_low ());
2647 /* For stabs-in-ecoff files, the second symbol must be @stab.
2648 This symbol is emitted by mips-tfile to signal that the
2649 current object file uses encapsulated stabs instead of mips
2650 ecoff for local symbols. (It is the second symbol because
2651 the first symbol is the stFile used to signal the start of a
2653 processing_gcc_compilation
= 0;
2656 (*swap_sym_in
) (cur_bfd
,
2657 ((char *) debug_info
->external_sym
2658 + (fh
->isymBase
+ 1) * external_sym_size
),
2660 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2662 processing_gcc_compilation
= 2;
2665 if (processing_gcc_compilation
!= 0)
2667 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2670 const char *namestring
;
2672 (*swap_sym_in
) (cur_bfd
,
2673 (((char *) debug_info
->external_sym
)
2674 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2676 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2677 if (!ECOFF_IS_STAB (&sh
))
2679 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2684 if (sh
.st
== stStaticProc
)
2686 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2687 record_minimal_symbol (reader
, namestring
, sh
.value
,
2688 mst_file_text
, sh
.sc
,
2691 procaddr
= sh
.value
;
2693 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2694 (debug_info
->external_aux
2697 (*swap_sym_in
) (cur_bfd
,
2698 ((char *) debug_info
->external_sym
2699 + ((fh
->isymBase
+ isym
- 1)
2700 * external_sym_size
)),
2704 CORE_ADDR high
= procaddr
+ sh
.value
;
2706 /* Kludge for Irix 5.2 zero fh->adr. */
2708 && (!pst
->text_low_valid
2709 || procaddr
< pst
->raw_text_low ()))
2710 pst
->set_text_low (procaddr
);
2711 if (high
> pst
->raw_text_high ())
2712 pst
->set_text_high (high
);
2715 else if (sh
.st
== stStatic
)
2730 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2731 record_minimal_symbol (reader
, namestring
, sh
.value
,
2732 mst_file_data
, sh
.sc
,
2737 /* FIXME! Shouldn't this use cases for bss,
2738 then have the default be abs? */
2739 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2740 record_minimal_symbol (reader
, namestring
, sh
.value
,
2741 mst_file_bss
, sh
.sc
,
2748 /* Handle stabs continuation. */
2750 char *stabstring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2751 /* If we need to heap-allocate STABSTRING, this owns
2753 gdb::unique_xmalloc_ptr
<char> stabstring_storage
;
2754 int len
= strlen (stabstring
);
2756 while (stabstring
[len
- 1] == '\\')
2759 char *stabstring1
= stabstring
;
2763 /* Ignore continuation char from 1st string. */
2766 /* Read next stabstring. */
2768 (*swap_sym_in
) (cur_bfd
,
2769 (((char *) debug_info
->external_sym
)
2770 + (fh
->isymBase
+ cur_sdx
)
2771 * external_sym_size
),
2773 stabstring2
= debug_info
->ss
+ fh
->issBase
+ sh2
.iss
;
2774 len2
= strlen (stabstring2
);
2776 /* Concatenate stabstring2 with stabstring1. */
2777 if (stabstring_storage
!= nullptr)
2779 stabstring_storage
.reset
2780 ((char *) xrealloc (stabstring_storage
.release (),
2782 stabstring
= stabstring_storage
.get ();
2786 stabstring_storage
.reset
2787 ((char *) xmalloc (len
+ len2
+ 1));
2788 stabstring
= stabstring_storage
.get ();
2789 strcpy (stabstring
, stabstring1
);
2791 strcpy (stabstring
+ len
, stabstring2
);
2799 /* Standard, external, non-debugger, symbols. */
2801 case N_TEXT
| N_EXT
:
2802 case N_NBTEXT
| N_EXT
:
2805 case N_DATA
| N_EXT
:
2806 case N_NBDATA
| N_EXT
:
2811 case N_NBBSS
| N_EXT
:
2812 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
2819 /* Standard, local, non-debugger, symbols. */
2823 /* We need to be able to deal with both N_FN or
2824 N_TEXT, because we have no way of knowing
2825 whether the sys-supplied ld or GNU ld was used
2826 to make the executable. Sequents throw in
2827 another wrinkle -- they renumbered N_FN. */
2837 case N_UNDF
| N_EXT
:
2838 continue; /* Just undefined, not COMMON. */
2843 /* Lots of symbol types we can just ignore. */
2850 /* Keep going . . . */
2853 * Special symbol types for GNU
2856 case N_INDR
| N_EXT
:
2858 case N_SETA
| N_EXT
:
2860 case N_SETT
| N_EXT
:
2862 case N_SETD
| N_EXT
:
2864 case N_SETB
| N_EXT
:
2874 static int prev_so_symnum
= -10;
2875 const char *basename
;
2877 /* A zero value is probably an indication for the
2878 SunPRO 3.0 compiler. dbx_end_psymtab explicitly tests
2879 for zero, so don't relocate it. */
2882 && gdbarch_sofun_address_maybe_missing (gdbarch
))
2883 textlow_not_set
= 1;
2885 textlow_not_set
= 0;
2887 if (prev_so_symnum
!= symnum
- 1)
2888 { /* Here if prev stab wasn't N_SO. */
2891 pst
= (legacy_psymtab
*) 0;
2893 dependencies_used
= 0;
2897 prev_so_symnum
= symnum
;
2899 /* End the current partial symtab and start a
2902 /* SET_NAMESTRING ();*/
2903 namestring
= stabstring
;
2905 /* Null name means end of .o file. Don't start a new
2907 if (*namestring
== '\000')
2910 /* Some compilers (including gcc) emit a pair of
2911 initial N_SOs. The first one is a directory name;
2912 the second the file name. If pst exists, is
2913 empty, and has a filename ending in '/', we assume
2914 the previous N_SO was a directory name. */
2915 basename
= lbasename (namestring
);
2916 if (basename
!= namestring
&& *basename
== '\000')
2917 continue; /* Simply ignore directory
2920 /* Some other compilers (C++ ones in particular) emit
2921 useless SOs for non-existant .c files. We ignore
2922 all subsequent SOs that immediately follow the
2935 enum language tmp_language
;
2937 /* Mark down an include file in the current psymtab. */
2939 /* SET_NAMESTRING (); */
2940 namestring
= stabstring
;
2943 = deduce_language_from_filename (namestring
);
2945 /* Only change the psymtab's language if we've
2946 learned something useful (eg. tmp_language is not
2947 language_unknown). In addition, to match what
2948 start_subfile does, never change from C++ to
2950 if (tmp_language
!= language_unknown
2951 && (tmp_language
!= language_c
2952 || psymtab_language
!= language_cplus
))
2953 psymtab_language
= tmp_language
;
2955 /* In C++, one may expect the same filename to come
2956 round many times, when code is coming alternately
2957 from the main file and from inline functions in
2958 other files. So I check to see if this is a file
2959 we've seen before -- either the main source file,
2960 or a previously included file.
2962 This seems to be a lot of time to be spending on
2963 N_SOL, but things like "break c-exp.y:435" need to
2964 work (I suppose the psymtab_include_list could be
2965 hashed or put in a binary tree, if profiling shows
2966 this is a major hog). */
2967 if (pst
&& filename_cmp (namestring
, pst
->filename
) == 0)
2973 for (i
= 0; i
< includes_used
; i
++)
2974 if (filename_cmp (namestring
,
2975 psymtab_include_list
[i
]) == 0)
2984 psymtab_include_list
[includes_used
++] = namestring
;
2985 if (includes_used
>= includes_allocated
)
2987 const char **orig
= psymtab_include_list
;
2989 psymtab_include_list
= (const char **)
2990 alloca ((includes_allocated
*= 2) *
2991 sizeof (const char *));
2992 memcpy (psymtab_include_list
, orig
,
2993 includes_used
* sizeof (const char *));
2997 case N_LSYM
: /* Typedef or automatic variable. */
2998 case N_STSYM
: /* Data seg var -- static */
2999 case N_LCSYM
: /* BSS " */
3000 case N_ROSYM
: /* Read-only data seg var -- static. */
3001 case N_NBSTS
: /* Gould nobase. */
3002 case N_NBLCS
: /* symbols. */
3004 case N_GSYM
: /* Global (extern) variable; can be
3005 data or bss (sigh FIXME). */
3007 /* Following may probably be ignored; I'll leave them here
3008 for now (until I do Pascal and Modula 2 extensions). */
3010 case N_PC
: /* I may or may not need this; I
3012 case N_M2C
: /* I suspect that I can ignore this
3014 case N_SCOPE
: /* Same. */
3016 /* SET_NAMESTRING (); */
3017 namestring
= stabstring
;
3018 p
= (char *) strchr (namestring
, ':');
3020 continue; /* Not a debugging symbol. */
3024 /* Main processing section for debugging symbols which
3025 the initial read through the symbol tables needs to
3026 worry about. If we reach this point, the symbol
3027 which we are considering is definitely one we are
3028 interested in. p must also contain the (valid)
3029 index into the namestring which indicates the
3030 debugging type symbol. */
3035 pst
->add_psymbol (gdb::string_view (namestring
,
3037 true, VAR_DOMAIN
, LOC_STATIC
,
3038 SECT_OFF_DATA (objfile
),
3039 psymbol_placement::STATIC
,
3041 psymtab_language
, objfile
);
3044 /* The addresses in these entries are reported
3045 to be wrong. See the code that reads 'G's
3047 pst
->add_psymbol (gdb::string_view (namestring
,
3049 true, VAR_DOMAIN
, LOC_STATIC
,
3050 SECT_OFF_DATA (objfile
),
3051 psymbol_placement::GLOBAL
,
3053 psymtab_language
, objfile
);
3057 /* When a 'T' entry is defining an anonymous enum, it
3058 may have a name which is the empty string, or a
3059 single space. Since they're not really defining a
3060 symbol, those shouldn't go in the partial symbol
3061 table. We do pick up the elements of such enums at
3062 'check_enum:', below. */
3063 if (p
>= namestring
+ 2
3064 || (p
== namestring
+ 1
3065 && namestring
[0] != ' '))
3068 (gdb::string_view (namestring
, p
- namestring
),
3069 true, STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
3070 psymbol_placement::STATIC
, 0, psymtab_language
,
3074 /* Also a typedef with the same name. */
3076 (gdb::string_view (namestring
,
3078 true, VAR_DOMAIN
, LOC_TYPEDEF
, -1,
3079 psymbol_placement::STATIC
, 0,
3080 psymtab_language
, objfile
);
3086 if (p
!= namestring
) /* a name is there, not
3090 (gdb::string_view (namestring
,
3092 true, VAR_DOMAIN
, LOC_TYPEDEF
, -1,
3093 psymbol_placement::STATIC
, 0, psymtab_language
,
3097 /* If this is an enumerated type, we need to add
3098 all the enum constants to the partial symbol
3099 table. This does not cover enums without names,
3100 e.g. "enum {a, b} c;" in C, but fortunately
3101 those are rare. There is no way for GDB to find
3102 those from the enum type without spending too
3103 much time on it. Thus to solve this problem,
3104 the compiler needs to put out the enum in a
3105 nameless type. GCC2 does this. */
3107 /* We are looking for something of the form
3108 <name> ":" ("t" | "T") [<number> "="] "e"
3109 {<constant> ":" <value> ","} ";". */
3111 /* Skip over the colon and the 't' or 'T'. */
3113 /* This type may be given a number. Also, numbers
3114 can come in pairs like (0,26). Skip over it. */
3115 while ((*p
>= '0' && *p
<= '9')
3116 || *p
== '(' || *p
== ',' || *p
== ')'
3122 /* The aix4 compiler emits extra crud before
3126 /* Skip over the type (?). */
3130 /* Skip over the colon. */
3134 /* We have found an enumerated type. */
3135 /* According to comments in read_enum_type
3136 a comma could end it instead of a semicolon.
3137 I don't know where that happens.
3139 while (*p
&& *p
!= ';' && *p
!= ',')
3143 /* Check for and handle cretinous dbx
3144 symbol name continuation! */
3145 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
3146 p
= next_symbol_text (objfile
);
3148 /* Point to the character after the name
3149 of the enum constant. */
3150 for (q
= p
; *q
&& *q
!= ':'; q
++)
3152 /* Note that the value doesn't matter for
3153 enum constants in psymtabs, just in
3155 pst
->add_psymbol (gdb::string_view (p
,
3159 psymbol_placement::STATIC
,
3160 0, psymtab_language
,
3162 /* Point past the name. */
3164 /* Skip over the value. */
3165 while (*p
&& *p
!= ',')
3167 /* Advance past the comma. */
3174 /* Constant, e.g. from "const" in Pascal. */
3175 pst
->add_psymbol (gdb::string_view (namestring
,
3177 true, VAR_DOMAIN
, LOC_CONST
, -1,
3178 psymbol_placement::STATIC
,
3179 0, psymtab_language
, objfile
);
3185 std::string
copy (namestring
, p
);
3186 function_outside_compilation_unit_complaint
3189 pst
->add_psymbol (gdb::string_view (namestring
,
3191 true, VAR_DOMAIN
, LOC_BLOCK
,
3192 SECT_OFF_TEXT (objfile
),
3193 psymbol_placement::STATIC
,
3195 psymtab_language
, objfile
);
3198 /* Global functions were ignored here, but now they
3199 are put into the global psymtab like one would
3200 expect. They're also in the minimal symbol
3205 std::string
copy (namestring
, p
);
3206 function_outside_compilation_unit_complaint
3209 pst
->add_psymbol (gdb::string_view (namestring
,
3211 true, VAR_DOMAIN
, LOC_BLOCK
,
3212 SECT_OFF_TEXT (objfile
),
3213 psymbol_placement::GLOBAL
,
3215 psymtab_language
, objfile
);
3218 /* Two things show up here (hopefully); static
3219 symbols of local scope (static used inside
3220 braces) or extensions of structure symbols. We
3235 case '#': /* For symbol identification (used
3240 /* It is a C++ nested symbol. We don't need to
3241 record it (I don't think); if we try to look up
3242 foo::bar::baz, then symbols for the symtab
3243 containing foo should get read in, I think. */
3244 /* Someone says sun cc puts out symbols like
3245 /foo/baz/maclib::/usr/local/bin/maclib,
3246 which would get here with a symbol type of ':'. */
3250 /* Unexpected symbol descriptor. The second and
3251 subsequent stabs of a continued stab can show up
3252 here. The question is whether they ever can
3253 mimic a normal stab--it would be nice if not,
3254 since we certainly don't want to spend the time
3255 searching to the end of every string looking for
3258 complaint (_("unknown symbol descriptor `%c'"), p
[1]);
3260 /* Ignore it; perhaps it is an extension that we don't
3269 /* Solaris 2 end of module, finish current partial
3270 symbol table. dbx_end_psymtab will set the
3271 high text address of PST to the proper value,
3272 which is necessary if a module compiled without
3273 debugging info follows this module. */
3275 && gdbarch_sofun_address_maybe_missing (gdbarch
))
3277 pst
= (legacy_psymtab
*) 0;
3279 dependencies_used
= 0;
3284 if (sh
.value
> save_pst
->raw_text_high ())
3285 save_pst
->set_text_high (sh
.value
);
3290 case N_SSYM
: /* Claim: Structure or union
3291 element. Hopefully, I can
3293 case N_ENTRY
: /* Alternate entry point; can
3295 case N_MAIN
: /* Can definitely ignore this. */
3296 case N_CATCH
: /* These are GNU C++ extensions. */
3297 case N_EHDECL
: /* that can safely be ignored here. */
3307 case N_NSYMS
: /* Ultrix 4.0: symbol count */
3308 case N_DEFD
: /* GNU Modula-2 */
3309 case N_ALIAS
: /* SunPro F77: alias name, ignore
3312 case N_OBJ
: /* Useless types from Solaris. */
3314 /* These symbols aren't interesting; don't worry about
3320 /* If we haven't found it yet, ignore it. It's
3321 probably some new type we don't know about yet. */
3322 complaint (_("unknown symbol type %s"),
3323 hex_string (type_code
)); /* CUR_SYMBOL_TYPE */
3327 /* end - Handle continuation */
3332 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
3335 enum address_class theclass
;
3336 CORE_ADDR minsym_value
;
3339 (*swap_sym_in
) (cur_bfd
,
3340 ((char *) debug_info
->external_sym
3341 + ((fh
->isymBase
+ cur_sdx
)
3342 * external_sym_size
)),
3345 if (ECOFF_IS_STAB (&sh
))
3351 /* Non absolute static symbols go into the minimal table. */
3352 if (SC_IS_UNDEF (sh
.sc
) || sh
.sc
== scNil
3353 || (sh
.index
== indexNil
3354 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
3356 /* FIXME, premature? */
3361 sym_name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3363 minsym_value
= sh
.value
;
3369 /* The value of a stEnd symbol is the displacement from the
3370 corresponding start symbol value, do not relocate it. */
3372 section
= SECT_OFF_TEXT (objfile
);
3379 section
= SECT_OFF_DATA (objfile
);
3383 section
= SECT_OFF_BSS (objfile
);
3394 reader
.record_with_info (sym_name
, minsym_value
,
3396 SECT_OFF_TEXT (objfile
));
3401 /* Ignore all parameter symbol records. */
3402 if (sh
.index
>= hdr
->iauxMax
)
3404 /* Should not happen, but does when cross-compiling
3405 with the MIPS compiler. FIXME -- pull later. */
3406 index_complaint (sym_name
);
3407 new_sdx
= cur_sdx
+ 1; /* Don't skip at all. */
3410 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
3411 (debug_info
->external_aux
3415 if (new_sdx
<= cur_sdx
)
3417 /* This should not happen either... FIXME. */
3418 complaint (_("bad proc end in aux found from symbol %s"),
3420 new_sdx
= cur_sdx
+ 1; /* Don't skip backward. */
3423 /* For stProc symbol records, we need to check the
3424 storage class as well, as only (stProc, scText)
3425 entries represent "real" procedures - See the
3426 Compaq document titled "Object File / Symbol Table
3427 Format Specification" for more information. If the
3428 storage class is not scText, we discard the whole
3429 block of symbol records for this stProc. */
3430 if (sh
.st
== stProc
&& sh
.sc
!= scText
)
3433 /* Usually there is a local and a global stProc symbol
3434 for a function. This means that the function name
3435 has already been entered into the minimal symbol table
3436 while processing the global symbols in pass 2 above.
3437 One notable exception is the PROGRAM name from
3438 f77 compiled executables, it is only put out as
3439 local stProc symbol, and a global MAIN__ stProc symbol
3440 points to it. It doesn't matter though, as gdb is
3441 still able to find the PROGRAM name via the partial
3442 symbol table, and the MAIN__ symbol via the minimal
3444 if (sh
.st
== stProc
)
3445 pst
->add_psymbol (sym_name
, true,
3446 VAR_DOMAIN
, LOC_BLOCK
,
3448 psymbol_placement::GLOBAL
,
3449 sh
.value
, psymtab_language
, objfile
);
3451 pst
->add_psymbol (sym_name
, true,
3452 VAR_DOMAIN
, LOC_BLOCK
,
3454 psymbol_placement::STATIC
,
3455 sh
.value
, psymtab_language
, objfile
);
3457 procaddr
= sh
.value
;
3460 (*swap_sym_in
) (cur_bfd
,
3461 ((char *) debug_info
->external_sym
3462 + ((fh
->isymBase
+ cur_sdx
- 1)
3463 * external_sym_size
)),
3468 /* Kludge for Irix 5.2 zero fh->adr. */
3470 && (!pst
->text_low_valid
3471 || procaddr
< pst
->raw_text_low ()))
3472 pst
->set_text_low (procaddr
);
3474 high
= procaddr
+ sh
.value
;
3475 if (high
> pst
->raw_text_high ())
3476 pst
->set_text_high (high
);
3479 case stStatic
: /* Variable */
3480 if (SC_IS_DATA (sh
.sc
))
3481 reader
.record_with_info (sym_name
, minsym_value
,
3483 SECT_OFF_DATA (objfile
));
3485 reader
.record_with_info (sym_name
, minsym_value
,
3487 SECT_OFF_BSS (objfile
));
3488 theclass
= LOC_STATIC
;
3491 case stIndirect
: /* Irix5 forward declaration */
3492 /* Skip forward declarations from Irix5 cc. */
3495 case stTypedef
: /* Typedef */
3496 /* Skip typedefs for forward declarations and opaque
3497 structs from alpha and mips cc. */
3498 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
3500 theclass
= LOC_TYPEDEF
;
3503 case stConstant
: /* Constant decl */
3504 theclass
= LOC_CONST
;
3510 case stBlock
: /* { }, str, un, enum */
3511 /* Do not create a partial symbol for cc unnamed aggregates
3512 and gcc empty aggregates. */
3513 if ((sh
.sc
== scInfo
3514 || SC_IS_COMMON (sh
.sc
))
3516 && sh
.index
!= cur_sdx
+ 2)
3518 pst
->add_psymbol (sym_name
, true,
3519 STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
3520 psymbol_placement::STATIC
,
3521 0, psymtab_language
, objfile
);
3523 handle_psymbol_enumerators (objfile
, pst
, fh
,
3526 /* Skip over the block. */
3528 if (new_sdx
<= cur_sdx
)
3530 /* This happens with the Ultrix kernel. */
3531 complaint (_("bad aux index at block symbol %s"),
3533 new_sdx
= cur_sdx
+ 1; /* Don't skip backward. */
3538 case stFile
: /* File headers */
3539 case stLabel
: /* Labels */
3540 case stEnd
: /* Ends of files */
3543 case stLocal
: /* Local variables */
3544 /* Normally these are skipped because we skip over
3545 all blocks we see. However, these can occur
3546 as visible symbols in a .h file that contains code. */
3550 /* Both complaints are valid: one gives symbol sym_name,
3551 the other the offending symbol type. */
3552 complaint (_("unknown local symbol %s"),
3554 complaint (_("with type %d"), sh
.st
);
3558 /* Use this gdb symbol. */
3559 pst
->add_psymbol (sym_name
, true,
3560 VAR_DOMAIN
, theclass
, section
,
3561 psymbol_placement::STATIC
,
3562 sh
.value
, psymtab_language
, objfile
);
3564 cur_sdx
++; /* Go to next file symbol. */
3567 /* Now do enter the external symbols. */
3568 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
3569 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
3570 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
3571 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
3572 for (; --cur_sdx
>= 0; ext_ptr
++)
3574 enum address_class theclass
;
3579 gdb_assert (ext_ptr
->ifd
== f_idx
);
3581 psh
= &ext_ptr
->asym
;
3583 /* Do not add undefined symbols to the partial symbol table. */
3584 if (SC_IS_UNDEF (psh
->sc
) || psh
->sc
== scNil
)
3587 svalue
= psh
->value
;
3593 section
= SECT_OFF_TEXT (objfile
);
3600 section
= SECT_OFF_DATA (objfile
);
3604 section
= SECT_OFF_BSS (objfile
);
3611 /* These are generated for static symbols in .o files,
3616 /* External procedure symbols have been entered
3617 into the minimal symbol table in pass 2 above.
3618 Ignore them, as parse_external will ignore them too. */
3621 theclass
= LOC_LABEL
;
3624 unknown_ext_complaint (debug_info
->ssext
+ psh
->iss
);
3625 /* Pretend it's global. */
3628 /* Global common symbols are resolved by the runtime loader,
3630 if (SC_IS_COMMON (psh
->sc
))
3633 theclass
= LOC_STATIC
;
3636 char *sym_name
= debug_info
->ssext
+ psh
->iss
;
3637 pst
->add_psymbol (sym_name
, true,
3638 VAR_DOMAIN
, theclass
,
3640 psymbol_placement::GLOBAL
,
3641 svalue
, psymtab_language
, objfile
);
3645 /* Link pst to FDR. dbx_end_psymtab returns NULL if the psymtab was
3646 empty and put on the free list. */
3647 fdr_to_pst
[f_idx
].pst
3648 = dbx_end_psymtab (objfile
, partial_symtabs
, save_pst
,
3649 psymtab_include_list
, includes_used
,
3650 -1, save_pst
->raw_text_high (),
3651 dependency_list
, dependencies_used
,
3654 dependencies_used
= 0;
3656 /* The objfile has its functions reordered if this partial symbol
3657 table overlaps any other partial symbol table.
3658 We cannot assume a reordered objfile if a partial symbol table
3659 is contained within another partial symbol table, as partial symbol
3660 tables for include files with executable code are contained
3661 within the partial symbol table for the including source file,
3662 and we do not want to flag the objfile reordered for these cases.
3664 This strategy works well for Irix-5.2 shared libraries, but we
3665 might have to use a more elaborate (and slower) algorithm for
3667 save_pst
= fdr_to_pst
[f_idx
].pst
;
3668 if (save_pst
!= NULL
3669 && save_pst
->text_low_valid
3670 && !(objfile
->flags
& OBJF_REORDERED
))
3672 for (partial_symtab
*iter
: partial_symtabs
->range ())
3674 if (save_pst
!= iter
3675 && save_pst
->raw_text_low () >= iter
->raw_text_low ()
3676 && save_pst
->raw_text_low () < iter
->raw_text_high ()
3677 && save_pst
->raw_text_high () > iter
->raw_text_high ())
3679 objfile
->flags
|= OBJF_REORDERED
;
3686 /* Now scan the FDRs for dependencies. */
3687 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3689 fh
= f_idx
+ debug_info
->fdr
;
3690 pst
= fdr_to_pst
[f_idx
].pst
;
3695 /* This should catch stabs-in-ecoff. */
3699 /* Skip the first file indirect entry as it is a self dependency for
3700 source files or a reverse .h -> .c dependency for header files. */
3701 pst
->number_of_dependencies
= 0;
3703 = partial_symtabs
->allocate_dependencies (fh
->crfd
- 1);
3704 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3708 (*swap_rfd_in
) (cur_bfd
,
3709 ((char *) debug_info
->external_rfd
3710 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3712 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3714 complaint (_("bad file number %ld"), rh
);
3718 /* Skip self dependencies of header files. */
3722 /* Do not add to dependency list if psymtab was empty. */
3723 if (fdr_to_pst
[rh
].pst
== NULL
)
3725 pst
->dependencies
[pst
->number_of_dependencies
++]
3726 = fdr_to_pst
[rh
].pst
;
3730 /* Remove the dummy psymtab created for -O3 images above, if it is
3731 still empty, to enable the detection of stripped executables. */
3732 partial_symtab
*pst_del
= partial_symtabs
->psymtabs
;
3733 if (pst_del
->next
== NULL
3734 && pst_del
->number_of_dependencies
== 0
3735 && pst_del
->empty ())
3736 partial_symtabs
->discard_psymtab (pst_del
);
3739 /* If the current psymbol has an enumerated type, we need to add
3740 all the enum constants to the partial symbol table. */
3743 handle_psymbol_enumerators (struct objfile
*objfile
, partial_symtab
*pst
,
3744 FDR
*fh
, int stype
, CORE_ADDR svalue
)
3746 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3747 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
3748 char *ext_sym
= ((char *) debug_info
->external_sym
3749 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3759 /* It is an enumerated type if the next symbol entry is a stMember
3760 and its auxiliary index is indexNil or its auxiliary entry
3761 is a plain btNil or btVoid.
3762 Alpha cc -migrate enums are recognized by a zero index and
3763 a zero symbol value.
3764 DU 4.0 cc enums are recognized by a member type of btEnum without
3765 qualifiers and a zero symbol value. */
3766 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3767 if (sh
.st
!= stMember
)
3770 if (sh
.index
== indexNil
3771 || (sh
.index
== 0 && svalue
== 0))
3773 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3774 &(debug_info
->external_aux
3775 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3777 if ((tir
.bt
!= btNil
3779 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3780 || tir
.tq0
!= tqNil
)
3792 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3793 if (sh
.st
!= stMember
)
3795 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3797 /* Note that the value doesn't matter for enum constants
3798 in psymtabs, just in symtabs. */
3799 pst
->add_psymbol (name
, true,
3800 VAR_DOMAIN
, LOC_CONST
, -1,
3801 psymbol_placement::STATIC
, 0,
3802 psymtab_language
, objfile
);
3803 ext_sym
+= external_sym_size
;
3807 /* Get the next symbol. OBJFILE is unused. */
3810 mdebug_next_symbol_text (struct objfile
*objfile
)
3815 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3816 ((char *) debug_info
->external_sym
3817 + ((cur_fdr
->isymBase
+ cur_sdx
)
3818 * debug_swap
->external_sym_size
)),
3820 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3823 /* Ancillary function to psymtab_to_symtab(). Does all the work
3824 for turning the partial symtab PST into a symtab, recurring
3825 first on all dependent psymtabs. The argument FILENAME is
3826 only passed so we can see in debug stack traces what file
3829 This function has a split personality, based on whether the
3830 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3831 The flow of control and even the memory allocation differs. FIXME. */
3834 mdebug_expand_psymtab (legacy_psymtab
*pst
, struct objfile
*objfile
)
3836 bfd_size_type external_sym_size
;
3837 bfd_size_type external_pdr_size
;
3838 void (*swap_sym_in
) (bfd
*, void *, SYMR
*);
3839 void (*swap_pdr_in
) (bfd
*, void *, PDR
*);
3841 struct compunit_symtab
*cust
= NULL
;
3843 struct linetable
*lines
;
3844 CORE_ADDR lowest_pdr_addr
= 0;
3845 int last_symtab_ended
= 0;
3846 const section_offsets
§ion_offsets
= objfile
->section_offsets
;
3852 /* Read in all partial symtabs on which this one is dependent.
3853 NOTE that we do have circular dependencies, sigh. We solved
3854 that by setting pst->readin before this point. */
3855 pst
->expand_dependencies (objfile
);
3857 /* Do nothing if this is a dummy psymtab. */
3859 if (pst
->empty () && !pst
->text_low_valid
&& !pst
->text_high_valid
)
3862 /* Now read the symbols for this symtab. */
3864 cur_bfd
= CUR_BFD (pst
);
3865 debug_swap
= DEBUG_SWAP (pst
);
3866 debug_info
= DEBUG_INFO (pst
);
3867 pending_list
= PENDING_LIST (pst
);
3868 external_sym_size
= debug_swap
->external_sym_size
;
3869 external_pdr_size
= debug_swap
->external_pdr_size
;
3870 swap_sym_in
= debug_swap
->swap_sym_in
;
3871 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3872 mdebugread_objfile
= objfile
;
3873 cur_fd
= FDR_IDX (pst
);
3874 fh
= ((cur_fd
== -1)
3876 : debug_info
->fdr
+ cur_fd
);
3879 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3880 processing_gcc_compilation
= 0;
3881 if (fh
!= NULL
&& fh
->csym
>= 2)
3885 (*swap_sym_in
) (cur_bfd
,
3886 ((char *) debug_info
->external_sym
3887 + (fh
->isymBase
+ 1) * external_sym_size
),
3889 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3892 /* We indicate that this is a GCC compilation so that certain
3893 features will be enabled in stabsread/dbxread. */
3894 processing_gcc_compilation
= 2;
3898 if (processing_gcc_compilation
!= 0)
3900 struct gdbarch
*gdbarch
= objfile
->arch ();
3902 /* This symbol table contains stabs-in-ecoff entries. */
3904 /* Parse local symbols first. */
3906 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr. */
3908 mdebugread_objfile
= NULL
;
3911 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3917 (*swap_sym_in
) (cur_bfd
,
3918 (((char *) debug_info
->external_sym
)
3919 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3921 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3923 /* XXX This is a hack. It will go away! */
3924 if (ECOFF_IS_STAB (&sh
) || (name
[0] == '#'))
3926 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3927 enum language language
= PST_PRIVATE (pst
)->pst_language
;
3929 /* We should never get non N_STAB symbols here, but they
3930 should be harmless, so keep process_one_symbol from
3931 complaining about them. */
3932 if (type_code
& N_STAB
)
3934 /* If we found a trailing N_SO with no name, process
3935 it here instead of in process_one_symbol, so we
3936 can keep a handle to its symtab. The symtab
3937 would otherwise be ended twice, once in
3938 process_one_symbol, and once after this loop. */
3939 if (type_code
== N_SO
3940 && get_last_source_file ()
3941 && previous_stab_code
!= (unsigned char) N_SO
3944 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
3945 previous_stab_code
= N_SO
;
3946 cust
= end_symtab (valu
, SECT_OFF_TEXT (objfile
));
3948 last_symtab_ended
= 1;
3952 last_symtab_ended
= 0;
3953 process_one_symbol (type_code
, 0, valu
, name
,
3954 section_offsets
, objfile
, language
);
3957 /* Similarly a hack. */
3958 else if (name
[0] == '#')
3960 process_one_symbol (N_SLINE
, 0, valu
, name
,
3961 section_offsets
, objfile
, language
);
3963 if (type_code
== N_FUN
)
3965 /* Make up special symbol to contain
3966 procedure specific info. */
3967 mdebug_extra_func_info
*e
3968 = OBSTACK_ZALLOC (&mdebugread_objfile
->objfile_obstack
,
3969 mdebug_extra_func_info
);
3970 struct symbol
*s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
3972 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
3973 SYMBOL_ACLASS_INDEX (s
) = LOC_CONST
;
3974 SYMBOL_TYPE (s
) = objfile_type (objfile
)->builtin_void
;
3975 SYMBOL_VALUE_BYTES (s
) = (gdb_byte
*) e
;
3976 e
->pdr
.framereg
= -1;
3977 add_symbol_to_list (s
, get_local_symbols ());
3980 else if (sh
.st
== stLabel
)
3982 if (sh
.index
== indexNil
)
3984 /* This is what the gcc2_compiled and __gnu_compiled_*
3985 show up as. So don't complain. */
3990 /* Handle encoded stab line number. */
3991 valu
+= section_offsets
[SECT_OFF_TEXT (objfile
)];
3992 record_line (get_current_subfile (), sh
.index
,
3993 gdbarch_addr_bits_remove (gdbarch
, valu
));
3996 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3997 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3998 /* These are generated by gcc-2.x, do not complain. */
4001 complaint (_("unknown stabs symbol %s"), name
);
4004 if (! last_symtab_ended
)
4006 cust
= end_symtab (pst
->raw_text_high (), SECT_OFF_TEXT (objfile
));
4010 /* There used to be a call to sort_blocks here, but this should not
4011 be necessary for stabs symtabs. And as sort_blocks modifies the
4012 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
4013 it did the wrong thing if the first procedure in a file was
4014 generated via asm statements. */
4016 /* Fill in procedure info next. */
4024 gdb::def_vector
<PDR
> pr_block (fh
->cpd
);
4026 pdr_ptr
= ((char *) debug_info
->external_pdr
4027 + fh
->ipdFirst
* external_pdr_size
);
4028 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4029 pdr_in
= pr_block
.data ();
4032 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4034 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4036 /* Determine lowest PDR address, the PDRs are not always
4038 if (pdr_in
== pr_block
.data ())
4039 lowest_pdr_addr
= pdr_in
->adr
;
4040 else if (pdr_in
->adr
< lowest_pdr_addr
)
4041 lowest_pdr_addr
= pdr_in
->adr
;
4044 pdr_in
= pr_block
.data ();
4045 pdr_in_end
= pdr_in
+ fh
->cpd
;
4046 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4047 parse_procedure (pdr_in
, cust
, pst
);
4052 /* This symbol table contains ordinary ecoff entries. */
4060 cust
= new_symtab ("unknown", 0, objfile
);
4064 maxlines
= 2 * fh
->cline
;
4065 cust
= new_symtab (pst
->filename
, maxlines
, objfile
);
4067 /* The proper language was already determined when building
4068 the psymtab, use it. */
4069 COMPUNIT_FILETABS (cust
)->language
= PST_PRIVATE (pst
)->pst_language
;
4072 psymtab_language
= COMPUNIT_FILETABS (cust
)->language
;
4074 lines
= SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
));
4076 /* Get a new lexical context. */
4078 push_parse_stack ();
4079 top_stack
->cur_st
= COMPUNIT_FILETABS (cust
);
4080 top_stack
->cur_block
4081 = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), STATIC_BLOCK
);
4082 BLOCK_START (top_stack
->cur_block
) = pst
->text_low (objfile
);
4083 BLOCK_END (top_stack
->cur_block
) = 0;
4084 top_stack
->blocktype
= stFile
;
4085 top_stack
->cur_type
= 0;
4086 top_stack
->procadr
= 0;
4087 top_stack
->numargs
= 0;
4088 found_ecoff_debugging_info
= 0;
4095 /* Parse local symbols first. */
4096 sym_ptr
= ((char *) debug_info
->external_sym
4097 + fh
->isymBase
* external_sym_size
);
4098 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
4099 while (sym_ptr
< sym_end
)
4104 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
4105 c
= parse_symbol (&sh
,
4106 debug_info
->external_aux
+ fh
->iauxBase
,
4107 sym_ptr
, fh
->fBigendian
,
4108 section_offsets
, objfile
);
4109 sym_ptr
+= c
* external_sym_size
;
4112 /* Linenumbers. At the end, check if we can save memory.
4113 parse_lines has to look ahead an arbitrary number of PDR
4114 structures, so we swap them all first. */
4122 gdb::def_vector
<PDR
> pr_block (fh
->cpd
);
4124 pdr_ptr
= ((char *) debug_info
->external_pdr
4125 + fh
->ipdFirst
* external_pdr_size
);
4126 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4127 pdr_in
= pr_block
.data ();
4130 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4132 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4134 /* Determine lowest PDR address, the PDRs are not always
4136 if (pdr_in
== pr_block
.data ())
4137 lowest_pdr_addr
= pdr_in
->adr
;
4138 else if (pdr_in
->adr
< lowest_pdr_addr
)
4139 lowest_pdr_addr
= pdr_in
->adr
;
4142 parse_lines (fh
, pr_block
.data (), lines
, maxlines
,
4143 pst
->text_low (objfile
), lowest_pdr_addr
);
4144 if (lines
->nitems
< fh
->cline
)
4145 lines
= shrink_linetable (lines
);
4147 /* Fill in procedure info next. */
4148 pdr_in
= pr_block
.data ();
4149 pdr_in_end
= pdr_in
+ fh
->cpd
;
4150 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4151 parse_procedure (pdr_in
, NULL
, pst
);
4155 size
= lines
->nitems
;
4158 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
4159 = ((struct linetable
*)
4160 obstack_copy (&mdebugread_objfile
->objfile_obstack
,
4161 lines
, (sizeof (struct linetable
)
4162 + size
* sizeof (lines
->item
))));
4165 /* .. and our share of externals.
4166 XXX use the global list to speed up things here. How?
4167 FIXME, Maybe quit once we have found the right number of ext's? */
4168 top_stack
->cur_st
= COMPUNIT_FILETABS (cust
);
4169 top_stack
->cur_block
4170 = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack
->cur_st
),
4172 top_stack
->blocktype
= stFile
;
4174 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
4175 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
4176 parse_external (ext_ptr
, fh
->fBigendian
,
4177 section_offsets
, objfile
);
4179 /* If there are undefined symbols, tell the user.
4180 The alpha has an undefined symbol for every symbol that is
4181 from a shared library, so tell the user only if verbose is on. */
4182 if (info_verbose
&& n_undef_symbols
)
4184 printf_filtered (_("File %s contains %d unresolved references:"),
4185 symtab_to_filename_for_display
4186 (COMPUNIT_FILETABS (cust
)),
4188 printf_filtered ("\n\t%4d variables\n\t%4d "
4189 "procedures\n\t%4d labels\n",
4190 n_undef_vars
, n_undef_procs
, n_undef_labels
);
4191 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
4196 sort_blocks (COMPUNIT_FILETABS (cust
));
4199 /* Now link the psymtab and the symtab. */
4200 pst
->compunit_symtab
= cust
;
4202 mdebugread_objfile
= NULL
;
4205 /* Ancillary parsing procedures. */
4207 /* Return 1 if the symbol pointed to by SH has a cross reference
4208 to an opaque aggregate type, else 0. */
4211 has_opaque_xref (FDR
*fh
, SYMR
*sh
)
4218 if (sh
->index
== indexNil
)
4221 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
4222 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
4223 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
4227 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
4228 if (rn
->rfd
== 0xfff)
4229 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
4237 /* Lookup the type at relative index RN. Return it in TPP
4238 if found and in any event come up with its name PNAME.
4239 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4240 Return value says how many aux symbols we ate. */
4243 cross_ref (int fd
, union aux_ext
*ax
, struct type
**tpp
,
4244 enum type_code type_code
,
4245 /* Use to alloc new type if none is found. */
4246 const char **pname
, int bigend
, const char *sym_name
)
4255 struct mdebug_pending
*pend
;
4259 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
4261 /* Escape index means 'the next one'. */
4262 if (rn
->rfd
== 0xfff)
4265 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
4272 /* mips cc uses a rf of -1 for opaque struct definitions.
4273 Set TYPE_STUB for these types so that check_typedef will
4274 resolve them if the struct gets defined in another compilation unit. */
4277 *pname
= "<undefined>";
4278 *tpp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
4279 (*tpp
)->set_is_stub (true);
4283 /* mips cc uses an escaped rn->index of 0 for struct return types
4284 of procedures that were compiled without -g. These will always remain
4286 if (rn
->rfd
== 0xfff && rn
->index
== 0)
4288 *pname
= "<undefined>";
4292 /* Find the relative file descriptor and the symbol in it. */
4293 fh
= get_rfd (fd
, rf
);
4294 xref_fd
= fh
- debug_info
->fdr
;
4296 if (rn
->index
>= fh
->csym
)
4298 /* File indirect entry is corrupt. */
4299 *pname
= "<illegal>";
4300 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4304 /* If we have processed this symbol then we left a forwarding
4305 pointer to the type in the pending list. If not, we`ll put
4306 it in a list of pending types, to be processed later when
4307 the file will be. In any event, we collect the name for the
4310 esh
= ((char *) debug_info
->external_sym
4311 + ((fh
->isymBase
+ rn
->index
)
4312 * debug_swap
->external_sym_size
));
4313 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
4315 /* Make sure that this type of cross reference can be handled. */
4316 if ((sh
.sc
!= scInfo
4317 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
4318 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
4319 && sh
.st
!= stEnum
))
4320 && (sh
.st
!= stBlock
|| !SC_IS_COMMON (sh
.sc
)))
4322 /* File indirect entry is corrupt. */
4323 *pname
= "<illegal>";
4324 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4328 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4330 pend
= is_pending_symbol (fh
, esh
);
4335 /* We have not yet seen this type. */
4337 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
4341 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4343 a) forward declarations of structs/unions/enums which are not
4344 defined in this compilation unit.
4345 For these the type will be void. This is a bad design decision
4346 as cross referencing across compilation units is impossible
4347 due to the missing name.
4348 b) forward declarations of structs/unions/enums/typedefs which
4349 are defined later in this file or in another file in the same
4350 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4351 Simply cross reference those again to get the true type.
4352 The forward references are not entered in the pending list and
4353 in the symbol table. */
4355 (*debug_swap
->swap_tir_in
) (bigend
,
4356 &(debug_info
->external_aux
4357 + fh
->iauxBase
+ sh
.index
)->a_ti
,
4359 if (tir
.tq0
!= tqNil
)
4360 complaint (_("illegal tq0 in forward typedef for %s"), sym_name
);
4364 *tpp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
4365 *pname
= "<undefined>";
4372 (debug_info
->external_aux
4373 + fh
->iauxBase
+ sh
.index
+ 1),
4374 tpp
, type_code
, pname
,
4375 fh
->fBigendian
, sym_name
);
4379 /* Follow a forward typedef. This might recursively
4380 call cross_ref till we get a non typedef'ed type.
4381 FIXME: This is not correct behaviour, but gdb currently
4382 cannot handle typedefs without type copying. Type
4383 copying is impossible as we might have mutual forward
4384 references between two files and the copied type would not
4385 get filled in when we later parse its definition. */
4386 *tpp
= parse_type (xref_fd
,
4387 debug_info
->external_aux
+ fh
->iauxBase
,
4391 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4392 add_pending (fh
, esh
, *tpp
);
4396 complaint (_("illegal bt %d in forward typedef for %s"), tir
.bt
,
4398 *tpp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
4403 else if (sh
.st
== stTypedef
)
4405 /* Parse the type for a normal typedef. This might recursively call
4406 cross_ref till we get a non typedef'ed type.
4407 FIXME: This is not correct behaviour, but gdb currently
4408 cannot handle typedefs without type copying. But type copying is
4409 impossible as we might have mutual forward references between
4410 two files and the copied type would not get filled in when
4411 we later parse its definition. */
4412 *tpp
= parse_type (xref_fd
,
4413 debug_info
->external_aux
+ fh
->iauxBase
,
4417 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4421 /* Cross reference to a struct/union/enum which is defined
4422 in another file in the same compilation unit but that file
4423 has not been parsed yet.
4424 Initialize the type only, it will be filled in when
4425 it's definition is parsed. */
4426 *tpp
= init_type (mdebugread_objfile
, type_code
, 0, NULL
);
4428 add_pending (fh
, esh
, *tpp
);
4431 /* We used one auxent normally, two if we got a "next one" rf. */
4436 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4437 keeping the symtab sorted. */
4439 static struct symbol
*
4440 mylookup_symbol (const char *name
, const struct block
*block
,
4441 domain_enum domain
, enum address_class theclass
)
4443 struct block_iterator iter
;
4448 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
4450 if (sym
->linkage_name ()[0] == inc
4451 && SYMBOL_DOMAIN (sym
) == domain
4452 && SYMBOL_CLASS (sym
) == theclass
4453 && strcmp (sym
->linkage_name (), name
) == 0)
4457 block
= BLOCK_SUPERBLOCK (block
);
4459 return mylookup_symbol (name
, block
, domain
, theclass
);
4464 /* Add a new symbol S to a block B. */
4467 add_symbol (struct symbol
*s
, struct symtab
*symtab
, struct block
*b
)
4469 symbol_set_symtab (s
, symtab
);
4470 mdict_add_symbol (BLOCK_MULTIDICT (b
), s
);
4473 /* Add a new block B to a symtab S. */
4476 add_block (struct block
*b
, struct symtab
*s
)
4478 /* Cast away "const", but that's ok because we're building the
4479 symtab and blockvector here. */
4480 struct blockvector
*bv
= (struct blockvector
*) SYMTAB_BLOCKVECTOR (s
);
4482 bv
= (struct blockvector
*) xrealloc ((void *) bv
,
4483 (sizeof (struct blockvector
)
4484 + BLOCKVECTOR_NBLOCKS (bv
)
4485 * sizeof (bv
->block
)));
4486 if (bv
!= SYMTAB_BLOCKVECTOR (s
))
4487 SYMTAB_BLOCKVECTOR (s
) = bv
;
4489 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
4492 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4493 MIPS' linenumber encoding might need more than one byte
4494 to describe it, LAST is used to detect these continuation lines.
4496 Combining lines with the same line number seems like a bad idea.
4497 E.g: There could be a line number entry with the same line number after the
4498 prologue and GDB should not ignore it (this is a better way to find
4499 a prologue than mips_skip_prologue).
4500 But due to the compressed line table format there are line number entries
4501 for the same line which are needed to bridge the gap to the next
4502 line number entry. These entries have a bogus address info with them
4503 and we are unable to tell them from intended duplicate line number
4505 This is another reason why -ggdb debugging format is preferable. */
4508 add_line (struct linetable
*lt
, int lineno
, CORE_ADDR adr
, int last
)
4510 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4511 Change them to something sensible. */
4515 last
= -2; /* Make sure we record first line. */
4517 if (last
== lineno
) /* Skip continuation lines. */
4520 lt
->item
[lt
->nitems
].line
= lineno
;
4521 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
4525 /* Sorting and reordering procedures. */
4527 /* Blocks with a smaller low bound should come first. */
4530 block_is_less_than (const struct block
*b1
, const struct block
*b2
)
4532 CORE_ADDR start1
= BLOCK_START (b1
);
4533 CORE_ADDR start2
= BLOCK_START (b2
);
4535 if (start1
!= start2
)
4536 return start1
< start2
;
4538 return (BLOCK_END (b2
)) < (BLOCK_END (b1
));
4541 /* Sort the blocks of a symtab S.
4542 Reorder the blocks in the blockvector by code-address,
4543 as required by some MI search routines. */
4546 sort_blocks (struct symtab
*s
)
4548 /* We have to cast away const here, but this is ok because we're
4549 constructing the blockvector in this code. */
4550 struct blockvector
*bv
= (struct blockvector
*) SYMTAB_BLOCKVECTOR (s
);
4552 if (BLOCKVECTOR_NBLOCKS (bv
) <= FIRST_LOCAL_BLOCK
)
4555 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
4556 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
4557 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
4558 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
4562 * This is very unfortunate: normally all functions are compiled in
4563 * the order they are found, but if the file is compiled -O3 things
4564 * are very different. It would be nice to find a reliable test
4565 * to detect -O3 images in advance.
4567 if (BLOCKVECTOR_NBLOCKS (bv
) > FIRST_LOCAL_BLOCK
+ 1)
4568 std::sort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
4569 &BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)),
4570 block_is_less_than
);
4574 int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
4576 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
4577 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
4578 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
4579 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
4582 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
4583 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
4585 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4586 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4587 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4588 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4592 /* Constructor/restructor/destructor procedures. */
4594 /* Allocate a new symtab for NAME. Needs an estimate of how many
4595 linenumbers MAXLINES we'll put in it. */
4597 static struct compunit_symtab
*
4598 new_symtab (const char *name
, int maxlines
, struct objfile
*objfile
)
4600 struct compunit_symtab
*cust
= allocate_compunit_symtab (objfile
, name
);
4601 struct symtab
*symtab
;
4602 struct blockvector
*bv
;
4605 add_compunit_symtab_to_objfile (cust
);
4606 symtab
= allocate_symtab (cust
, name
);
4608 SYMTAB_LINETABLE (symtab
) = new_linetable (maxlines
);
4609 lang
= compunit_language (cust
);
4611 /* All symtabs must have at least two blocks. */
4613 BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
) = new_block (NON_FUNCTION_BLOCK
, lang
);
4614 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
) = new_block (NON_FUNCTION_BLOCK
, lang
);
4615 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4616 BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
4617 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
4619 COMPUNIT_DEBUGFORMAT (cust
) = "ECOFF";
4623 /* Allocate a new partial_symtab NAME. */
4625 static legacy_psymtab
*
4626 new_psymtab (const char *name
, struct objfile
*objfile
)
4628 legacy_psymtab
*psymtab
;
4630 psymtab
= new legacy_psymtab (name
, objfile
);
4632 /* Keep a backpointer to the file's symbols. */
4634 psymtab
->read_symtab_private
4635 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, symloc
);
4636 CUR_BFD (psymtab
) = cur_bfd
;
4637 DEBUG_SWAP (psymtab
) = debug_swap
;
4638 DEBUG_INFO (psymtab
) = debug_info
;
4639 PENDING_LIST (psymtab
) = pending_list
;
4641 /* The way to turn this into a symtab is to call... */
4642 psymtab
->legacy_read_symtab
= mdebug_read_symtab
;
4643 psymtab
->legacy_expand_psymtab
= mdebug_expand_psymtab
;
4648 /* Allocate a linetable array of the given SIZE. Since the struct
4649 already includes one item, we subtract one when calculating the
4650 proper size to allocate. */
4652 static struct linetable
*
4653 new_linetable (int size
)
4655 struct linetable
*l
;
4659 size
= size
* sizeof (l
->item
) + sizeof (struct linetable
);
4660 l
= (struct linetable
*) xmalloc (size
);
4665 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4666 I am not so sure about the 3.4 ones.
4668 Since the struct linetable already includes one item, we subtract one when
4669 calculating the proper size to allocate. */
4671 static struct linetable
*
4672 shrink_linetable (struct linetable
*lt
)
4674 return (struct linetable
*) xrealloc ((void *) lt
,
4675 (sizeof (struct linetable
)
4677 * sizeof (lt
->item
))));
4680 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4682 static struct blockvector
*
4683 new_bvect (int nblocks
)
4685 struct blockvector
*bv
;
4688 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4689 bv
= (struct blockvector
*) xzalloc (size
);
4691 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4696 /* Allocate and zero a new block of language LANGUAGE, and set its
4697 BLOCK_MULTIDICT. If function is non-zero, assume the block is
4698 associated to a function, and make sure that the symbols are stored
4699 linearly; otherwise, store them hashed. */
4701 static struct block
*
4702 new_block (enum block_type type
, enum language language
)
4704 /* FIXME: carlton/2003-09-11: This should use allocate_block to
4705 allocate the block. Which, in turn, suggests that the block
4706 should be allocated on an obstack. */
4707 struct block
*retval
= XCNEW (struct block
);
4709 if (type
== FUNCTION_BLOCK
)
4710 BLOCK_MULTIDICT (retval
) = mdict_create_linear_expandable (language
);
4712 BLOCK_MULTIDICT (retval
) = mdict_create_hashed_expandable (language
);
4717 /* Create a new symbol with printname NAME. */
4719 static struct symbol
*
4720 new_symbol (const char *name
)
4722 struct symbol
*s
= new (&mdebugread_objfile
->objfile_obstack
) symbol
;
4724 s
->set_language (psymtab_language
, &mdebugread_objfile
->objfile_obstack
);
4725 s
->compute_and_set_names (name
, true, mdebugread_objfile
->per_bfd
);
4729 /* Create a new type with printname NAME. */
4731 static struct type
*
4732 new_type (char *name
)
4736 t
= alloc_type (mdebugread_objfile
);
4738 INIT_CPLUS_SPECIFIC (t
);
4742 /* Read ECOFF debugging information from a BFD section. This is
4743 called from elfread.c. It parses the section into a
4744 ecoff_debug_info struct, and then lets the rest of the file handle
4748 elfmdebug_build_psymtabs (struct objfile
*objfile
,
4749 const struct ecoff_debug_swap
*swap
, asection
*sec
)
4751 bfd
*abfd
= objfile
->obfd
;
4752 struct ecoff_debug_info
*info
;
4754 /* FIXME: It's not clear whether we should be getting minimal symbol
4755 information from .mdebug in an ELF file, or whether we will.
4756 Re-initialize the minimal symbol reader in case we do. */
4758 minimal_symbol_reader
reader (objfile
);
4760 info
= XOBNEW (&objfile
->objfile_obstack
, ecoff_debug_info
);
4762 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4763 error (_("Error reading ECOFF debugging information: %s"),
4764 bfd_errmsg (bfd_get_error ()));
4766 mdebug_build_psymtabs (reader
, objfile
, swap
, info
);
4771 void _initialize_mdebugread ();
4773 _initialize_mdebugread ()
4775 mdebug_register_index
4776 = register_symbol_register_impl (LOC_REGISTER
, &mdebug_register_funcs
);
4777 mdebug_regparm_index
4778 = register_symbol_register_impl (LOC_REGPARM_ADDR
, &mdebug_register_funcs
);