1 /* Read a symbol table in ECOFF format (Third-Eye).
3 Copyright (C) 1986-1987, 1989-2004, 2007-2012 Free Software
6 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
7 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
10 This file is part of GDB.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 /* This module provides the function mdebug_build_psymtabs. It reads
26 ECOFF debugging information into partial symbol tables. The
27 debugging information is read from two structures. A struct
28 ecoff_debug_swap includes the sizes of each ECOFF structure and
29 swapping routines; these are fixed for a particular target. A
30 struct ecoff_debug_info points to the debugging information for a
31 particular object file.
33 ECOFF symbol tables are mostly written in the byte order of the
34 target machine. However, one section of the table (the auxiliary
35 symbol information) is written in the host byte order. There is a
36 bit in the other symbol info which describes which host byte order
37 was used. ECOFF thereby takes the trophy from Intel `b.out' for
38 the most brain-dead adaptation of a file format to byte order.
40 This module can read all four of the known byte-order combinations,
41 on any type of host. */
47 #include "filenames.h"
49 #include "gdb_obstack.h"
51 #include "stabsread.h"
52 #include "complaints.h"
54 #include "gdb-demangle.h"
55 #include "gdb_assert.h"
57 #include "dictionary.h"
58 #include "mdebugread.h"
60 #include "gdb_string.h"
65 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files. */
67 #include "libaout.h" /* Private BFD a.out information. */
68 #include "aout/aout64.h"
69 #include "aout/stab_gnu.h" /* STABS information. */
71 #include "expression.h"
73 extern void _initialize_mdebugread (void);
75 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
76 We use this define in order to know whether we should override a
77 symbol's ECOFF section with its ELF section. This is necessary in
78 case the symbol's ELF section could not be represented in ECOFF. */
79 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
80 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
82 /* The objfile we are currently reading. */
84 static struct objfile
*mdebugread_objfile
;
88 /* We put a pointer to this structure in the read_symtab_private field
93 /* Index of the FDR that this psymtab represents. */
95 /* The BFD that the psymtab was created from. */
97 const struct ecoff_debug_swap
*debug_swap
;
98 struct ecoff_debug_info
*debug_info
;
99 struct mdebug_pending
**pending_list
;
100 /* Pointer to external symbols for this file. */
102 /* Size of extern_tab. */
104 enum language pst_language
;
107 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
108 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
109 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
110 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
111 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
112 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
114 #define SC_IS_TEXT(sc) ((sc) == scText \
115 || (sc) == scRConst \
118 #define SC_IS_DATA(sc) ((sc) == scData \
123 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
124 #define SC_IS_BSS(sc) ((sc) == scBss)
125 #define SC_IS_SBSS(sc) ((sc) == scSBss)
126 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
128 /* Various complaints about symbol reading that don't abort the process. */
130 index_complaint (const char *arg1
)
132 complaint (&symfile_complaints
, _("bad aux index at symbol %s"), arg1
);
136 unknown_ext_complaint (const char *arg1
)
138 complaint (&symfile_complaints
, _("unknown external symbol %s"), arg1
);
142 basic_type_complaint (int arg1
, const char *arg2
)
144 complaint (&symfile_complaints
, _("cannot map ECOFF basic type 0x%x for %s"),
149 bad_tag_guess_complaint (const char *arg1
)
151 complaint (&symfile_complaints
,
152 _("guessed tag type of %s incorrectly"), arg1
);
156 bad_rfd_entry_complaint (const char *arg1
, int arg2
, int arg3
)
158 complaint (&symfile_complaints
, _("bad rfd entry for %s: file %d, index %d"),
163 unexpected_type_code_complaint (const char *arg1
)
165 complaint (&symfile_complaints
, _("unexpected type code for %s"), arg1
);
168 /* Macros and extra defs. */
170 /* Puns: hard to find whether -g was used and how. */
172 #define MIN_GLEVEL GLEVEL_0
173 #define compare_glevel(a,b) \
174 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
175 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
177 /* Things that really are local to this module. */
179 /* Remember what we deduced to be the source language of this psymtab. */
181 static enum language psymtab_language
= language_unknown
;
187 /* How to parse debugging information for CUR_BFD. */
189 static const struct ecoff_debug_swap
*debug_swap
;
191 /* Pointers to debugging information for CUR_BFD. */
193 static struct ecoff_debug_info
*debug_info
;
195 /* Pointer to current file decriptor record, and its index. */
200 /* Index of current symbol. */
204 /* Note how much "debuggable" this image is. We would like
205 to see at least one FDR with full symbols. */
207 static int max_gdbinfo
;
208 static int max_glevel
;
210 /* When examining .o files, report on undefined symbols. */
212 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
214 /* Pseudo symbol to use when putting stabs into the symbol table. */
216 static char stabs_symbol
[] = STABS_SYMBOL
;
218 /* Nonzero if we have seen ecoff debugging info for a file. */
220 static int found_ecoff_debugging_info
;
222 /* Forward declarations. */
224 static int upgrade_type (int, struct type
**, int, union aux_ext
*,
227 static void parse_partial_symbols (struct objfile
*);
229 static int has_opaque_xref (FDR
*, SYMR
*);
231 static int cross_ref (int, union aux_ext
*, struct type
**, enum type_code
,
232 char **, int, char *);
234 static struct symbol
*new_symbol (char *);
236 static struct type
*new_type (char *);
238 enum block_type
{ FUNCTION_BLOCK
, NON_FUNCTION_BLOCK
};
240 static struct block
*new_block (enum block_type
);
242 static struct symtab
*new_symtab (const char *, int, struct objfile
*);
244 static struct linetable
*new_linetable (int);
246 static struct blockvector
*new_bvect (int);
248 static struct type
*parse_type (int, union aux_ext
*, unsigned int, int *,
251 static struct symbol
*mylookup_symbol (char *, struct block
*, domain_enum
,
254 static void sort_blocks (struct symtab
*);
256 static struct partial_symtab
*new_psymtab (char *, struct objfile
*);
258 static void psymtab_to_symtab_1 (struct objfile
*objfile
,
259 struct partial_symtab
*, const char *);
261 static void add_block (struct block
*, struct symtab
*);
263 static void add_symbol (struct symbol
*, struct symtab
*, struct block
*);
265 static int add_line (struct linetable
*, int, CORE_ADDR
, int);
267 static struct linetable
*shrink_linetable (struct linetable
*);
269 static void handle_psymbol_enumerators (struct objfile
*, FDR
*, int,
272 static char *mdebug_next_symbol_text (struct objfile
*);
274 /* Exported procedure: Builds a symtab from the PST partial one.
275 Restores the environment in effect when PST was created, delegates
276 most of the work to an ancillary procedure, and sorts
277 and reorders the symtab list at the end. */
280 mdebug_psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
287 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
288 gdb_flush (gdb_stdout
);
291 next_symbol_text_func
= mdebug_next_symbol_text
;
293 psymtab_to_symtab_1 (objfile
, pst
, pst
->filename
);
295 /* Match with global symbols. This only needs to be done once,
296 after all of the symtabs and dependencies have been read in. */
297 scan_file_globals (objfile
);
300 printf_filtered (_("done.\n"));
303 /* File-level interface functions. */
305 /* Find a file descriptor given its index RF relative to a file CF. */
308 get_rfd (int cf
, int rf
)
314 fdrs
= debug_info
->fdr
;
316 /* Object files do not have the RFD table, all refs are absolute. */
319 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
320 ((char *) debug_info
->external_rfd
322 * debug_swap
->external_rfd_size
)),
327 /* Return a safer print NAME for a file descriptor. */
333 return "<stripped file>";
336 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
340 /* Read in and parse the symtab of the file OBJFILE. Symbols from
341 different sections are relocated via the SECTION_OFFSETS. */
344 mdebug_build_psymtabs (struct objfile
*objfile
,
345 const struct ecoff_debug_swap
*swap
,
346 struct ecoff_debug_info
*info
)
348 cur_bfd
= objfile
->obfd
;
352 stabsread_new_init ();
353 buildsym_new_init ();
354 free_header_files ();
355 init_header_files ();
357 /* Make sure all the FDR information is swapped in. */
358 if (info
->fdr
== (FDR
*) NULL
)
364 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->objfile_obstack
,
365 (info
->symbolic_header
.ifdMax
367 fdr_src
= info
->external_fdr
;
369 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
371 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
372 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
375 parse_partial_symbols (objfile
);
378 /* Check to make sure file was compiled with -g. If not, warn the
379 user of this limitation. */
380 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
382 if (max_gdbinfo
== 0)
383 printf_unfiltered (_("\n%s not compiled with -g, "
384 "debugging support is limited.\n"),
386 printf_unfiltered (_("You should compile with -g2 or "
387 "-g3 for best debugging support.\n"));
388 gdb_flush (gdb_stdout
);
393 /* Local utilities */
395 /* Map of FDR indexes to partial symtabs. */
399 struct partial_symtab
*pst
; /* the psymtab proper */
400 long n_globals
; /* exported globals (external symbols) */
401 long globals_offset
; /* cumulative */
405 /* Utility stack, used to nest procedures and blocks properly.
406 It is a doubly linked list, to avoid too many alloc/free.
407 Since we might need it quite a few times it is NOT deallocated
410 static struct parse_stack
412 struct parse_stack
*next
, *prev
;
413 struct symtab
*cur_st
; /* Current symtab. */
414 struct block
*cur_block
; /* Block in it. */
416 /* What are we parsing. stFile, or stBlock are for files and
417 blocks. stProc or stStaticProc means we have seen the start of a
418 procedure, but not the start of the block within in. When we see
419 the start of that block, we change it to stNil, without pushing a
420 new block, i.e. stNil means both a procedure and a block. */
424 struct type
*cur_type
; /* Type we parse fields for. */
425 int cur_field
; /* Field number in cur_type. */
426 CORE_ADDR procadr
; /* Start addres of this procedure. */
427 int numargs
; /* Its argument count. */
430 *top_stack
; /* Top stack ptr */
433 /* Enter a new lexical context. */
436 push_parse_stack (void)
438 struct parse_stack
*new;
440 /* Reuse frames if possible. */
441 if (top_stack
&& top_stack
->prev
)
442 new = top_stack
->prev
;
444 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
445 /* Initialize new frame with previous content. */
448 struct parse_stack
*prev
= new->prev
;
451 top_stack
->prev
= new;
453 new->next
= top_stack
;
458 /* Exit a lexical context. */
461 pop_parse_stack (void)
466 top_stack
= top_stack
->next
;
470 /* Cross-references might be to things we haven't looked at
471 yet, e.g. type references. To avoid too many type
472 duplications we keep a quick fixup table, an array
473 of lists of references indexed by file descriptor. */
475 struct mdebug_pending
477 struct mdebug_pending
*next
; /* link */
478 char *s
; /* the unswapped symbol */
479 struct type
*t
; /* its partial type descriptor */
483 /* The pending information is kept for an entire object file. We
484 allocate the pending information table when we create the partial
485 symbols, and we store a pointer to the single table in each
488 static struct mdebug_pending
**pending_list
;
490 /* Check whether we already saw symbol SH in file FH. */
492 static struct mdebug_pending
*
493 is_pending_symbol (FDR
*fh
, char *sh
)
495 int f_idx
= fh
- debug_info
->fdr
;
496 struct mdebug_pending
*p
;
498 /* Linear search is ok, list is typically no more than 10 deep. */
499 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
505 /* Add a new symbol SH of type T. */
508 add_pending (FDR
*fh
, char *sh
, struct type
*t
)
510 int f_idx
= fh
- debug_info
->fdr
;
511 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
513 /* Make sure we do not make duplicates. */
516 p
= ((struct mdebug_pending
*)
517 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
518 sizeof (struct mdebug_pending
)));
521 p
->next
= pending_list
[f_idx
];
522 pending_list
[f_idx
] = p
;
527 /* Parsing Routines proper. */
529 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
530 For blocks, procedures and types we open a new lexical context.
531 This is basically just a big switch on the symbol's type. Argument
532 AX is the base pointer of aux symbols for this file (fh->iauxBase).
533 EXT_SH points to the unswapped symbol, which is needed for struct,
534 union, etc., types; it is NULL for an EXTR. BIGEND says whether
535 aux symbols are big-endian or little-endian. Return count of
536 SYMR's handled (normally one). */
539 mdebug_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
541 return gdbarch_ecoff_reg_to_regnum (gdbarch
, SYMBOL_VALUE (sym
));
544 static const struct symbol_register_ops mdebug_register_funcs
= {
549 parse_symbol (SYMR
*sh
, union aux_ext
*ax
, char *ext_sh
, int bigend
,
550 struct section_offsets
*section_offsets
, struct objfile
*objfile
)
552 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
553 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
554 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
558 struct mdebug_pending
*pend
;
562 enum address_class
class;
564 long svalue
= sh
->value
;
567 if (ext_sh
== (char *) NULL
)
568 name
= debug_info
->ssext
+ sh
->iss
;
570 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
576 /* Do not relocate relative values.
577 The value of a stEnd symbol is the displacement from the
578 corresponding start symbol value.
579 The value of a stBlock symbol is the displacement from the
580 procedure address. */
581 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
582 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
589 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
593 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS (objfile
));
602 case stGlobal
: /* External symbol, goes into global block. */
604 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
606 s
= new_symbol (name
);
607 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
610 case stStatic
: /* Static data, goes into current block. */
612 b
= top_stack
->cur_block
;
613 s
= new_symbol (name
);
614 if (SC_IS_COMMON (sh
->sc
))
616 /* It is a FORTRAN common block. At least for SGI Fortran the
617 address is not in the symbol; we need to fix it later in
618 scan_file_globals. */
619 int bucket
= hashname (SYMBOL_LINKAGE_NAME (s
));
620 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
621 global_sym_chain
[bucket
] = s
;
624 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
627 case stLocal
: /* Local variable, goes into current block. */
628 b
= top_stack
->cur_block
;
629 s
= new_symbol (name
);
630 SYMBOL_VALUE (s
) = svalue
;
631 if (sh
->sc
== scRegister
)
633 class = LOC_REGISTER
;
634 SYMBOL_REGISTER_OPS (s
) = &mdebug_register_funcs
;
639 data
: /* Common code for symbols describing data. */
640 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
641 SYMBOL_CLASS (s
) = class;
642 add_symbol (s
, top_stack
->cur_st
, b
);
644 /* Type could be missing if file is compiled without debugging info. */
645 if (SC_IS_UNDEF (sh
->sc
)
646 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
647 SYMBOL_TYPE (s
) = objfile_type (objfile
)->nodebug_data_symbol
;
649 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
650 /* Value of a data symbol is its memory address. */
653 case stParam
: /* Arg to procedure, goes into current
656 found_ecoff_debugging_info
= 1;
657 top_stack
->numargs
++;
659 /* Special GNU C++ name. */
660 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
661 name
= "this"; /* FIXME, not alloc'd in obstack. */
662 s
= new_symbol (name
);
664 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
665 SYMBOL_IS_ARGUMENT (s
) = 1;
669 /* Pass by value in register. */
670 SYMBOL_CLASS (s
) = LOC_REGISTER
;
671 SYMBOL_REGISTER_OPS (s
) = &mdebug_register_funcs
;
674 /* Pass by reference on stack. */
675 SYMBOL_CLASS (s
) = LOC_REF_ARG
;
678 /* Pass by reference in register. */
679 SYMBOL_CLASS (s
) = LOC_REGPARM_ADDR
;
680 SYMBOL_REGISTER_OPS (s
) = &mdebug_register_funcs
;
683 /* Pass by value on stack. */
684 SYMBOL_CLASS (s
) = LOC_ARG
;
687 SYMBOL_VALUE (s
) = svalue
;
688 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
689 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
692 case stLabel
: /* label, goes into current block. */
693 s
= new_symbol (name
);
694 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
; /* So that it can be used */
695 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused. */
696 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
697 SYMBOL_TYPE (s
) = objfile_type (objfile
)->builtin_int
;
698 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
701 case stProc
: /* Procedure, usually goes into global block. */
702 case stStaticProc
: /* Static procedure, goes into current block. */
703 /* For stProc symbol records, we need to check the storage class
704 as well, as only (stProc, scText) entries represent "real"
705 procedures - See the Compaq document titled "Object File /
706 Symbol Table Format Specification" for more information.
707 If the storage class is not scText, we discard the whole block
708 of symbol records for this stProc. */
709 if (sh
->st
== stProc
&& sh
->sc
!= scText
)
711 char *ext_tsym
= ext_sh
;
712 int keep_counting
= 1;
715 while (keep_counting
)
717 ext_tsym
+= external_sym_size
;
718 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
728 complaint (&symfile_complaints
,
729 _("unknown symbol type 0x%x"), sh
->st
);
735 s
= new_symbol (name
);
736 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
737 SYMBOL_CLASS (s
) = LOC_BLOCK
;
738 /* Type of the return value. */
739 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
740 t
= objfile_type (objfile
)->builtin_int
;
743 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
744 if (strcmp (name
, "malloc") == 0
745 && TYPE_CODE (t
) == TYPE_CODE_VOID
)
747 /* I don't know why, but, at least under Alpha GNU/Linux,
748 when linking against a malloc without debugging
749 symbols, its read as a function returning void---this
750 is bad because it means we cannot call functions with
751 string arguments interactively; i.e., "call
752 printf("howdy\n")" would fail with the error message
753 "program has no memory available". To avoid this, we
754 patch up the type and make it void*
755 instead. (davidm@azstarnet.com). */
756 t
= make_pointer_type (t
, NULL
);
759 b
= top_stack
->cur_block
;
760 if (sh
->st
== stProc
)
762 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
764 /* The next test should normally be true, but provides a
765 hook for nested functions (which we don't want to make
767 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
768 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
769 /* Irix 5 sometimes has duplicate names for the same
770 function. We want to add such names up at the global
771 level, not as a nested function. */
772 else if (sh
->value
== top_stack
->procadr
)
773 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
775 add_symbol (s
, top_stack
->cur_st
, b
);
777 /* Make a type for the procedure itself. */
778 SYMBOL_TYPE (s
) = lookup_function_type (t
);
780 /* All functions in C++ have prototypes. For C we don't have enough
781 information in the debug info. */
782 if (SYMBOL_LANGUAGE (s
) == language_cplus
)
783 TYPE_PROTOTYPED (SYMBOL_TYPE (s
)) = 1;
785 /* Create and enter a new lexical context. */
786 b
= new_block (FUNCTION_BLOCK
);
787 SYMBOL_BLOCK_VALUE (s
) = b
;
788 BLOCK_FUNCTION (b
) = s
;
789 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
790 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
791 add_block (b
, top_stack
->cur_st
);
793 /* Not if we only have partial info. */
794 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
798 top_stack
->cur_block
= b
;
799 top_stack
->blocktype
= sh
->st
;
800 top_stack
->cur_type
= SYMBOL_TYPE (s
);
801 top_stack
->cur_field
= -1;
802 top_stack
->procadr
= sh
->value
;
803 top_stack
->numargs
= 0;
806 /* Beginning of code for structure, union, and enum definitions.
807 They all share a common set of local variables, defined here. */
809 enum type_code type_code
;
815 case stStruct
: /* Start a block defining a struct type. */
816 type_code
= TYPE_CODE_STRUCT
;
817 goto structured_common
;
819 case stUnion
: /* Start a block defining a union type. */
820 type_code
= TYPE_CODE_UNION
;
821 goto structured_common
;
823 case stEnum
: /* Start a block defining an enum type. */
824 type_code
= TYPE_CODE_ENUM
;
825 goto structured_common
;
827 case stBlock
: /* Either a lexical block, or some type. */
828 if (sh
->sc
!= scInfo
&& !SC_IS_COMMON (sh
->sc
))
829 goto case_stBlock_code
; /* Lexical block */
831 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
833 /* Common code for handling struct, union, enum, and/or as-yet-
834 unknown-type blocks of info about structured data. `type_code'
835 has been set to the proper TYPE_CODE, if we know it. */
837 found_ecoff_debugging_info
= 1;
839 top_stack
->blocktype
= stBlock
;
841 /* First count the number of fields and the highest value. */
844 for (ext_tsym
= ext_sh
+ external_sym_size
;
846 ext_tsym
+= external_sym_size
)
850 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
855 /* C++ encodes class types as structures where there the
856 methods are encoded as stProc. The scope of stProc
857 symbols also ends with stEnd, thus creating a risk of
858 taking the wrong stEnd symbol record as the end of
859 the current struct, which would cause GDB to undercount
860 the real number of fields in this struct. To make sure
861 we really reached the right stEnd symbol record, we
862 check the associated name, and match it against the
863 struct name. Since method names are mangled while
864 the class name is not, there is no risk of having a
865 method whose name is identical to the class name
866 (in particular constructor method names are different
867 from the class name). There is therefore no risk that
868 this check stops the count on the StEnd of a method.
870 Also, assume that we're really at the end when tsym.iss
872 if (tsym
.iss
== issNull
873 || strcmp (debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
,
879 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
881 /* If the type of the member is Nil (or Void),
882 without qualifiers, assume the tag is an
884 Alpha cc -migrate enums are recognized by a zero
885 index and a zero symbol value.
886 DU 4.0 cc enums are recognized by a member type of
887 btEnum without qualifiers and a zero symbol value. */
888 if (tsym
.index
== indexNil
889 || (tsym
.index
== 0 && sh
->value
== 0))
890 type_code
= TYPE_CODE_ENUM
;
893 (*debug_swap
->swap_tir_in
) (bigend
,
894 &ax
[tsym
.index
].a_ti
,
896 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
897 || (tir
.bt
== btEnum
&& sh
->value
== 0))
899 type_code
= TYPE_CODE_ENUM
;
903 if (tsym
.value
> max_value
)
904 max_value
= tsym
.value
;
913 /* This is a no-op; is it trying to tell us something
914 we should be checking? */
915 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED */
919 /* This is something like a struct within a
920 struct. Skip over the fields of the inner
921 struct. The -1 is because the for loop will
922 increment ext_tsym. */
923 ext_tsym
= ((char *) debug_info
->external_sym
924 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
925 * external_sym_size
));
931 /* mips cc puts out a typedef for struct x if it is not yet
932 defined when it encounters
933 struct y { struct x *xp; };
938 /* Irix5 cc puts out a stIndirect for struct x if it is not
939 yet defined when it encounters
940 struct y { struct x *xp; };
945 complaint (&symfile_complaints
,
946 _("declaration block contains "
947 "unhandled symbol type %d"),
953 /* In an stBlock, there is no way to distinguish structs,
954 unions, and enums at this point. This is a bug in the
955 original design (that has been fixed with the recent
956 addition of the stStruct, stUnion, and stEnum symbol
957 types.) The way you can tell is if/when you see a variable
958 or field of that type. In that case the variable's type
959 (in the AUX table) says if the type is struct, union, or
960 enum, and points back to the stBlock here. So you can
961 patch the tag kind up later - but only if there actually is
962 a variable or field of that type.
964 So until we know for sure, we will guess at this point.
966 If the first member has index==indexNil or a void type,
967 assume we have an enumeration.
968 Otherwise, if there is more than one member, and all
969 the members have offset 0, assume we have a union.
970 Otherwise, assume we have a struct.
972 The heuristic could guess wrong in the case of of an
973 enumeration with no members or a union with one (or zero)
974 members, or when all except the last field of a struct have
975 width zero. These are uncommon and/or illegal situations,
976 and in any case guessing wrong probably doesn't matter
979 But if we later do find out we were wrong, we fixup the tag
980 kind. Members of an enumeration must be handled
981 differently from struct/union fields, and that is harder to
982 patch up, but luckily we shouldn't need to. (If there are
983 any enumeration members, we can tell for sure it's an enum
986 if (type_code
== TYPE_CODE_UNDEF
)
988 if (nfields
> 1 && max_value
== 0)
989 type_code
= TYPE_CODE_UNION
;
991 type_code
= TYPE_CODE_STRUCT
;
994 /* Create a new type or use the pending type. */
995 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
996 if (pend
== (struct mdebug_pending
*) NULL
)
999 add_pending (cur_fdr
, ext_sh
, t
);
1004 /* Do not set the tag name if it is a compiler generated tag name
1005 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1006 Alpha cc puts out an sh->iss of zero for those. */
1007 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1008 TYPE_TAG_NAME (t
) = NULL
;
1010 TYPE_TAG_NAME (t
) = obconcat (&mdebugread_objfile
->objfile_obstack
,
1011 name
, (char *) NULL
);
1013 TYPE_CODE (t
) = type_code
;
1014 TYPE_LENGTH (t
) = sh
->value
;
1015 TYPE_NFIELDS (t
) = nfields
;
1016 TYPE_FIELDS (t
) = f
= ((struct field
*)
1018 nfields
* sizeof (struct field
)));
1020 if (type_code
== TYPE_CODE_ENUM
)
1022 int unsigned_enum
= 1;
1024 /* This is a non-empty enum. */
1026 /* DEC c89 has the number of enumerators in the sh.value field,
1027 not the type length, so we have to compensate for that
1028 incompatibility quirk.
1029 This might do the wrong thing for an enum with one or two
1030 enumerators and gcc -gcoff -fshort-enums, but these cases
1031 are hopefully rare enough.
1032 Alpha cc -migrate has a sh.value field of zero, we adjust
1034 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
)
1035 || TYPE_LENGTH (t
) == 0)
1036 TYPE_LENGTH (t
) = gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
1037 for (ext_tsym
= ext_sh
+ external_sym_size
;
1039 ext_tsym
+= external_sym_size
)
1042 struct symbol
*enum_sym
;
1044 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1046 if (tsym
.st
!= stMember
)
1049 SET_FIELD_ENUMVAL (*f
, tsym
.value
);
1050 FIELD_TYPE (*f
) = t
;
1051 FIELD_NAME (*f
) = debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1052 FIELD_BITSIZE (*f
) = 0;
1054 enum_sym
= ((struct symbol
*)
1055 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
1056 sizeof (struct symbol
)));
1057 memset (enum_sym
, 0, sizeof (struct symbol
));
1058 SYMBOL_SET_LINKAGE_NAME
1059 (enum_sym
, obsavestring (f
->name
, strlen (f
->name
),
1060 &mdebugread_objfile
->objfile_obstack
));
1061 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1062 SYMBOL_TYPE (enum_sym
) = t
;
1063 SYMBOL_DOMAIN (enum_sym
) = VAR_DOMAIN
;
1064 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1065 if (SYMBOL_VALUE (enum_sym
) < 0)
1067 add_symbol (enum_sym
, top_stack
->cur_st
, top_stack
->cur_block
);
1069 /* Skip the stMembers that we've handled. */
1074 TYPE_UNSIGNED (t
) = 1;
1076 /* Make this the current type. */
1077 top_stack
->cur_type
= t
;
1078 top_stack
->cur_field
= 0;
1080 /* Do not create a symbol for alpha cc unnamed structs. */
1084 /* gcc puts out an empty struct for an opaque struct definitions,
1085 do not create a symbol for it either. */
1086 if (TYPE_NFIELDS (t
) == 0)
1092 s
= new_symbol (name
);
1093 SYMBOL_DOMAIN (s
) = STRUCT_DOMAIN
;
1094 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1095 SYMBOL_VALUE (s
) = 0;
1096 SYMBOL_TYPE (s
) = t
;
1097 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1100 /* End of local variables shared by struct, union, enum, and
1101 block (as yet unknown struct/union/enum) processing. */
1105 found_ecoff_debugging_info
= 1;
1106 /* Beginnning of (code) block. Value of symbol
1107 is the displacement from procedure start. */
1108 push_parse_stack ();
1110 /* Do not start a new block if this is the outermost block of a
1111 procedure. This allows the LOC_BLOCK symbol to point to the
1112 block with the local variables, so funcname::var works. */
1113 if (top_stack
->blocktype
== stProc
1114 || top_stack
->blocktype
== stStaticProc
)
1116 top_stack
->blocktype
= stNil
;
1120 top_stack
->blocktype
= stBlock
;
1121 b
= new_block (NON_FUNCTION_BLOCK
);
1122 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1123 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1124 top_stack
->cur_block
= b
;
1125 add_block (b
, top_stack
->cur_st
);
1128 case stEnd
: /* end (of anything) */
1129 if (sh
->sc
== scInfo
|| SC_IS_COMMON (sh
->sc
))
1131 /* Finished with type */
1132 top_stack
->cur_type
= 0;
1134 else if (sh
->sc
== scText
&&
1135 (top_stack
->blocktype
== stProc
||
1136 top_stack
->blocktype
== stStaticProc
))
1138 /* Finished with procedure */
1139 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1140 struct mdebug_extra_func_info
*e
;
1141 struct block
*b
= top_stack
->cur_block
;
1142 struct type
*ftype
= top_stack
->cur_type
;
1145 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1147 /* Make up special symbol to contain procedure specific info. */
1148 s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
1149 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
1150 SYMBOL_CLASS (s
) = LOC_CONST
;
1151 SYMBOL_TYPE (s
) = objfile_type (mdebugread_objfile
)->builtin_void
;
1152 e
= ((struct mdebug_extra_func_info
*)
1153 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
1154 sizeof (struct mdebug_extra_func_info
)));
1155 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
1156 SYMBOL_VALUE_BYTES (s
) = (gdb_byte
*) e
;
1157 e
->numargs
= top_stack
->numargs
;
1158 e
->pdr
.framereg
= -1;
1159 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1161 /* f77 emits proc-level with address bounds==[0,0],
1162 So look for such child blocks, and patch them. */
1163 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1165 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1167 if (BLOCK_SUPERBLOCK (b_bad
) == b
1168 && BLOCK_START (b_bad
) == top_stack
->procadr
1169 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1171 BLOCK_START (b_bad
) = BLOCK_START (b
);
1172 BLOCK_END (b_bad
) = BLOCK_END (b
);
1176 if (TYPE_NFIELDS (ftype
) <= 0)
1178 /* No parameter type information is recorded with the function's
1179 type. Set that from the type of the parameter symbols. */
1180 int nparams
= top_stack
->numargs
;
1186 struct block_iterator iter
;
1188 TYPE_NFIELDS (ftype
) = nparams
;
1189 TYPE_FIELDS (ftype
) = (struct field
*)
1190 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1193 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1195 if (iparams
== nparams
)
1198 if (SYMBOL_IS_ARGUMENT (sym
))
1200 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1201 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
1208 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1210 /* End of (code) block. The value of the symbol is the
1211 displacement from the procedure`s start address of the
1212 end of this block. */
1213 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1215 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1217 /* End of outermost block. Pop parse stack and ignore. The
1218 following stEnd of stProc will take care of the block. */
1221 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1223 /* End of file. Pop parse stack and ignore. Higher
1224 level code deals with this. */
1228 complaint (&symfile_complaints
,
1229 _("stEnd with storage class %d not handled"), sh
->sc
);
1231 pop_parse_stack (); /* Restore previous lexical context. */
1234 case stMember
: /* member of struct or union */
1235 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1236 FIELD_NAME (*f
) = name
;
1237 SET_FIELD_BITPOS (*f
, sh
->value
);
1239 FIELD_TYPE (*f
) = parse_type (cur_fd
, ax
, sh
->index
,
1240 &bitsize
, bigend
, name
);
1241 FIELD_BITSIZE (*f
) = bitsize
;
1244 case stIndirect
: /* forward declaration on Irix5 */
1245 /* Forward declarations from Irix5 cc are handled by cross_ref,
1249 case stTypedef
: /* type definition */
1250 found_ecoff_debugging_info
= 1;
1252 /* Typedefs for forward declarations and opaque structs from alpha cc
1253 are handled by cross_ref, skip them. */
1257 /* Parse the type or use the pending type. */
1258 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1259 if (pend
== (struct mdebug_pending
*) NULL
)
1261 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *) NULL
, bigend
, name
);
1262 add_pending (cur_fdr
, ext_sh
, t
);
1267 /* Mips cc puts out a typedef with the name of the struct for forward
1268 declarations. These should not go into the symbol table and
1269 TYPE_NAME should not be set for them.
1270 They can't be distinguished from an intentional typedef to
1271 the same name however:
1273 struct x { int ix; int jx; };
1277 struct xx {int ixx; int jxx; };
1278 generates a cross referencing stTypedef for x and xx.
1279 The user visible effect of this is that the type of a pointer
1280 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1281 The problem is fixed with alpha cc and Irix5 cc. */
1283 /* However if the typedef cross references to an opaque aggregate, it
1284 is safe to omit it from the symbol table. */
1286 if (has_opaque_xref (cur_fdr
, sh
))
1288 s
= new_symbol (name
);
1289 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1290 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1291 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1292 SYMBOL_TYPE (s
) = t
;
1293 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1295 /* Incomplete definitions of structs should not get a name. */
1296 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1297 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1298 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1299 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1301 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1302 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1304 /* If we are giving a name to a type such as "pointer to
1305 foo" or "function returning foo", we better not set
1306 the TYPE_NAME. If the program contains "typedef char
1307 *caddr_t;", we don't want all variables of type char
1308 * to print as caddr_t. This is not just a
1309 consequence of GDB's type management; CC and GCC (at
1310 least through version 2.4) both output variables of
1311 either type char * or caddr_t with the type
1312 refering to the stTypedef symbol for caddr_t. If a future
1313 compiler cleans this up it GDB is not ready for it
1314 yet, but if it becomes ready we somehow need to
1315 disable this check (without breaking the PCC/GCC2.4
1320 Fortunately, this check seems not to be necessary
1321 for anything except pointers or functions. */
1324 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_LINKAGE_NAME (s
);
1328 case stFile
: /* file name */
1329 push_parse_stack ();
1330 top_stack
->blocktype
= sh
->st
;
1333 /* I`ve never seen these for C */
1335 break; /* register relocation */
1337 break; /* forwarding address */
1339 break; /* constant */
1341 complaint (&symfile_complaints
, _("unknown symbol type 0x%x"), sh
->st
);
1350 static const struct objfile_data
*basic_type_data
;
1352 static struct type
*
1353 basic_type (int bt
, struct objfile
*objfile
)
1355 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1356 struct type
**map_bt
= objfile_data (objfile
, basic_type_data
);
1364 map_bt
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
1365 btMax
, struct type
*);
1366 set_objfile_data (objfile
, basic_type_data
, map_bt
);
1375 tp
= objfile_type (objfile
)->builtin_void
;
1379 tp
= init_type (TYPE_CODE_PTR
, 4, TYPE_FLAG_UNSIGNED
,
1381 TYPE_TARGET_TYPE (tp
) = objfile_type (objfile
)->builtin_void
;
1385 tp
= init_type (TYPE_CODE_INT
, 1, 0,
1390 tp
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
1391 "unsigned char", objfile
);
1395 tp
= init_type (TYPE_CODE_INT
, 2, 0,
1400 tp
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
1401 "unsigned short", objfile
);
1405 tp
= init_type (TYPE_CODE_INT
, 4, 0,
1410 tp
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1411 "unsigned int", objfile
);
1415 tp
= init_type (TYPE_CODE_INT
, 4, 0,
1420 tp
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1421 "unsigned long", objfile
);
1425 tp
= init_type (TYPE_CODE_FLT
,
1426 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1431 tp
= init_type (TYPE_CODE_FLT
,
1432 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1437 tp
= init_type (TYPE_CODE_COMPLEX
,
1438 2 * gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1439 "complex", objfile
);
1440 TYPE_TARGET_TYPE (tp
) = basic_type (btFloat
, objfile
);
1444 tp
= init_type (TYPE_CODE_COMPLEX
,
1445 2 * gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1446 "double complex", objfile
);
1447 TYPE_TARGET_TYPE (tp
) = basic_type (btDouble
, objfile
);
1451 /* We use TYPE_CODE_INT to print these as integers. Does this do any
1452 good? Would we be better off with TYPE_CODE_ERROR? Should
1453 TYPE_CODE_ERROR print things in hex if it knows the size? */
1454 tp
= init_type (TYPE_CODE_INT
,
1455 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1456 "fixed decimal", objfile
);
1460 tp
= init_type (TYPE_CODE_ERROR
,
1461 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1462 "floating decimal", objfile
);
1466 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
1468 tp
= init_type (TYPE_CODE_STRING
, 1, 0,
1473 tp
= objfile_type (objfile
)->builtin_void
;
1477 tp
= init_type (TYPE_CODE_INT
, 8, 0,
1482 tp
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
1483 "unsigned long", objfile
);
1487 tp
= init_type (TYPE_CODE_INT
, 8, 0,
1488 "long long", objfile
);
1492 tp
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
1493 "unsigned long long", objfile
);
1497 tp
= init_type (TYPE_CODE_PTR
, 8, TYPE_FLAG_UNSIGNED
,
1499 TYPE_TARGET_TYPE (tp
) = objfile_type (objfile
)->builtin_void
;
1503 tp
= init_type (TYPE_CODE_INT
, 8, 0,
1508 tp
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
1509 "unsigned int", objfile
);
1521 /* Parse the type information provided in the raw AX entries for
1522 the symbol SH. Return the bitfield size in BS, in case.
1523 We must byte-swap the AX entries before we use them; BIGEND says whether
1524 they are big-endian or little-endian (from fh->fBigendian). */
1526 static struct type
*
1527 parse_type (int fd
, union aux_ext
*ax
, unsigned int aux_index
, int *bs
,
1528 int bigend
, char *sym_name
)
1531 struct type
*tp
= 0;
1532 enum type_code type_code
= TYPE_CODE_UNDEF
;
1534 /* Handle undefined types, they have indexNil. */
1535 if (aux_index
== indexNil
)
1536 return basic_type (btInt
, mdebugread_objfile
);
1538 /* Handle corrupt aux indices. */
1539 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1541 index_complaint (sym_name
);
1542 return basic_type (btInt
, mdebugread_objfile
);
1546 /* Use aux as a type information record, map its basic type. */
1547 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1548 tp
= basic_type (t
->bt
, mdebugread_objfile
);
1551 /* Cannot use builtin types -- build our own. */
1555 type_code
= TYPE_CODE_STRUCT
;
1558 type_code
= TYPE_CODE_UNION
;
1561 type_code
= TYPE_CODE_ENUM
;
1564 type_code
= TYPE_CODE_RANGE
;
1567 type_code
= TYPE_CODE_SET
;
1570 /* alpha cc -migrate uses this for typedefs. The true type will
1571 be obtained by crossreferencing below. */
1572 type_code
= TYPE_CODE_ERROR
;
1575 /* alpha cc uses this for typedefs. The true type will be
1576 obtained by crossreferencing below. */
1577 type_code
= TYPE_CODE_ERROR
;
1580 basic_type_complaint (t
->bt
, sym_name
);
1581 return basic_type (btInt
, mdebugread_objfile
);
1585 /* Move on to next aux. */
1590 int width
= AUX_GET_WIDTH (bigend
, ax
);
1592 /* Inhibit core dumps if TIR is corrupted. */
1593 if (bs
== (int *) NULL
)
1595 /* Alpha cc -migrate encodes char and unsigned char types
1596 as short and unsigned short types with a field width of 8.
1597 Enum types also have a field width which we ignore for now. */
1598 if (t
->bt
== btShort
&& width
== 8)
1599 tp
= basic_type (btChar
, mdebugread_objfile
);
1600 else if (t
->bt
== btUShort
&& width
== 8)
1601 tp
= basic_type (btUChar
, mdebugread_objfile
);
1602 else if (t
->bt
== btEnum
)
1605 complaint (&symfile_complaints
,
1606 _("can't handle TIR fBitfield for %s"),
1614 /* A btIndirect entry cross references to an aux entry containing
1616 if (t
->bt
== btIndirect
)
1623 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1625 if (rn
->rfd
== 0xfff)
1627 rf
= AUX_GET_ISYM (bigend
, ax
);
1635 complaint (&symfile_complaints
,
1636 _("unable to cross ref btIndirect for %s"), sym_name
);
1637 return basic_type (btInt
, mdebugread_objfile
);
1639 xref_fh
= get_rfd (fd
, rf
);
1640 xref_fd
= xref_fh
- debug_info
->fdr
;
1641 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1642 rn
->index
, (int *) NULL
, xref_fh
->fBigendian
, sym_name
);
1645 /* All these types really point to some (common) MIPS type
1646 definition, and only the type-qualifiers fully identify
1647 them. We'll make the same effort at sharing. */
1648 if (t
->bt
== btStruct
||
1652 /* btSet (I think) implies that the name is a tag name, not a typedef
1653 name. This apparently is a MIPS extension for C sets. */
1658 /* Try to cross reference this type, build new type on failure. */
1659 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1660 if (tp
== (struct type
*) NULL
)
1661 tp
= init_type (type_code
, 0, 0, (char *) NULL
, mdebugread_objfile
);
1663 /* DEC c89 produces cross references to qualified aggregate types,
1664 dereference them. */
1665 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1666 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1667 tp
= TYPE_TARGET_TYPE (tp
);
1669 /* Make sure that TYPE_CODE(tp) has an expected type code.
1670 Any type may be returned from cross_ref if file indirect entries
1672 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1673 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1674 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1676 unexpected_type_code_complaint (sym_name
);
1680 /* Usually, TYPE_CODE(tp) is already type_code. The main
1681 exception is if we guessed wrong re struct/union/enum.
1682 But for struct vs. union a wrong guess is harmless, so
1683 don't complain(). */
1684 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1685 && type_code
!= TYPE_CODE_ENUM
)
1686 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1687 && type_code
== TYPE_CODE_ENUM
))
1689 bad_tag_guess_complaint (sym_name
);
1692 if (TYPE_CODE (tp
) != type_code
)
1694 TYPE_CODE (tp
) = type_code
;
1697 /* Do not set the tag name if it is a compiler generated tag name
1698 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1699 if (name
[0] == '.' || name
[0] == '\0')
1700 TYPE_TAG_NAME (tp
) = NULL
;
1701 else if (TYPE_TAG_NAME (tp
) == NULL
1702 || strcmp (TYPE_TAG_NAME (tp
), name
) != 0)
1704 = obsavestring (name
, strlen (name
),
1705 &mdebugread_objfile
->objfile_obstack
);
1709 /* All these types really point to some (common) MIPS type
1710 definition, and only the type-qualifiers fully identify
1711 them. We'll make the same effort at sharing.
1712 FIXME: We are not doing any guessing on range types. */
1713 if (t
->bt
== btRange
)
1717 /* Try to cross reference this type, build new type on failure. */
1718 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1719 if (tp
== (struct type
*) NULL
)
1720 tp
= init_type (type_code
, 0, 0, (char *) NULL
, mdebugread_objfile
);
1722 /* Make sure that TYPE_CODE(tp) has an expected type code.
1723 Any type may be returned from cross_ref if file indirect entries
1725 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1727 unexpected_type_code_complaint (sym_name
);
1731 /* Usually, TYPE_CODE(tp) is already type_code. The main
1732 exception is if we guessed wrong re struct/union/enum. */
1733 if (TYPE_CODE (tp
) != type_code
)
1735 bad_tag_guess_complaint (sym_name
);
1736 TYPE_CODE (tp
) = type_code
;
1738 if (TYPE_NAME (tp
) == NULL
1739 || strcmp (TYPE_NAME (tp
), name
) != 0)
1740 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1741 &mdebugread_objfile
->objfile_obstack
);
1744 if (t
->bt
== btTypedef
)
1748 /* Try to cross reference this type, it should succeed. */
1749 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1750 if (tp
== (struct type
*) NULL
)
1752 complaint (&symfile_complaints
,
1753 _("unable to cross ref btTypedef for %s"), sym_name
);
1754 tp
= basic_type (btInt
, mdebugread_objfile
);
1758 /* Deal with range types. */
1759 if (t
->bt
== btRange
)
1761 TYPE_NFIELDS (tp
) = 0;
1762 TYPE_RANGE_DATA (tp
) = ((struct range_bounds
*)
1763 TYPE_ZALLOC (tp
, sizeof (struct range_bounds
)));
1764 TYPE_LOW_BOUND (tp
) = AUX_GET_DNLOW (bigend
, ax
);
1766 TYPE_HIGH_BOUND (tp
) = AUX_GET_DNHIGH (bigend
, ax
);
1770 /* Parse all the type qualifiers now. If there are more
1771 than 6 the game will continue in the next aux. */
1775 #define PARSE_TQ(tq) \
1776 if (t->tq != tqNil) \
1777 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1789 /* mips cc 2.x and gcc never put out continued aux entries. */
1793 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1797 /* Complain for illegal continuations due to corrupt aux entries. */
1799 complaint (&symfile_complaints
,
1800 _("illegal TIR continued for %s"), sym_name
);
1805 /* Make up a complex type from a basic one. Type is passed by
1806 reference in TPP and side-effected as necessary. The type
1807 qualifier TQ says how to handle the aux symbols at AX for
1808 the symbol SX we are currently analyzing. BIGEND says whether
1809 aux symbols are big-endian or little-endian.
1810 Returns the number of aux symbols we parsed. */
1813 upgrade_type (int fd
, struct type
**tpp
, int tq
, union aux_ext
*ax
, int bigend
,
1819 /* Used in array processing. */
1830 t
= lookup_pointer_type (*tpp
);
1835 t
= lookup_function_type (*tpp
);
1842 /* Determine and record the domain type (type of index). */
1843 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1849 rf
= AUX_GET_ISYM (bigend
, ax
);
1852 fh
= get_rfd (fd
, rf
);
1854 indx
= parse_type (fh
- debug_info
->fdr
,
1855 debug_info
->external_aux
+ fh
->iauxBase
,
1856 id
, (int *) NULL
, bigend
, sym_name
);
1858 /* The bounds type should be an integer type, but might be anything
1859 else due to corrupt aux entries. */
1860 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1862 complaint (&symfile_complaints
,
1863 _("illegal array index type for %s, assuming int"),
1865 indx
= objfile_type (mdebugread_objfile
)->builtin_int
;
1868 /* Get the bounds, and create the array type. */
1870 lower
= AUX_GET_DNLOW (bigend
, ax
);
1872 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1874 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1876 range
= create_range_type ((struct type
*) NULL
, indx
,
1879 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1881 /* We used to fill in the supplied array element bitsize
1882 here if the TYPE_LENGTH of the target type was zero.
1883 This happens for a `pointer to an array of anonymous structs',
1884 but in this case the array element bitsize is also zero,
1885 so nothing is gained.
1886 And we used to check the TYPE_LENGTH of the target type against
1887 the supplied array element bitsize.
1888 gcc causes a mismatch for `pointer to array of object',
1889 since the sdb directives it uses do not have a way of
1890 specifying the bitsize, but it does no harm (the
1891 TYPE_LENGTH should be correct) and we should be able to
1892 ignore the erroneous bitsize from the auxiliary entry safely.
1893 dbx seems to ignore it too. */
1895 /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */
1896 if (TYPE_LENGTH (*tpp
) == 0)
1897 TYPE_TARGET_STUB (t
) = 1;
1903 /* Volatile -- currently ignored */
1907 /* Const -- currently ignored */
1911 complaint (&symfile_complaints
, _("unknown type qualifier 0x%x"), tq
);
1917 /* Parse a procedure descriptor record PR. Note that the procedure is
1918 parsed _after_ the local symbols, now we just insert the extra
1919 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1920 already been placed in the procedure's main block. Note also that
1921 images that have been partially stripped (ld -x) have been deprived
1922 of local symbols, and we have to cope with them here. FIRST_OFF is
1923 the offset of the first procedure for this FDR; we adjust the
1924 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1925 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1926 in question, or NULL to use top_stack->cur_block. */
1928 static void parse_procedure (PDR
*, struct symtab
*, struct partial_symtab
*);
1931 parse_procedure (PDR
*pr
, struct symtab
*search_symtab
,
1932 struct partial_symtab
*pst
)
1934 struct symbol
*s
, *i
;
1938 /* Simple rule to find files linked "-x". */
1939 if (cur_fdr
->rss
== -1)
1943 /* Static procedure at address pr->adr. Sigh. */
1944 /* FIXME-32x64. assuming pr->adr fits in long. */
1945 complaint (&symfile_complaints
,
1946 _("can't handle PDR for static proc at 0x%lx"),
1947 (unsigned long) pr
->adr
);
1955 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1956 ((char *) debug_info
->external_ext
1958 * debug_swap
->external_ext_size
)),
1960 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1968 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1969 ((char *) debug_info
->external_sym
1970 + ((cur_fdr
->isymBase
+ pr
->isym
)
1971 * debug_swap
->external_sym_size
)),
1973 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1976 if (search_symtab
!= NULL
)
1979 /* This loses both in the case mentioned (want a static, find a global),
1980 but also if we are looking up a non-mangled name which happens to
1981 match the name of a mangled function. */
1982 /* We have to save the cur_fdr across the call to lookup_symbol.
1983 If the pdr is for a static function and if a global function with
1984 the same name exists, lookup_symbol will eventually read in the symtab
1985 for the global function and clobber cur_fdr. */
1986 FDR
*save_cur_fdr
= cur_fdr
;
1988 s
= lookup_symbol (sh_name
, NULL
, VAR_DOMAIN
, 0);
1989 cur_fdr
= save_cur_fdr
;
1993 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1999 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
2000 VAR_DOMAIN
, LOC_BLOCK
);
2004 b
= SYMBOL_BLOCK_VALUE (s
);
2008 complaint (&symfile_complaints
, _("PDR for %s, but no symbol"), sh_name
);
2012 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
2013 s
= new_symbol (sh_name
);
2014 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
2015 SYMBOL_CLASS (s
) = LOC_BLOCK
;
2016 /* Donno its type, hope int is ok. */
2018 = lookup_function_type (objfile_type (pst
->objfile
)->builtin_int
);
2019 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
2020 /* Won't have symbols for this one. */
2022 SYMBOL_BLOCK_VALUE (s
) = b
;
2023 BLOCK_FUNCTION (b
) = s
;
2024 BLOCK_START (b
) = pr
->adr
;
2025 /* BOUND used to be the end of procedure's text, but the
2026 argument is no longer passed in. */
2027 BLOCK_END (b
) = bound
;
2028 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
2029 add_block (b
, top_stack
->cur_st
);
2033 i
= mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME
, b
, LABEL_DOMAIN
, LOC_CONST
);
2037 struct mdebug_extra_func_info
*e
;
2039 e
= (struct mdebug_extra_func_info
*) SYMBOL_VALUE_BYTES (i
);
2042 /* GDB expects the absolute function start address for the
2043 procedure descriptor in e->pdr.adr.
2044 As the address in the procedure descriptor is usually relative,
2045 we would have to relocate e->pdr.adr with cur_fdr->adr and
2046 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
2047 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2048 in shared libraries on some systems, and on other systems
2049 e->pdr.adr is sometimes offset by a bogus value.
2050 To work around these problems, we replace e->pdr.adr with
2051 the start address of the function. */
2052 e
->pdr
.adr
= BLOCK_START (b
);
2055 /* It would be reasonable that functions that have been compiled
2056 without debugging info have a btNil type for their return value,
2057 and functions that are void and are compiled with debugging info
2059 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2060 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2062 The glevel field in cur_fdr could be used to determine the presence
2063 of debugging info, but GCC doesn't always pass the -g switch settings
2064 to the assembler and GAS doesn't set the glevel field from the -g switch
2066 To work around these problems, the return value type of a TYPE_CODE_VOID
2067 function is adjusted accordingly if no debugging info was found in the
2068 compilation unit. */
2070 if (processing_gcc_compilation
== 0
2071 && found_ecoff_debugging_info
== 0
2072 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
2073 SYMBOL_TYPE (s
) = objfile_type (mdebugread_objfile
)->nodebug_text_symbol
;
2076 /* Parse the external symbol ES. Just call parse_symbol() after
2077 making sure we know where the aux are for it.
2078 BIGEND says whether aux entries are big-endian or little-endian.
2080 This routine clobbers top_stack->cur_block and ->cur_st. */
2082 static void parse_external (EXTR
*, int, struct section_offsets
*,
2086 parse_external (EXTR
*es
, int bigend
, struct section_offsets
*section_offsets
,
2087 struct objfile
*objfile
)
2091 if (es
->ifd
!= ifdNil
)
2094 cur_fdr
= debug_info
->fdr
+ cur_fd
;
2095 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
2099 cur_fdr
= debug_info
->fdr
;
2103 /* Reading .o files */
2104 if (SC_IS_UNDEF (es
->asym
.sc
) || es
->asym
.sc
== scNil
)
2107 switch (es
->asym
.st
)
2110 /* These are generated for static symbols in .o files,
2131 /* FIXME: Turn this into a complaint? */
2133 printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
2134 what
, debug_info
->ssext
+ es
->asym
.iss
,
2135 fdr_name (cur_fdr
));
2139 switch (es
->asym
.st
)
2143 /* There is no need to parse the external procedure symbols.
2144 If they are from objects compiled without -g, their index will
2145 be indexNil, and the symbol definition from the minimal symbol
2146 is preferrable (yielding a function returning int instead of int).
2147 If the index points to a local procedure symbol, the local
2148 symbol already provides the correct type.
2149 Note that the index of the external procedure symbol points
2150 to the local procedure symbol in the local symbol table, and
2151 _not_ to the auxiliary symbol info. */
2155 /* Global common symbols are resolved by the runtime loader,
2157 if (SC_IS_COMMON (es
->asym
.sc
))
2160 /* Note that the case of a symbol with indexNil must be handled
2161 anyways by parse_symbol(). */
2162 parse_symbol (&es
->asym
, ax
, (char *) NULL
,
2163 bigend
, section_offsets
, objfile
);
2170 /* Parse the line number info for file descriptor FH into
2171 GDB's linetable LT. MIPS' encoding requires a little bit
2172 of magic to get things out. Note also that MIPS' line
2173 numbers can go back and forth, apparently we can live
2174 with that and do not need to reorder our linetables. */
2176 static void parse_lines (FDR
*, PDR
*, struct linetable
*, int,
2177 struct partial_symtab
*, CORE_ADDR
);
2180 parse_lines (FDR
*fh
, PDR
*pr
, struct linetable
*lt
, int maxlines
,
2181 struct partial_symtab
*pst
, CORE_ADDR lowest_pdr_addr
)
2183 unsigned char *base
;
2185 int delta
, count
, lineno
= 0;
2187 if (fh
->cbLine
== 0)
2190 /* Scan by procedure descriptors. */
2192 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2196 unsigned char *halt
;
2198 /* No code for this one. */
2199 if (pr
->iline
== ilineNil
||
2200 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2203 /* Determine start and end address of compressed line bytes for
2205 base
= debug_info
->line
+ fh
->cbLineOffset
;
2206 if (j
!= (fh
->cpd
- 1))
2207 halt
= base
+ pr
[1].cbLineOffset
;
2209 halt
= base
+ fh
->cbLine
;
2210 base
+= pr
->cbLineOffset
;
2212 adr
= pst
->textlow
+ pr
->adr
- lowest_pdr_addr
;
2214 l
= adr
>> 2; /* in words */
2215 for (lineno
= pr
->lnLow
; base
< halt
;)
2217 count
= *base
& 0x0f;
2218 delta
= *base
++ >> 4;
2223 delta
= (base
[0] << 8) | base
[1];
2224 if (delta
>= 0x8000)
2228 lineno
+= delta
; /* first delta is 0 */
2230 /* Complain if the line table overflows. Could happen
2231 with corrupt binaries. */
2232 if (lt
->nitems
>= maxlines
)
2234 complaint (&symfile_complaints
,
2235 _("guessed size of linetable for %s incorrectly"),
2239 k
= add_line (lt
, lineno
, l
, k
);
2246 function_outside_compilation_unit_complaint (const char *arg1
)
2248 complaint (&symfile_complaints
,
2249 _("function `%s' appears to be defined "
2250 "outside of all compilation units"),
2254 /* Use the STORAGE_CLASS to compute which section the given symbol
2255 belongs to, and then records this new minimal symbol. */
2258 record_minimal_symbol (const char *name
, const CORE_ADDR address
,
2259 enum minimal_symbol_type ms_type
, int storage_class
,
2260 struct objfile
*objfile
)
2263 asection
*bfd_section
;
2265 switch (storage_class
)
2268 section
= SECT_OFF_TEXT (objfile
);
2269 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".text");
2272 section
= SECT_OFF_DATA (objfile
);
2273 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".data");
2276 section
= SECT_OFF_BSS (objfile
);
2277 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".bss");
2280 section
= get_section_index (objfile
, ".sdata");
2281 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".sdata");
2284 section
= get_section_index (objfile
, ".sbss");
2285 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".sbss");
2288 section
= get_section_index (objfile
, ".rdata");
2289 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".rdata");
2292 section
= get_section_index (objfile
, ".init");
2293 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".init");
2296 section
= get_section_index (objfile
, ".xdata");
2297 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".xdata");
2300 section
= get_section_index (objfile
, ".pdata");
2301 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".pdata");
2304 section
= get_section_index (objfile
, ".fini");
2305 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".fini");
2308 section
= get_section_index (objfile
, ".rconst");
2309 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".rconst");
2313 section
= get_section_index (objfile
, ".tlsdata");
2314 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".tlsdata");
2319 section
= get_section_index (objfile
, ".tlsbss");
2320 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".tlsbss");
2324 /* This kind of symbol is not associated to a section. */
2329 prim_record_minimal_symbol_and_info (name
, address
, ms_type
,
2330 section
, bfd_section
, objfile
);
2333 /* Master parsing procedure for first-pass reading of file symbols
2334 into a partial_symtab. */
2337 parse_partial_symbols (struct objfile
*objfile
)
2339 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2340 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2341 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2342 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2343 void (*const swap_ext_in
) (bfd
*, void *, EXTR
*) = debug_swap
->swap_ext_in
;
2344 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
2345 void (*const swap_rfd_in
) (bfd
*, void *, RFDT
*) = debug_swap
->swap_rfd_in
;
2347 HDRR
*hdr
= &debug_info
->symbolic_header
;
2348 /* Running pointers */
2356 struct partial_symtab
*pst
;
2357 int textlow_not_set
= 1;
2358 int past_first_source_file
= 0;
2360 /* List of current psymtab's include files. */
2361 const char **psymtab_include_list
;
2362 int includes_allocated
;
2365 struct pst_map
*fdr_to_pst
;
2366 /* Index within current psymtab dependency list. */
2367 struct partial_symtab
**dependency_list
;
2368 int dependencies_used
, dependencies_allocated
;
2369 struct cleanup
*old_chain
;
2371 enum language prev_language
;
2372 asection
*text_sect
;
2373 int relocatable
= 0;
2375 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2376 the shared libraries are prelinked at a high memory address.
2377 We have to adjust the start address of the object file for this case,
2378 by setting it to the start address of the first procedure in the file.
2379 But we should do no adjustments if we are debugging a .o file, where
2380 the text section (and fh->adr) really starts at zero. */
2381 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2382 if (text_sect
!= NULL
2383 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2386 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->objfile_obstack
,
2387 sizeof (EXTR
) * hdr
->iextMax
);
2389 includes_allocated
= 30;
2391 psymtab_include_list
= (const char **) alloca (includes_allocated
*
2392 sizeof (const char *));
2393 next_symbol_text_func
= mdebug_next_symbol_text
;
2395 dependencies_allocated
= 30;
2396 dependencies_used
= 0;
2398 (struct partial_symtab
**) alloca (dependencies_allocated
*
2399 sizeof (struct partial_symtab
*));
2401 last_source_file
= NULL
;
2406 * Only parse the Local and External symbols, and the Relative FDR.
2407 * Fixup enough of the loader symtab to be able to use it.
2408 * Allocate space only for the file's portions we need to
2413 max_glevel
= MIN_GLEVEL
;
2415 /* Allocate the map FDR -> PST.
2416 Minor hack: -O3 images might claim some global data belongs
2417 to FDR -1. We`ll go along with that. */
2418 fdr_to_pst
= (struct pst_map
*)
2419 xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2420 old_chain
= make_cleanup (xfree
, fdr_to_pst
);
2423 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2425 fdr_to_pst
[-1].pst
= pst
;
2429 /* Allocate the global pending list. */
2431 ((struct mdebug_pending
**)
2432 obstack_alloc (&objfile
->objfile_obstack
,
2433 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2434 memset (pending_list
, 0,
2435 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2437 /* Pass 0 over external syms: swap them in. */
2438 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2439 make_cleanup (xfree
, ext_block
);
2441 ext_out
= (char *) debug_info
->external_ext
;
2442 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2444 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2445 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2447 /* Pass 1 over external syms: Presize and partition the list. */
2449 ext_in_end
= ext_in
+ hdr
->iextMax
;
2450 for (; ext_in
< ext_in_end
; ext_in
++)
2452 /* See calls to complain below. */
2453 if (ext_in
->ifd
>= -1
2454 && ext_in
->ifd
< hdr
->ifdMax
2455 && ext_in
->asym
.iss
>= 0
2456 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2457 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2460 /* Pass 1.5 over files: partition out global symbol space. */
2462 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2464 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2465 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2466 fdr_to_pst
[f_idx
].n_globals
= 0;
2471 For ECOFF in ELF, we skip the creation of the minimal symbols.
2472 The ECOFF symbols should be a subset of the Elf symbols, and the
2473 section information of the elf symbols will be more accurate.
2474 FIXME! What about Irix 5's native linker?
2476 By default, Elf sections which don't exist in ECOFF
2477 get put in ECOFF's absolute section by the gnu linker.
2478 Since absolute sections don't get relocated, we
2479 end up calculating an address different from that of
2480 the symbol's minimal symbol (created earlier from the
2483 To fix this, either :
2484 1) don't create the duplicate symbol
2485 (assumes ECOFF symtab is a subset of the ELF symtab;
2486 assumes no side-effects result from ignoring ECOFF symbol)
2487 2) create it, only if lookup for existing symbol in ELF's minimal
2490 assumes no side-effects result from ignoring ECOFF symbol)
2491 3) create it, but lookup ELF's minimal symbol and use it's section
2492 during relocation, then modify "uniqify" phase to merge and
2493 eliminate the duplicate symbol
2494 (highly inefficient)
2496 I've implemented #1 here...
2497 Skip the creation of the minimal symbols based on the ECOFF
2500 /* Pass 2 over external syms: fill in external symbols. */
2502 ext_in_end
= ext_in
+ hdr
->iextMax
;
2503 for (; ext_in
< ext_in_end
; ext_in
++)
2505 enum minimal_symbol_type ms_type
= mst_text
;
2506 CORE_ADDR svalue
= ext_in
->asym
.value
;
2508 /* The Irix 5 native tools seem to sometimes generate bogus
2509 external symbols. */
2510 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2512 complaint (&symfile_complaints
,
2513 _("bad ifd for external symbol: %d (max %ld)"),
2514 ext_in
->ifd
, hdr
->ifdMax
);
2517 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2519 complaint (&symfile_complaints
,
2520 _("bad iss for external symbol: %ld (max %ld)"),
2521 ext_in
->asym
.iss
, hdr
->issExtMax
);
2525 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2526 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2529 if (SC_IS_UNDEF (ext_in
->asym
.sc
) || ext_in
->asym
.sc
== scNil
)
2533 /* Pass 3 over files, over local syms: fill in static symbols. */
2534 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2536 /* Process ECOFF Symbol Types and Storage Classes. */
2537 switch (ext_in
->asym
.st
)
2540 /* Beginnning of Procedure */
2541 svalue
+= ANOFFSET (objfile
->section_offsets
,
2542 SECT_OFF_TEXT (objfile
));
2545 /* Load time only static procs */
2546 ms_type
= mst_file_text
;
2547 svalue
+= ANOFFSET (objfile
->section_offsets
,
2548 SECT_OFF_TEXT (objfile
));
2551 /* External symbol */
2552 if (SC_IS_COMMON (ext_in
->asym
.sc
))
2554 /* The value of a common symbol is its size, not its address.
2558 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2561 svalue
+= ANOFFSET (objfile
->section_offsets
,
2562 SECT_OFF_DATA (objfile
));
2564 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2567 svalue
+= ANOFFSET (objfile
->section_offsets
,
2568 SECT_OFF_BSS (objfile
));
2570 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2573 svalue
+= ANOFFSET (objfile
->section_offsets
,
2574 get_section_index (objfile
, ".sbss"));
2582 /* On certain platforms, some extra label symbols can be
2583 generated by the linker. One possible usage for this kind
2584 of symbols is to represent the address of the begining of a
2585 given section. For instance, on Tru64 5.1, the address of
2586 the _ftext label is the start address of the .text section.
2588 The storage class of these symbols is usually directly
2589 related to the section to which the symbol refers. For
2590 instance, on Tru64 5.1, the storage class for the _fdata
2591 label is scData, refering to the .data section.
2593 It is actually possible that the section associated to the
2594 storage class of the label does not exist. On True64 5.1
2595 for instance, the libm.so shared library does not contain
2596 any .data section, although it contains a _fpdata label
2597 which storage class is scData... Since these symbols are
2598 usually useless for the debugger user anyway, we just
2599 discard these symbols. */
2601 if (SC_IS_TEXT (ext_in
->asym
.sc
))
2603 if (objfile
->sect_index_text
== -1)
2606 ms_type
= mst_file_text
;
2607 svalue
+= ANOFFSET (objfile
->section_offsets
,
2608 SECT_OFF_TEXT (objfile
));
2610 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2612 if (objfile
->sect_index_data
== -1)
2615 ms_type
= mst_file_data
;
2616 svalue
+= ANOFFSET (objfile
->section_offsets
,
2617 SECT_OFF_DATA (objfile
));
2619 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2621 if (objfile
->sect_index_bss
== -1)
2624 ms_type
= mst_file_bss
;
2625 svalue
+= ANOFFSET (objfile
->section_offsets
,
2626 SECT_OFF_BSS (objfile
));
2628 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2630 const int sbss_sect_index
= get_section_index (objfile
, ".sbss");
2632 if (sbss_sect_index
== -1)
2635 ms_type
= mst_file_bss
;
2636 svalue
+= ANOFFSET (objfile
->section_offsets
, sbss_sect_index
);
2643 /* The alpha has the section start addresses in stLocal symbols
2644 whose name starts with a `.'. Skip those but complain for all
2645 other stLocal symbols.
2646 Irix6 puts the section start addresses in stNil symbols, skip
2652 ms_type
= mst_unknown
;
2653 unknown_ext_complaint (name
);
2655 if (!ECOFF_IN_ELF (cur_bfd
))
2656 record_minimal_symbol (name
, svalue
, ms_type
, ext_in
->asym
.sc
,
2660 /* Pass 3 over files, over local syms: fill in static symbols. */
2661 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2663 struct partial_symtab
*save_pst
;
2667 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2671 fdr_to_pst
[f_idx
].pst
= NULL
;
2675 /* Determine the start address for this object file from the
2676 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2680 if (relocatable
|| textlow
!= 0)
2681 textlow
+= ANOFFSET (objfile
->section_offsets
,
2682 SECT_OFF_TEXT (objfile
));
2686 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
2689 objfile
->global_psymbols
.next
,
2690 objfile
->static_psymbols
.next
);
2691 pst
->read_symtab_private
= obstack_alloc (&objfile
->objfile_obstack
,
2692 sizeof (struct symloc
));
2693 memset (pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2696 FDR_IDX (pst
) = f_idx
;
2697 CUR_BFD (pst
) = cur_bfd
;
2698 DEBUG_SWAP (pst
) = debug_swap
;
2699 DEBUG_INFO (pst
) = debug_info
;
2700 PENDING_LIST (pst
) = pending_list
;
2702 /* The way to turn this into a symtab is to call... */
2703 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2705 /* Set up language for the pst.
2706 The language from the FDR is used if it is unambigious (e.g. cfront
2707 with native cc and g++ will set the language to C).
2708 Otherwise we have to deduce the language from the filename.
2709 Native ecoff has every header file in a separate FDR, so
2710 deduce_language_from_filename will return language_unknown for
2711 a header file, which is not what we want.
2712 But the FDRs for the header files are after the FDR for the source
2713 file, so we can assign the language of the source file to the
2714 following header files. Then we save the language in the private
2715 pst data so that we can reuse it when building symtabs. */
2716 prev_language
= psymtab_language
;
2720 case langCplusplusV2
:
2721 psymtab_language
= language_cplus
;
2724 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2727 if (psymtab_language
== language_unknown
)
2728 psymtab_language
= prev_language
;
2729 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2731 pst
->texthigh
= pst
->textlow
;
2733 /* For stabs-in-ecoff files, the second symbol must be @stab.
2734 This symbol is emitted by mips-tfile to signal that the
2735 current object file uses encapsulated stabs instead of mips
2736 ecoff for local symbols. (It is the second symbol because
2737 the first symbol is the stFile used to signal the start of a
2739 processing_gcc_compilation
= 0;
2742 (*swap_sym_in
) (cur_bfd
,
2743 ((char *) debug_info
->external_sym
2744 + (fh
->isymBase
+ 1) * external_sym_size
),
2746 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2748 processing_gcc_compilation
= 2;
2751 if (processing_gcc_compilation
!= 0)
2753 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2756 const char *namestring
;
2758 (*swap_sym_in
) (cur_bfd
,
2759 (((char *) debug_info
->external_sym
)
2760 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2762 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2763 if (!ECOFF_IS_STAB (&sh
))
2765 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2770 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2771 SECT_OFF_TEXT (objfile
));
2772 if (sh
.st
== stStaticProc
)
2774 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2775 record_minimal_symbol (namestring
, sh
.value
,
2776 mst_file_text
, sh
.sc
,
2779 procaddr
= sh
.value
;
2781 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2782 (debug_info
->external_aux
2785 (*swap_sym_in
) (cur_bfd
,
2786 ((char *) debug_info
->external_sym
2787 + ((fh
->isymBase
+ isym
- 1)
2788 * external_sym_size
)),
2792 CORE_ADDR high
= procaddr
+ sh
.value
;
2794 /* Kludge for Irix 5.2 zero fh->adr. */
2796 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2797 pst
->textlow
= procaddr
;
2798 if (high
> pst
->texthigh
)
2799 pst
->texthigh
= high
;
2802 else if (sh
.st
== stStatic
)
2817 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2818 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2819 SECT_OFF_DATA (objfile
));
2820 record_minimal_symbol (namestring
, sh
.value
,
2821 mst_file_data
, sh
.sc
,
2826 /* FIXME! Shouldn't this use cases for bss,
2827 then have the default be abs? */
2828 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2829 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2830 SECT_OFF_BSS (objfile
));
2831 record_minimal_symbol (namestring
, sh
.value
,
2832 mst_file_bss
, sh
.sc
,
2839 /* Handle stabs continuation. */
2841 char *stabstring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2842 int len
= strlen (stabstring
);
2844 while (stabstring
[len
- 1] == '\\')
2847 char *stabstring1
= stabstring
;
2851 /* Ignore continuation char from 1st string. */
2854 /* Read next stabstring. */
2856 (*swap_sym_in
) (cur_bfd
,
2857 (((char *) debug_info
->external_sym
)
2858 + (fh
->isymBase
+ cur_sdx
)
2859 * external_sym_size
),
2861 stabstring2
= debug_info
->ss
+ fh
->issBase
+ sh2
.iss
;
2862 len2
= strlen (stabstring2
);
2864 /* Concatinate stabstring2 with stabstring1. */
2866 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
2867 stabstring
= xrealloc (stabstring
, len
+ len2
+ 1);
2870 stabstring
= xmalloc (len
+ len2
+ 1);
2871 strcpy (stabstring
, stabstring1
);
2873 strcpy (stabstring
+ len
, stabstring2
);
2881 /* Standard, external, non-debugger, symbols. */
2883 case N_TEXT
| N_EXT
:
2884 case N_NBTEXT
| N_EXT
:
2885 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2886 SECT_OFF_TEXT (objfile
));
2889 case N_DATA
| N_EXT
:
2890 case N_NBDATA
| N_EXT
:
2891 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2892 SECT_OFF_DATA (objfile
));
2897 case N_NBBSS
| N_EXT
:
2898 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
2899 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2900 SECT_OFF_BSS (objfile
));
2907 /* Standard, local, non-debugger, symbols. */
2911 /* We need to be able to deal with both N_FN or
2912 N_TEXT, because we have no way of knowing
2913 whether the sys-supplied ld or GNU ld was used
2914 to make the executable. Sequents throw in
2915 another wrinkle -- they renumbered N_FN. */
2923 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2924 SECT_OFF_DATA (objfile
));
2927 case N_UNDF
| N_EXT
:
2928 continue; /* Just undefined, not COMMON. */
2933 /* Lots of symbol types we can just ignore. */
2940 /* Keep going . . . */
2943 * Special symbol types for GNU
2946 case N_INDR
| N_EXT
:
2948 case N_SETA
| N_EXT
:
2950 case N_SETT
| N_EXT
:
2952 case N_SETD
| N_EXT
:
2954 case N_SETB
| N_EXT
:
2965 static int prev_so_symnum
= -10;
2966 static int first_so_symnum
;
2968 int prev_textlow_not_set
;
2970 valu
= sh
.value
+ ANOFFSET (objfile
->section_offsets
,
2971 SECT_OFF_TEXT (objfile
));
2973 prev_textlow_not_set
= textlow_not_set
;
2975 /* A zero value is probably an indication for the
2976 SunPRO 3.0 compiler. end_psymtab explicitly tests
2977 for zero, so don't relocate it. */
2980 && gdbarch_sofun_address_maybe_missing (gdbarch
))
2982 textlow_not_set
= 1;
2986 textlow_not_set
= 0;
2988 past_first_source_file
= 1;
2990 if (prev_so_symnum
!= symnum
- 1)
2991 { /* Here if prev stab wasn't N_SO. */
2992 first_so_symnum
= symnum
;
2996 pst
= (struct partial_symtab
*) 0;
2998 dependencies_used
= 0;
3002 prev_so_symnum
= symnum
;
3004 /* End the current partial symtab and start a
3007 /* SET_NAMESTRING ();*/
3008 namestring
= stabstring
;
3010 /* Null name means end of .o file. Don't start a new
3012 if (*namestring
== '\000')
3015 /* Some compilers (including gcc) emit a pair of
3016 initial N_SOs. The first one is a directory name;
3017 the second the file name. If pst exists, is
3018 empty, and has a filename ending in '/', we assume
3019 the previous N_SO was a directory name. */
3020 p
= lbasename (namestring
);
3021 if (p
!= namestring
&& *p
== '\000')
3022 continue; /* Simply ignore directory
3025 /* Some other compilers (C++ ones in particular) emit
3026 useless SOs for non-existant .c files. We ignore
3027 all subsequent SOs that immediately follow the
3040 enum language tmp_language
;
3042 /* Mark down an include file in the current psymtab. */
3044 /* SET_NAMESTRING (); */
3045 namestring
= stabstring
;
3048 = deduce_language_from_filename (namestring
);
3050 /* Only change the psymtab's language if we've
3051 learned something useful (eg. tmp_language is not
3052 language_unknown). In addition, to match what
3053 start_subfile does, never change from C++ to
3055 if (tmp_language
!= language_unknown
3056 && (tmp_language
!= language_c
3057 || psymtab_language
!= language_cplus
))
3058 psymtab_language
= tmp_language
;
3060 /* In C++, one may expect the same filename to come
3061 round many times, when code is coming alternately
3062 from the main file and from inline functions in
3063 other files. So I check to see if this is a file
3064 we've seen before -- either the main source file,
3065 or a previously included file.
3067 This seems to be a lot of time to be spending on
3068 N_SOL, but things like "break c-exp.y:435" need to
3069 work (I suppose the psymtab_include_list could be
3070 hashed or put in a binary tree, if profiling shows
3071 this is a major hog). */
3072 if (pst
&& filename_cmp (namestring
, pst
->filename
) == 0)
3078 for (i
= 0; i
< includes_used
; i
++)
3079 if (filename_cmp (namestring
,
3080 psymtab_include_list
[i
]) == 0)
3089 psymtab_include_list
[includes_used
++] = namestring
;
3090 if (includes_used
>= includes_allocated
)
3092 const char **orig
= psymtab_include_list
;
3094 psymtab_include_list
= (const char **)
3095 alloca ((includes_allocated
*= 2) *
3096 sizeof (const char *));
3097 memcpy (psymtab_include_list
, orig
,
3098 includes_used
* sizeof (const char *));
3102 case N_LSYM
: /* Typedef or automatic variable. */
3103 case N_STSYM
: /* Data seg var -- static */
3104 case N_LCSYM
: /* BSS " */
3105 case N_ROSYM
: /* Read-only data seg var -- static. */
3106 case N_NBSTS
: /* Gould nobase. */
3107 case N_NBLCS
: /* symbols. */
3109 case N_GSYM
: /* Global (extern) variable; can be
3110 data or bss (sigh FIXME). */
3112 /* Following may probably be ignored; I'll leave them here
3113 for now (until I do Pascal and Modula 2 extensions). */
3115 case N_PC
: /* I may or may not need this; I
3117 case N_M2C
: /* I suspect that I can ignore this
3119 case N_SCOPE
: /* Same. */
3121 /* SET_NAMESTRING (); */
3122 namestring
= stabstring
;
3123 p
= (char *) strchr (namestring
, ':');
3125 continue; /* Not a debugging symbol. */
3129 /* Main processing section for debugging symbols which
3130 the initial read through the symbol tables needs to
3131 worry about. If we reach this point, the symbol
3132 which we are considering is definitely one we are
3133 interested in. p must also contain the (valid)
3134 index into the namestring which indicates the
3135 debugging type symbol. */
3140 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3141 SECT_OFF_DATA (objfile
));
3143 if (gdbarch_static_transform_name_p (gdbarch
))
3144 namestring
= gdbarch_static_transform_name
3145 (gdbarch
, namestring
);
3147 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3148 VAR_DOMAIN
, LOC_STATIC
,
3149 &objfile
->static_psymbols
,
3151 psymtab_language
, objfile
);
3154 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3155 SECT_OFF_DATA (objfile
));
3156 /* The addresses in these entries are reported
3157 to be wrong. See the code that reads 'G's
3159 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3160 VAR_DOMAIN
, LOC_STATIC
,
3161 &objfile
->global_psymbols
,
3163 psymtab_language
, objfile
);
3167 /* When a 'T' entry is defining an anonymous enum, it
3168 may have a name which is the empty string, or a
3169 single space. Since they're not really defining a
3170 symbol, those shouldn't go in the partial symbol
3171 table. We do pick up the elements of such enums at
3172 'check_enum:', below. */
3173 if (p
>= namestring
+ 2
3174 || (p
== namestring
+ 1
3175 && namestring
[0] != ' '))
3177 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3178 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3179 &objfile
->static_psymbols
,
3181 psymtab_language
, objfile
);
3184 /* Also a typedef with the same name. */
3185 add_psymbol_to_list (namestring
,
3187 VAR_DOMAIN
, LOC_TYPEDEF
,
3188 &objfile
->static_psymbols
,
3197 if (p
!= namestring
) /* a name is there, not
3200 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3201 VAR_DOMAIN
, LOC_TYPEDEF
,
3202 &objfile
->static_psymbols
,
3204 psymtab_language
, objfile
);
3207 /* If this is an enumerated type, we need to add
3208 all the enum constants to the partial symbol
3209 table. This does not cover enums without names,
3210 e.g. "enum {a, b} c;" in C, but fortunately
3211 those are rare. There is no way for GDB to find
3212 those from the enum type without spending too
3213 much time on it. Thus to solve this problem,
3214 the compiler needs to put out the enum in a
3215 nameless type. GCC2 does this. */
3217 /* We are looking for something of the form
3218 <name> ":" ("t" | "T") [<number> "="] "e"
3219 {<constant> ":" <value> ","} ";". */
3221 /* Skip over the colon and the 't' or 'T'. */
3223 /* This type may be given a number. Also, numbers
3224 can come in pairs like (0,26). Skip over it. */
3225 while ((*p
>= '0' && *p
<= '9')
3226 || *p
== '(' || *p
== ',' || *p
== ')'
3232 /* The aix4 compiler emits extra crud before
3236 /* Skip over the type (?). */
3240 /* Skip over the colon. */
3244 /* We have found an enumerated type. */
3245 /* According to comments in read_enum_type
3246 a comma could end it instead of a semicolon.
3247 I don't know where that happens.
3249 while (*p
&& *p
!= ';' && *p
!= ',')
3253 /* Check for and handle cretinous dbx
3254 symbol name continuation! */
3255 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
3256 p
= next_symbol_text (objfile
);
3258 /* Point to the character after the name
3259 of the enum constant. */
3260 for (q
= p
; *q
&& *q
!= ':'; q
++)
3262 /* Note that the value doesn't matter for
3263 enum constants in psymtabs, just in
3265 add_psymbol_to_list (p
, q
- p
, 1,
3266 VAR_DOMAIN
, LOC_CONST
,
3267 &objfile
->static_psymbols
,
3268 0, 0, psymtab_language
,
3270 /* Point past the name. */
3272 /* Skip over the value. */
3273 while (*p
&& *p
!= ',')
3275 /* Advance past the comma. */
3282 /* Constant, e.g. from "const" in Pascal. */
3283 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3284 VAR_DOMAIN
, LOC_CONST
,
3285 &objfile
->static_psymbols
,
3286 sh
.value
, 0, psymtab_language
,
3293 int name_len
= p
- namestring
;
3294 char *name
= xmalloc (name_len
+ 1);
3296 memcpy (name
, namestring
, name_len
);
3297 name
[name_len
] = '\0';
3298 function_outside_compilation_unit_complaint (name
);
3301 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3302 SECT_OFF_TEXT (objfile
));
3303 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3304 VAR_DOMAIN
, LOC_BLOCK
,
3305 &objfile
->static_psymbols
,
3307 psymtab_language
, objfile
);
3310 /* Global functions were ignored here, but now they
3311 are put into the global psymtab like one would
3312 expect. They're also in the minimal symbol
3317 int name_len
= p
- namestring
;
3318 char *name
= xmalloc (name_len
+ 1);
3320 memcpy (name
, namestring
, name_len
);
3321 name
[name_len
] = '\0';
3322 function_outside_compilation_unit_complaint (name
);
3325 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3326 SECT_OFF_TEXT (objfile
));
3327 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3328 VAR_DOMAIN
, LOC_BLOCK
,
3329 &objfile
->global_psymbols
,
3331 psymtab_language
, objfile
);
3334 /* Two things show up here (hopefully); static
3335 symbols of local scope (static used inside
3336 braces) or extensions of structure symbols. We
3351 case '#': /* For symbol identification (used
3356 /* It is a C++ nested symbol. We don't need to
3357 record it (I don't think); if we try to look up
3358 foo::bar::baz, then symbols for the symtab
3359 containing foo should get read in, I think. */
3360 /* Someone says sun cc puts out symbols like
3361 /foo/baz/maclib::/usr/local/bin/maclib,
3362 which would get here with a symbol type of ':'. */
3366 /* Unexpected symbol descriptor. The second and
3367 subsequent stabs of a continued stab can show up
3368 here. The question is whether they ever can
3369 mimic a normal stab--it would be nice if not,
3370 since we certainly don't want to spend the time
3371 searching to the end of every string looking for
3374 complaint (&symfile_complaints
,
3375 _("unknown symbol descriptor `%c'"), p
[1]);
3377 /* Ignore it; perhaps it is an extension that we don't
3386 /* Solaris 2 end of module, finish current partial
3387 symbol table. END_PSYMTAB will set
3388 pst->texthigh to the proper value, which is
3389 necessary if a module compiled without
3390 debugging info follows this module. */
3392 && gdbarch_sofun_address_maybe_missing (gdbarch
))
3394 pst
= (struct partial_symtab
*) 0;
3396 dependencies_used
= 0;
3401 if (sh
.value
> save_pst
->texthigh
)
3402 save_pst
->texthigh
= sh
.value
;
3407 case N_SSYM
: /* Claim: Structure or union
3408 element. Hopefully, I can
3410 case N_ENTRY
: /* Alternate entry point; can
3412 case N_MAIN
: /* Can definitely ignore this. */
3413 case N_CATCH
: /* These are GNU C++ extensions. */
3414 case N_EHDECL
: /* that can safely be ignored here. */
3424 case N_NSYMS
: /* Ultrix 4.0: symbol count */
3425 case N_DEFD
: /* GNU Modula-2 */
3426 case N_ALIAS
: /* SunPro F77: alias name, ignore
3429 case N_OBJ
: /* Useless types from Solaris. */
3431 /* These symbols aren't interesting; don't worry about
3437 /* If we haven't found it yet, ignore it. It's
3438 probably some new type we don't know about yet. */
3439 complaint (&symfile_complaints
,
3440 _("unknown symbol type %s"),
3441 hex_string (type_code
)); /* CUR_SYMBOL_TYPE */
3445 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
3448 /* end - Handle continuation */
3453 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
3456 enum address_class
class;
3458 (*swap_sym_in
) (cur_bfd
,
3459 ((char *) debug_info
->external_sym
3460 + ((fh
->isymBase
+ cur_sdx
)
3461 * external_sym_size
)),
3464 if (ECOFF_IS_STAB (&sh
))
3470 /* Non absolute static symbols go into the minimal table. */
3471 if (SC_IS_UNDEF (sh
.sc
) || sh
.sc
== scNil
3472 || (sh
.index
== indexNil
3473 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
3475 /* FIXME, premature? */
3480 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3486 /* The value of a stEnd symbol is the displacement from the
3487 corresponding start symbol value, do not relocate it. */
3489 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3490 SECT_OFF_TEXT (objfile
));
3497 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3498 SECT_OFF_DATA (objfile
));
3502 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3503 SECT_OFF_BSS (objfile
));
3514 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3516 SECT_OFF_TEXT (objfile
),
3522 /* Ignore all parameter symbol records. */
3523 if (sh
.index
>= hdr
->iauxMax
)
3525 /* Should not happen, but does when cross-compiling
3526 with the MIPS compiler. FIXME -- pull later. */
3527 index_complaint (name
);
3528 new_sdx
= cur_sdx
+ 1; /* Don't skip at all. */
3531 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
3532 (debug_info
->external_aux
3536 if (new_sdx
<= cur_sdx
)
3538 /* This should not happen either... FIXME. */
3539 complaint (&symfile_complaints
,
3540 _("bad proc end in aux found from symbol %s"),
3542 new_sdx
= cur_sdx
+ 1; /* Don't skip backward. */
3545 /* For stProc symbol records, we need to check the
3546 storage class as well, as only (stProc, scText)
3547 entries represent "real" procedures - See the
3548 Compaq document titled "Object File / Symbol Table
3549 Format Specification" for more information. If the
3550 storage class is not scText, we discard the whole
3551 block of symbol records for this stProc. */
3552 if (sh
.st
== stProc
&& sh
.sc
!= scText
)
3555 /* Usually there is a local and a global stProc symbol
3556 for a function. This means that the function name
3557 has already been entered into the mimimal symbol table
3558 while processing the global symbols in pass 2 above.
3559 One notable exception is the PROGRAM name from
3560 f77 compiled executables, it is only put out as
3561 local stProc symbol, and a global MAIN__ stProc symbol
3562 points to it. It doesn't matter though, as gdb is
3563 still able to find the PROGRAM name via the partial
3564 symbol table, and the MAIN__ symbol via the minimal
3566 if (sh
.st
== stProc
)
3567 add_psymbol_to_list (name
, strlen (name
), 1,
3568 VAR_DOMAIN
, LOC_BLOCK
,
3569 &objfile
->global_psymbols
,
3570 0, sh
.value
, psymtab_language
, objfile
);
3572 add_psymbol_to_list (name
, strlen (name
), 1,
3573 VAR_DOMAIN
, LOC_BLOCK
,
3574 &objfile
->static_psymbols
,
3575 0, sh
.value
, psymtab_language
, objfile
);
3577 procaddr
= sh
.value
;
3580 (*swap_sym_in
) (cur_bfd
,
3581 ((char *) debug_info
->external_sym
3582 + ((fh
->isymBase
+ cur_sdx
- 1)
3583 * external_sym_size
)),
3588 /* Kludge for Irix 5.2 zero fh->adr. */
3590 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
3591 pst
->textlow
= procaddr
;
3593 high
= procaddr
+ sh
.value
;
3594 if (high
> pst
->texthigh
)
3595 pst
->texthigh
= high
;
3598 case stStatic
: /* Variable */
3599 if (SC_IS_DATA (sh
.sc
))
3600 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3602 SECT_OFF_DATA (objfile
),
3606 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3608 SECT_OFF_BSS (objfile
),
3614 case stIndirect
: /* Irix5 forward declaration */
3615 /* Skip forward declarations from Irix5 cc. */
3618 case stTypedef
: /* Typedef */
3619 /* Skip typedefs for forward declarations and opaque
3620 structs from alpha and mips cc. */
3621 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
3623 class = LOC_TYPEDEF
;
3626 case stConstant
: /* Constant decl */
3633 case stBlock
: /* { }, str, un, enum */
3634 /* Do not create a partial symbol for cc unnamed aggregates
3635 and gcc empty aggregates. */
3636 if ((sh
.sc
== scInfo
3637 || SC_IS_COMMON (sh
.sc
))
3639 && sh
.index
!= cur_sdx
+ 2)
3641 add_psymbol_to_list (name
, strlen (name
), 1,
3642 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3643 &objfile
->static_psymbols
,
3645 psymtab_language
, objfile
);
3647 handle_psymbol_enumerators (objfile
, fh
, sh
.st
, sh
.value
);
3649 /* Skip over the block. */
3651 if (new_sdx
<= cur_sdx
)
3653 /* This happens with the Ultrix kernel. */
3654 complaint (&symfile_complaints
,
3655 _("bad aux index at block symbol %s"), name
);
3656 new_sdx
= cur_sdx
+ 1; /* Don't skip backward. */
3661 case stFile
: /* File headers */
3662 case stLabel
: /* Labels */
3663 case stEnd
: /* Ends of files */
3666 case stLocal
: /* Local variables */
3667 /* Normally these are skipped because we skip over
3668 all blocks we see. However, these can occur
3669 as visible symbols in a .h file that contains code. */
3673 /* Both complaints are valid: one gives symbol name,
3674 the other the offending symbol type. */
3675 complaint (&symfile_complaints
, _("unknown local symbol %s"),
3677 complaint (&symfile_complaints
, _("with type %d"), sh
.st
);
3681 /* Use this gdb symbol. */
3682 add_psymbol_to_list (name
, strlen (name
), 1,
3684 &objfile
->static_psymbols
,
3685 0, sh
.value
, psymtab_language
, objfile
);
3687 cur_sdx
++; /* Go to next file symbol. */
3690 /* Now do enter the external symbols. */
3691 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
3692 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
3693 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
3694 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
3695 for (; --cur_sdx
>= 0; ext_ptr
++)
3697 enum address_class
class;
3702 if (ext_ptr
->ifd
!= f_idx
)
3703 internal_error (__FILE__
, __LINE__
,
3704 _("failed internal consistency check"));
3705 psh
= &ext_ptr
->asym
;
3707 /* Do not add undefined symbols to the partial symbol table. */
3708 if (SC_IS_UNDEF (psh
->sc
) || psh
->sc
== scNil
)
3711 svalue
= psh
->value
;
3716 svalue
+= ANOFFSET (objfile
->section_offsets
,
3717 SECT_OFF_TEXT (objfile
));
3724 svalue
+= ANOFFSET (objfile
->section_offsets
,
3725 SECT_OFF_DATA (objfile
));
3729 svalue
+= ANOFFSET (objfile
->section_offsets
,
3730 SECT_OFF_BSS (objfile
));
3737 /* These are generated for static symbols in .o files,
3742 /* External procedure symbols have been entered
3743 into the minimal symbol table in pass 2 above.
3744 Ignore them, as parse_external will ignore them too. */
3750 unknown_ext_complaint (debug_info
->ssext
+ psh
->iss
);
3751 /* Fall through, pretend it's global. */
3753 /* Global common symbols are resolved by the runtime loader,
3755 if (SC_IS_COMMON (psh
->sc
))
3761 name
= debug_info
->ssext
+ psh
->iss
;
3762 add_psymbol_to_list (name
, strlen (name
), 1,
3764 &objfile
->global_psymbols
,
3766 psymtab_language
, objfile
);
3770 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3771 empty and put on the free list. */
3772 fdr_to_pst
[f_idx
].pst
= end_psymtab (objfile
, save_pst
,
3773 psymtab_include_list
, includes_used
,
3774 -1, save_pst
->texthigh
,
3775 dependency_list
, dependencies_used
, textlow_not_set
);
3777 dependencies_used
= 0;
3779 /* The objfile has its functions reordered if this partial symbol
3780 table overlaps any other partial symbol table.
3781 We cannot assume a reordered objfile if a partial symbol table
3782 is contained within another partial symbol table, as partial symbol
3783 tables for include files with executable code are contained
3784 within the partial symbol table for the including source file,
3785 and we do not want to flag the objfile reordered for these cases.
3787 This strategy works well for Irix-5.2 shared libraries, but we
3788 might have to use a more elaborate (and slower) algorithm for
3790 save_pst
= fdr_to_pst
[f_idx
].pst
;
3791 if (save_pst
!= NULL
3792 && save_pst
->textlow
!= 0
3793 && !(objfile
->flags
& OBJF_REORDERED
))
3795 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
3798 && save_pst
->textlow
>= pst
->textlow
3799 && save_pst
->textlow
< pst
->texthigh
3800 && save_pst
->texthigh
> pst
->texthigh
)
3802 objfile
->flags
|= OBJF_REORDERED
;
3809 /* Now scan the FDRs for dependencies. */
3810 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3812 fh
= f_idx
+ debug_info
->fdr
;
3813 pst
= fdr_to_pst
[f_idx
].pst
;
3815 if (pst
== (struct partial_symtab
*) NULL
)
3818 /* This should catch stabs-in-ecoff. */
3822 /* Skip the first file indirect entry as it is a self dependency for
3823 source files or a reverse .h -> .c dependency for header files. */
3824 pst
->number_of_dependencies
= 0;
3826 ((struct partial_symtab
**)
3827 obstack_alloc (&objfile
->objfile_obstack
,
3829 * sizeof (struct partial_symtab
*))));
3830 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3834 (*swap_rfd_in
) (cur_bfd
,
3835 ((char *) debug_info
->external_rfd
3836 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3838 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3840 complaint (&symfile_complaints
, _("bad file number %ld"), rh
);
3844 /* Skip self dependencies of header files. */
3848 /* Do not add to dependeny list if psymtab was empty. */
3849 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*) NULL
)
3851 pst
->dependencies
[pst
->number_of_dependencies
++]
3852 = fdr_to_pst
[rh
].pst
;
3856 /* Remove the dummy psymtab created for -O3 images above, if it is
3857 still empty, to enable the detection of stripped executables. */
3858 if (objfile
->psymtabs
->next
== NULL
3859 && objfile
->psymtabs
->number_of_dependencies
== 0
3860 && objfile
->psymtabs
->n_global_syms
== 0
3861 && objfile
->psymtabs
->n_static_syms
== 0)
3862 objfile
->psymtabs
= NULL
;
3863 do_cleanups (old_chain
);
3866 /* If the current psymbol has an enumerated type, we need to add
3867 all the enum constants to the partial symbol table. */
3870 handle_psymbol_enumerators (struct objfile
*objfile
, FDR
*fh
, int stype
,
3873 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3874 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
3875 char *ext_sym
= ((char *) debug_info
->external_sym
3876 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3886 /* It is an enumerated type if the next symbol entry is a stMember
3887 and its auxiliary index is indexNil or its auxiliary entry
3888 is a plain btNil or btVoid.
3889 Alpha cc -migrate enums are recognized by a zero index and
3890 a zero symbol value.
3891 DU 4.0 cc enums are recognized by a member type of btEnum without
3892 qualifiers and a zero symbol value. */
3893 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3894 if (sh
.st
!= stMember
)
3897 if (sh
.index
== indexNil
3898 || (sh
.index
== 0 && svalue
== 0))
3900 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3901 &(debug_info
->external_aux
3902 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3904 if ((tir
.bt
!= btNil
3906 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3907 || tir
.tq0
!= tqNil
)
3919 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3920 if (sh
.st
!= stMember
)
3922 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3924 /* Note that the value doesn't matter for enum constants
3925 in psymtabs, just in symtabs. */
3926 add_psymbol_to_list (name
, strlen (name
), 1,
3927 VAR_DOMAIN
, LOC_CONST
,
3928 &objfile
->static_psymbols
, 0,
3929 (CORE_ADDR
) 0, psymtab_language
, objfile
);
3930 ext_sym
+= external_sym_size
;
3934 /* Get the next symbol. OBJFILE is unused. */
3937 mdebug_next_symbol_text (struct objfile
*objfile
)
3942 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3943 ((char *) debug_info
->external_sym
3944 + ((cur_fdr
->isymBase
+ cur_sdx
)
3945 * debug_swap
->external_sym_size
)),
3947 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3950 /* Ancillary function to psymtab_to_symtab(). Does all the work
3951 for turning the partial symtab PST into a symtab, recurring
3952 first on all dependent psymtabs. The argument FILENAME is
3953 only passed so we can see in debug stack traces what file
3956 This function has a split personality, based on whether the
3957 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3958 The flow of control and even the memory allocation differs. FIXME. */
3961 psymtab_to_symtab_1 (struct objfile
*objfile
,
3962 struct partial_symtab
*pst
, const char *filename
)
3964 bfd_size_type external_sym_size
;
3965 bfd_size_type external_pdr_size
;
3966 void (*swap_sym_in
) (bfd
*, void *, SYMR
*);
3967 void (*swap_pdr_in
) (bfd
*, void *, PDR
*);
3969 struct symtab
*st
= NULL
;
3971 struct linetable
*lines
;
3972 CORE_ADDR lowest_pdr_addr
= 0;
3973 int last_symtab_ended
= 0;
3979 /* Read in all partial symbtabs on which this one is dependent.
3980 NOTE that we do have circular dependencies, sigh. We solved
3981 that by setting pst->readin before this point. */
3983 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3984 if (!pst
->dependencies
[i
]->readin
)
3986 /* Inform about additional files to be read in. */
3989 fputs_filtered (" ", gdb_stdout
);
3991 fputs_filtered ("and ", gdb_stdout
);
3993 printf_filtered ("%s...",
3994 pst
->dependencies
[i
]->filename
);
3995 wrap_here (""); /* Flush output */
3996 gdb_flush (gdb_stdout
);
3998 /* We only pass the filename for debug purposes. */
3999 psymtab_to_symtab_1 (objfile
, pst
->dependencies
[i
],
4000 pst
->dependencies
[i
]->filename
);
4003 /* Do nothing if this is a dummy psymtab. */
4005 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
4006 && pst
->textlow
== 0 && pst
->texthigh
== 0)
4009 /* Now read the symbols for this symtab. */
4011 cur_bfd
= CUR_BFD (pst
);
4012 debug_swap
= DEBUG_SWAP (pst
);
4013 debug_info
= DEBUG_INFO (pst
);
4014 pending_list
= PENDING_LIST (pst
);
4015 external_sym_size
= debug_swap
->external_sym_size
;
4016 external_pdr_size
= debug_swap
->external_pdr_size
;
4017 swap_sym_in
= debug_swap
->swap_sym_in
;
4018 swap_pdr_in
= debug_swap
->swap_pdr_in
;
4019 mdebugread_objfile
= objfile
;
4020 cur_fd
= FDR_IDX (pst
);
4021 fh
= ((cur_fd
== -1)
4023 : debug_info
->fdr
+ cur_fd
);
4026 /* See comment in parse_partial_symbols about the @stabs sentinel. */
4027 processing_gcc_compilation
= 0;
4028 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
4032 (*swap_sym_in
) (cur_bfd
,
4033 ((char *) debug_info
->external_sym
4034 + (fh
->isymBase
+ 1) * external_sym_size
),
4036 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
4039 /* We indicate that this is a GCC compilation so that certain
4040 features will be enabled in stabsread/dbxread. */
4041 processing_gcc_compilation
= 2;
4045 if (processing_gcc_compilation
!= 0)
4047 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4049 /* This symbol table contains stabs-in-ecoff entries. */
4051 /* Parse local symbols first. */
4053 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr. */
4055 mdebugread_objfile
= NULL
;
4058 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
4064 (*swap_sym_in
) (cur_bfd
,
4065 (((char *) debug_info
->external_sym
)
4066 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
4068 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4070 /* XXX This is a hack. It will go away! */
4071 if (ECOFF_IS_STAB (&sh
) || (name
[0] == '#'))
4073 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
4075 /* We should never get non N_STAB symbols here, but they
4076 should be harmless, so keep process_one_symbol from
4077 complaining about them. */
4078 if (type_code
& N_STAB
)
4080 /* If we found a trailing N_SO with no name, process
4081 it here instead of in process_one_symbol, so we
4082 can keep a handle to its symtab. The symtab
4083 would otherwise be ended twice, once in
4084 process_one_symbol, and once after this loop. */
4085 if (type_code
== N_SO
4087 && previous_stab_code
!= (unsigned char) N_SO
4090 valu
+= ANOFFSET (pst
->section_offsets
,
4091 SECT_OFF_TEXT (objfile
));
4092 previous_stab_code
= N_SO
;
4093 st
= end_symtab (valu
, objfile
,
4094 SECT_OFF_TEXT (objfile
));
4096 last_symtab_ended
= 1;
4100 last_symtab_ended
= 0;
4101 process_one_symbol (type_code
, 0, valu
, name
,
4102 pst
->section_offsets
, objfile
);
4105 /* Similarly a hack. */
4106 else if (name
[0] == '#')
4108 process_one_symbol (N_SLINE
, 0, valu
, name
,
4109 pst
->section_offsets
, objfile
);
4111 if (type_code
== N_FUN
)
4113 /* Make up special symbol to contain
4114 procedure specific info. */
4115 struct mdebug_extra_func_info
*e
=
4116 ((struct mdebug_extra_func_info
*)
4117 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
4118 sizeof (struct mdebug_extra_func_info
)));
4119 struct symbol
*s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
4121 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
4122 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
4123 SYMBOL_CLASS (s
) = LOC_CONST
;
4124 SYMBOL_TYPE (s
) = objfile_type (objfile
)->builtin_void
;
4125 SYMBOL_VALUE_BYTES (s
) = (gdb_byte
*) e
;
4126 e
->pdr
.framereg
= -1;
4127 add_symbol_to_list (s
, &local_symbols
);
4130 else if (sh
.st
== stLabel
)
4132 if (sh
.index
== indexNil
)
4134 /* This is what the gcc2_compiled and __gnu_compiled_*
4135 show up as. So don't complain. */
4140 /* Handle encoded stab line number. */
4141 valu
+= ANOFFSET (pst
->section_offsets
,
4142 SECT_OFF_TEXT (objfile
));
4143 record_line (current_subfile
, sh
.index
,
4144 gdbarch_addr_bits_remove (gdbarch
, valu
));
4147 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
4148 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
4149 /* These are generated by gcc-2.x, do not complain. */
4152 complaint (&symfile_complaints
,
4153 _("unknown stabs symbol %s"), name
);
4156 if (! last_symtab_ended
)
4158 st
= end_symtab (pst
->texthigh
, objfile
,
4159 SECT_OFF_TEXT (objfile
));
4163 /* There used to be a call to sort_blocks here, but this should not
4164 be necessary for stabs symtabs. And as sort_blocks modifies the
4165 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
4166 it did the wrong thing if the first procedure in a file was
4167 generated via asm statements. */
4169 /* Fill in procedure info next. */
4173 struct cleanup
*old_chain
;
4179 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4180 old_chain
= make_cleanup (xfree
, pr_block
);
4182 pdr_ptr
= ((char *) debug_info
->external_pdr
4183 + fh
->ipdFirst
* external_pdr_size
);
4184 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4188 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4190 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4192 /* Determine lowest PDR address, the PDRs are not always
4194 if (pdr_in
== pr_block
)
4195 lowest_pdr_addr
= pdr_in
->adr
;
4196 else if (pdr_in
->adr
< lowest_pdr_addr
)
4197 lowest_pdr_addr
= pdr_in
->adr
;
4201 pdr_in_end
= pdr_in
+ fh
->cpd
;
4202 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4203 parse_procedure (pdr_in
, st
, pst
);
4205 do_cleanups (old_chain
);
4210 /* This symbol table contains ordinary ecoff entries. */
4218 st
= new_symtab ("unknown", 0, objfile
);
4222 maxlines
= 2 * fh
->cline
;
4223 st
= new_symtab (pst
->filename
, maxlines
, objfile
);
4225 /* The proper language was already determined when building
4226 the psymtab, use it. */
4227 st
->language
= PST_PRIVATE (pst
)->pst_language
;
4230 psymtab_language
= st
->language
;
4232 lines
= LINETABLE (st
);
4234 /* Get a new lexical context. */
4236 push_parse_stack ();
4237 top_stack
->cur_st
= st
;
4238 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
4240 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
4241 BLOCK_END (top_stack
->cur_block
) = 0;
4242 top_stack
->blocktype
= stFile
;
4243 top_stack
->cur_type
= 0;
4244 top_stack
->procadr
= 0;
4245 top_stack
->numargs
= 0;
4246 found_ecoff_debugging_info
= 0;
4253 /* Parse local symbols first. */
4254 sym_ptr
= ((char *) debug_info
->external_sym
4255 + fh
->isymBase
* external_sym_size
);
4256 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
4257 while (sym_ptr
< sym_end
)
4262 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
4263 c
= parse_symbol (&sh
,
4264 debug_info
->external_aux
+ fh
->iauxBase
,
4265 sym_ptr
, fh
->fBigendian
,
4266 pst
->section_offsets
, objfile
);
4267 sym_ptr
+= c
* external_sym_size
;
4270 /* Linenumbers. At the end, check if we can save memory.
4271 parse_lines has to look ahead an arbitrary number of PDR
4272 structures, so we swap them all first. */
4276 struct cleanup
*old_chain
;
4282 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4284 old_chain
= make_cleanup (xfree
, pr_block
);
4286 pdr_ptr
= ((char *) debug_info
->external_pdr
4287 + fh
->ipdFirst
* external_pdr_size
);
4288 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4292 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4294 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4296 /* Determine lowest PDR address, the PDRs are not always
4298 if (pdr_in
== pr_block
)
4299 lowest_pdr_addr
= pdr_in
->adr
;
4300 else if (pdr_in
->adr
< lowest_pdr_addr
)
4301 lowest_pdr_addr
= pdr_in
->adr
;
4304 parse_lines (fh
, pr_block
, lines
, maxlines
,
4305 pst
, lowest_pdr_addr
);
4306 if (lines
->nitems
< fh
->cline
)
4307 lines
= shrink_linetable (lines
);
4309 /* Fill in procedure info next. */
4311 pdr_in_end
= pdr_in
+ fh
->cpd
;
4312 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4313 parse_procedure (pdr_in
, 0, pst
);
4315 do_cleanups (old_chain
);
4319 size
= lines
->nitems
;
4322 LINETABLE (st
) = obstack_copy (&mdebugread_objfile
->objfile_obstack
,
4324 (sizeof (struct linetable
)
4325 + size
* sizeof (lines
->item
)));
4328 /* .. and our share of externals.
4329 XXX use the global list to speed up things here. How?
4330 FIXME, Maybe quit once we have found the right number of ext's? */
4331 top_stack
->cur_st
= st
;
4332 top_stack
->cur_block
4333 = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
4335 top_stack
->blocktype
= stFile
;
4337 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
4338 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
4339 parse_external (ext_ptr
, fh
->fBigendian
,
4340 pst
->section_offsets
, objfile
);
4342 /* If there are undefined symbols, tell the user.
4343 The alpha has an undefined symbol for every symbol that is
4344 from a shared library, so tell the user only if verbose is on. */
4345 if (info_verbose
&& n_undef_symbols
)
4347 printf_filtered (_("File %s contains %d unresolved references:"),
4348 st
->filename
, n_undef_symbols
);
4349 printf_filtered ("\n\t%4d variables\n\t%4d "
4350 "procedures\n\t%4d labels\n",
4351 n_undef_vars
, n_undef_procs
, n_undef_labels
);
4352 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
4362 /* Now link the psymtab and the symtab. */
4365 mdebugread_objfile
= NULL
;
4368 /* Ancillary parsing procedures. */
4370 /* Return 1 if the symbol pointed to by SH has a cross reference
4371 to an opaque aggregate type, else 0. */
4374 has_opaque_xref (FDR
*fh
, SYMR
*sh
)
4381 if (sh
->index
== indexNil
)
4384 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
4385 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
4386 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
4390 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
4391 if (rn
->rfd
== 0xfff)
4392 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
4400 /* Lookup the type at relative index RN. Return it in TPP
4401 if found and in any event come up with its name PNAME.
4402 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4403 Return value says how many aux symbols we ate. */
4406 cross_ref (int fd
, union aux_ext
*ax
, struct type
**tpp
,
4407 enum type_code type_code
,
4408 /* Use to alloc new type if none is found. */
4409 char **pname
, int bigend
, char *sym_name
)
4418 struct mdebug_pending
*pend
;
4420 *tpp
= (struct type
*) NULL
;
4422 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
4424 /* Escape index means 'the next one'. */
4425 if (rn
->rfd
== 0xfff)
4428 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
4435 /* mips cc uses a rf of -1 for opaque struct definitions.
4436 Set TYPE_FLAG_STUB for these types so that check_typedef will
4437 resolve them if the struct gets defined in another compilation unit. */
4440 *pname
= "<undefined>";
4441 *tpp
= init_type (type_code
, 0, TYPE_FLAG_STUB
,
4442 (char *) NULL
, mdebugread_objfile
);
4446 /* mips cc uses an escaped rn->index of 0 for struct return types
4447 of procedures that were compiled without -g. These will always remain
4449 if (rn
->rfd
== 0xfff && rn
->index
== 0)
4451 *pname
= "<undefined>";
4455 /* Find the relative file descriptor and the symbol in it. */
4456 fh
= get_rfd (fd
, rf
);
4457 xref_fd
= fh
- debug_info
->fdr
;
4459 if (rn
->index
>= fh
->csym
)
4461 /* File indirect entry is corrupt. */
4462 *pname
= "<illegal>";
4463 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4467 /* If we have processed this symbol then we left a forwarding
4468 pointer to the type in the pending list. If not, we`ll put
4469 it in a list of pending types, to be processed later when
4470 the file will be. In any event, we collect the name for the
4473 esh
= ((char *) debug_info
->external_sym
4474 + ((fh
->isymBase
+ rn
->index
)
4475 * debug_swap
->external_sym_size
));
4476 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
4478 /* Make sure that this type of cross reference can be handled. */
4479 if ((sh
.sc
!= scInfo
4480 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
4481 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
4482 && sh
.st
!= stEnum
))
4483 && (sh
.st
!= stBlock
|| !SC_IS_COMMON (sh
.sc
)))
4485 /* File indirect entry is corrupt. */
4486 *pname
= "<illegal>";
4487 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4491 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4493 pend
= is_pending_symbol (fh
, esh
);
4498 /* We have not yet seen this type. */
4500 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
4504 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4506 a) forward declarations of structs/unions/enums which are not
4507 defined in this compilation unit.
4508 For these the type will be void. This is a bad design decision
4509 as cross referencing across compilation units is impossible
4510 due to the missing name.
4511 b) forward declarations of structs/unions/enums/typedefs which
4512 are defined later in this file or in another file in the same
4513 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4514 Simply cross reference those again to get the true type.
4515 The forward references are not entered in the pending list and
4516 in the symbol table. */
4518 (*debug_swap
->swap_tir_in
) (bigend
,
4519 &(debug_info
->external_aux
4520 + fh
->iauxBase
+ sh
.index
)->a_ti
,
4522 if (tir
.tq0
!= tqNil
)
4523 complaint (&symfile_complaints
,
4524 _("illegal tq0 in forward typedef for %s"), sym_name
);
4528 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4529 mdebugread_objfile
);
4530 *pname
= "<undefined>";
4537 (debug_info
->external_aux
4538 + fh
->iauxBase
+ sh
.index
+ 1),
4539 tpp
, type_code
, pname
,
4540 fh
->fBigendian
, sym_name
);
4544 /* Follow a forward typedef. This might recursively
4545 call cross_ref till we get a non typedef'ed type.
4546 FIXME: This is not correct behaviour, but gdb currently
4547 cannot handle typedefs without type copying. Type
4548 copying is impossible as we might have mutual forward
4549 references between two files and the copied type would not
4550 get filled in when we later parse its definition. */
4551 *tpp
= parse_type (xref_fd
,
4552 debug_info
->external_aux
+ fh
->iauxBase
,
4556 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4557 add_pending (fh
, esh
, *tpp
);
4561 complaint (&symfile_complaints
,
4562 _("illegal bt %d in forward typedef for %s"), tir
.bt
,
4564 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4565 mdebugread_objfile
);
4570 else if (sh
.st
== stTypedef
)
4572 /* Parse the type for a normal typedef. This might recursively call
4573 cross_ref till we get a non typedef'ed type.
4574 FIXME: This is not correct behaviour, but gdb currently
4575 cannot handle typedefs without type copying. But type copying is
4576 impossible as we might have mutual forward references between
4577 two files and the copied type would not get filled in when
4578 we later parse its definition. */
4579 *tpp
= parse_type (xref_fd
,
4580 debug_info
->external_aux
+ fh
->iauxBase
,
4584 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4588 /* Cross reference to a struct/union/enum which is defined
4589 in another file in the same compilation unit but that file
4590 has not been parsed yet.
4591 Initialize the type only, it will be filled in when
4592 it's definition is parsed. */
4593 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, mdebugread_objfile
);
4595 add_pending (fh
, esh
, *tpp
);
4598 /* We used one auxent normally, two if we got a "next one" rf. */
4603 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4604 keeping the symtab sorted. */
4606 static struct symbol
*
4607 mylookup_symbol (char *name
, struct block
*block
,
4608 domain_enum domain
, enum address_class
class)
4610 struct block_iterator iter
;
4615 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
4617 if (SYMBOL_LINKAGE_NAME (sym
)[0] == inc
4618 && SYMBOL_DOMAIN (sym
) == domain
4619 && SYMBOL_CLASS (sym
) == class
4620 && strcmp (SYMBOL_LINKAGE_NAME (sym
), name
) == 0)
4624 block
= BLOCK_SUPERBLOCK (block
);
4626 return mylookup_symbol (name
, block
, domain
, class);
4631 /* Add a new symbol S to a block B. */
4634 add_symbol (struct symbol
*s
, struct symtab
*symtab
, struct block
*b
)
4636 SYMBOL_SYMTAB (s
) = symtab
;
4637 dict_add_symbol (BLOCK_DICT (b
), s
);
4640 /* Add a new block B to a symtab S. */
4643 add_block (struct block
*b
, struct symtab
*s
)
4645 struct blockvector
*bv
= BLOCKVECTOR (s
);
4647 bv
= (struct blockvector
*) xrealloc ((void *) bv
,
4648 (sizeof (struct blockvector
)
4649 + BLOCKVECTOR_NBLOCKS (bv
)
4650 * sizeof (bv
->block
)));
4651 if (bv
!= BLOCKVECTOR (s
))
4652 BLOCKVECTOR (s
) = bv
;
4654 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
4657 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4658 MIPS' linenumber encoding might need more than one byte
4659 to describe it, LAST is used to detect these continuation lines.
4661 Combining lines with the same line number seems like a bad idea.
4662 E.g: There could be a line number entry with the same line number after the
4663 prologue and GDB should not ignore it (this is a better way to find
4664 a prologue than mips_skip_prologue).
4665 But due to the compressed line table format there are line number entries
4666 for the same line which are needed to bridge the gap to the next
4667 line number entry. These entries have a bogus address info with them
4668 and we are unable to tell them from intended duplicate line number
4670 This is another reason why -ggdb debugging format is preferable. */
4673 add_line (struct linetable
*lt
, int lineno
, CORE_ADDR adr
, int last
)
4675 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4676 Change them to something sensible. */
4680 last
= -2; /* Make sure we record first line. */
4682 if (last
== lineno
) /* Skip continuation lines. */
4685 lt
->item
[lt
->nitems
].line
= lineno
;
4686 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
4690 /* Sorting and reordering procedures. */
4692 /* Blocks with a smaller low bound should come first. */
4695 compare_blocks (const void *arg1
, const void *arg2
)
4698 struct block
**b1
= (struct block
**) arg1
;
4699 struct block
**b2
= (struct block
**) arg2
;
4701 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
4703 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
4707 /* Sort the blocks of a symtab S.
4708 Reorder the blocks in the blockvector by code-address,
4709 as required by some MI search routines. */
4712 sort_blocks (struct symtab
*s
)
4714 struct blockvector
*bv
= BLOCKVECTOR (s
);
4716 if (BLOCKVECTOR_NBLOCKS (bv
) <= FIRST_LOCAL_BLOCK
)
4719 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
4720 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
4721 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
4722 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
4726 * This is very unfortunate: normally all functions are compiled in
4727 * the order they are found, but if the file is compiled -O3 things
4728 * are very different. It would be nice to find a reliable test
4729 * to detect -O3 images in advance.
4731 if (BLOCKVECTOR_NBLOCKS (bv
) > FIRST_LOCAL_BLOCK
+ 1)
4732 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
4733 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
4734 sizeof (struct block
*),
4739 int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
4741 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
4742 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
4743 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
4744 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
4747 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
4748 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
4750 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4751 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4752 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4753 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4757 /* Constructor/restructor/destructor procedures. */
4759 /* Allocate a new symtab for NAME. Needs an estimate of how many
4760 linenumbers MAXLINES we'll put in it. */
4762 static struct symtab
*
4763 new_symtab (const char *name
, int maxlines
, struct objfile
*objfile
)
4765 struct symtab
*s
= allocate_symtab (name
, objfile
);
4767 LINETABLE (s
) = new_linetable (maxlines
);
4769 /* All symtabs must have at least two blocks. */
4770 BLOCKVECTOR (s
) = new_bvect (2);
4771 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
)
4772 = new_block (NON_FUNCTION_BLOCK
);
4773 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
4774 = new_block (NON_FUNCTION_BLOCK
);
4775 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
4776 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4778 s
->debugformat
= "ECOFF";
4782 /* Allocate a new partial_symtab NAME. */
4784 static struct partial_symtab
*
4785 new_psymtab (char *name
, struct objfile
*objfile
)
4787 struct partial_symtab
*psymtab
;
4789 psymtab
= allocate_psymtab (name
, objfile
);
4790 psymtab
->section_offsets
= objfile
->section_offsets
;
4792 /* Keep a backpointer to the file's symbols. */
4794 psymtab
->read_symtab_private
= obstack_alloc (&objfile
->objfile_obstack
,
4795 sizeof (struct symloc
));
4796 memset (psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
4797 CUR_BFD (psymtab
) = cur_bfd
;
4798 DEBUG_SWAP (psymtab
) = debug_swap
;
4799 DEBUG_INFO (psymtab
) = debug_info
;
4800 PENDING_LIST (psymtab
) = pending_list
;
4802 /* The way to turn this into a symtab is to call... */
4803 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
4808 /* Allocate a linetable array of the given SIZE. Since the struct
4809 already includes one item, we subtract one when calculating the
4810 proper size to allocate. */
4812 static struct linetable
*
4813 new_linetable (int size
)
4815 struct linetable
*l
;
4819 size
= size
* sizeof (l
->item
) + sizeof (struct linetable
);
4820 l
= (struct linetable
*) xmalloc (size
);
4825 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4826 I am not so sure about the 3.4 ones.
4828 Since the struct linetable already includes one item, we subtract one when
4829 calculating the proper size to allocate. */
4831 static struct linetable
*
4832 shrink_linetable (struct linetable
*lt
)
4834 return (struct linetable
*) xrealloc ((void *) lt
,
4835 (sizeof (struct linetable
)
4837 * sizeof (lt
->item
))));
4840 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4842 static struct blockvector
*
4843 new_bvect (int nblocks
)
4845 struct blockvector
*bv
;
4848 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4849 bv
= (struct blockvector
*) xzalloc (size
);
4851 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4856 /* Allocate and zero a new block, and set its BLOCK_DICT. If function
4857 is non-zero, assume the block is associated to a function, and make
4858 sure that the symbols are stored linearly; otherwise, store them
4861 static struct block
*
4862 new_block (enum block_type type
)
4864 /* FIXME: carlton/2003-09-11: This should use allocate_block to
4865 allocate the block. Which, in turn, suggests that the block
4866 should be allocated on an obstack. */
4867 struct block
*retval
= xzalloc (sizeof (struct block
));
4869 if (type
== FUNCTION_BLOCK
)
4870 BLOCK_DICT (retval
) = dict_create_linear_expandable ();
4872 BLOCK_DICT (retval
) = dict_create_hashed_expandable ();
4877 /* Create a new symbol with printname NAME. */
4879 static struct symbol
*
4880 new_symbol (char *name
)
4882 struct symbol
*s
= ((struct symbol
*)
4883 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
4884 sizeof (struct symbol
)));
4886 memset (s
, 0, sizeof (*s
));
4887 SYMBOL_SET_LANGUAGE (s
, psymtab_language
);
4888 SYMBOL_SET_NAMES (s
, name
, strlen (name
), 1, mdebugread_objfile
);
4892 /* Create a new type with printname NAME. */
4894 static struct type
*
4895 new_type (char *name
)
4899 t
= alloc_type (mdebugread_objfile
);
4900 TYPE_NAME (t
) = name
;
4901 INIT_CPLUS_SPECIFIC (t
);
4905 /* Read ECOFF debugging information from a BFD section. This is
4906 called from elfread.c. It parses the section into a
4907 ecoff_debug_info struct, and then lets the rest of the file handle
4911 elfmdebug_build_psymtabs (struct objfile
*objfile
,
4912 const struct ecoff_debug_swap
*swap
, asection
*sec
)
4914 bfd
*abfd
= objfile
->obfd
;
4915 struct ecoff_debug_info
*info
;
4916 struct cleanup
*back_to
;
4918 /* FIXME: It's not clear whether we should be getting minimal symbol
4919 information from .mdebug in an ELF file, or whether we will.
4920 Re-initialize the minimal symbol reader in case we do. */
4922 init_minimal_symbol_collection ();
4923 back_to
= make_cleanup_discard_minimal_symbols ();
4925 info
= ((struct ecoff_debug_info
*)
4926 obstack_alloc (&objfile
->objfile_obstack
,
4927 sizeof (struct ecoff_debug_info
)));
4929 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4930 error (_("Error reading ECOFF debugging information: %s"),
4931 bfd_errmsg (bfd_get_error ()));
4933 mdebug_build_psymtabs (objfile
, swap
, info
);
4935 install_minimal_symbols (objfile
);
4936 do_cleanups (back_to
);
4940 _initialize_mdebugread (void)
4942 basic_type_data
= register_objfile_data ();