1 /* Read a symbol table in ECOFF format (Third-Eye).
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
6 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 /* This module provides the function mdebug_build_psymtabs. It reads
25 ECOFF debugging information into partial symbol tables. The
26 debugging information is read from two structures. A struct
27 ecoff_debug_swap includes the sizes of each ECOFF structure and
28 swapping routines; these are fixed for a particular target. A
29 struct ecoff_debug_info points to the debugging information for a
30 particular object file.
32 ECOFF symbol tables are mostly written in the byte order of the
33 target machine. However, one section of the table (the auxiliary
34 symbol information) is written in the host byte order. There is a
35 bit in the other symbol info which describes which host byte order
36 was used. ECOFF thereby takes the trophy from Intel `b.out' for
37 the most brain-dead adaptation of a file format to byte order.
39 This module can read all four of the known byte-order combinations,
40 on any type of host. */
46 #include "filenames.h"
48 #include "gdb_obstack.h"
50 #include "stabsread.h"
51 #include "complaints.h"
53 #include "gdb-demangle.h"
54 #include "gdb_assert.h"
56 #include "dictionary.h"
57 #include "mdebugread.h"
59 #include "gdb_string.h"
64 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files. */
66 #include "libaout.h" /* Private BFD a.out information. */
67 #include "aout/aout64.h"
68 #include "aout/stab_gnu.h" /* STABS information. */
70 #include "expression.h"
72 extern void _initialize_mdebugread (void);
74 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
75 We use this define in order to know whether we should override a
76 symbol's ECOFF section with its ELF section. This is necessary in
77 case the symbol's ELF section could not be represented in ECOFF. */
78 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
79 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
81 /* The objfile we are currently reading. */
83 static struct objfile
*mdebugread_objfile
;
87 /* We put a pointer to this structure in the read_symtab_private field
92 /* Index of the FDR that this psymtab represents. */
94 /* The BFD that the psymtab was created from. */
96 const struct ecoff_debug_swap
*debug_swap
;
97 struct ecoff_debug_info
*debug_info
;
98 struct mdebug_pending
**pending_list
;
99 /* Pointer to external symbols for this file. */
101 /* Size of extern_tab. */
103 enum language pst_language
;
106 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
107 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
108 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
109 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
110 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
111 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
113 #define SC_IS_TEXT(sc) ((sc) == scText \
114 || (sc) == scRConst \
117 #define SC_IS_DATA(sc) ((sc) == scData \
122 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
123 #define SC_IS_BSS(sc) ((sc) == scBss)
124 #define SC_IS_SBSS(sc) ((sc) == scSBss)
125 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
127 /* Various complaints about symbol reading that don't abort the process. */
129 index_complaint (const char *arg1
)
131 complaint (&symfile_complaints
, _("bad aux index at symbol %s"), arg1
);
135 unknown_ext_complaint (const char *arg1
)
137 complaint (&symfile_complaints
, _("unknown external symbol %s"), arg1
);
141 basic_type_complaint (int arg1
, const char *arg2
)
143 complaint (&symfile_complaints
, _("cannot map ECOFF basic type 0x%x for %s"),
148 bad_tag_guess_complaint (const char *arg1
)
150 complaint (&symfile_complaints
,
151 _("guessed tag type of %s incorrectly"), arg1
);
155 bad_rfd_entry_complaint (const char *arg1
, int arg2
, int arg3
)
157 complaint (&symfile_complaints
, _("bad rfd entry for %s: file %d, index %d"),
162 unexpected_type_code_complaint (const char *arg1
)
164 complaint (&symfile_complaints
, _("unexpected type code for %s"), arg1
);
167 /* Macros and extra defs. */
169 /* Puns: hard to find whether -g was used and how. */
171 #define MIN_GLEVEL GLEVEL_0
172 #define compare_glevel(a,b) \
173 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
174 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
176 /* Things that really are local to this module. */
178 /* Remember what we deduced to be the source language of this psymtab. */
180 static enum language psymtab_language
= language_unknown
;
186 /* How to parse debugging information for CUR_BFD. */
188 static const struct ecoff_debug_swap
*debug_swap
;
190 /* Pointers to debugging information for CUR_BFD. */
192 static struct ecoff_debug_info
*debug_info
;
194 /* Pointer to current file decriptor record, and its index. */
199 /* Index of current symbol. */
203 /* Note how much "debuggable" this image is. We would like
204 to see at least one FDR with full symbols. */
206 static int max_gdbinfo
;
207 static int max_glevel
;
209 /* When examining .o files, report on undefined symbols. */
211 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
213 /* Pseudo symbol to use when putting stabs into the symbol table. */
215 static char stabs_symbol
[] = STABS_SYMBOL
;
217 /* Nonzero if we have seen ecoff debugging info for a file. */
219 static int found_ecoff_debugging_info
;
221 /* Forward declarations. */
223 static int upgrade_type (int, struct type
**, int, union aux_ext
*,
226 static void parse_partial_symbols (struct objfile
*);
228 static int has_opaque_xref (FDR
*, SYMR
*);
230 static int cross_ref (int, union aux_ext
*, struct type
**, enum type_code
,
231 char **, int, char *);
233 static struct symbol
*new_symbol (char *);
235 static struct type
*new_type (char *);
237 enum block_type
{ FUNCTION_BLOCK
, NON_FUNCTION_BLOCK
};
239 static struct block
*new_block (enum block_type
);
241 static struct symtab
*new_symtab (const char *, int, struct objfile
*);
243 static struct linetable
*new_linetable (int);
245 static struct blockvector
*new_bvect (int);
247 static struct type
*parse_type (int, union aux_ext
*, unsigned int, int *,
250 static struct symbol
*mylookup_symbol (char *, struct block
*, domain_enum
,
253 static void sort_blocks (struct symtab
*);
255 static struct partial_symtab
*new_psymtab (char *, struct objfile
*);
257 static void psymtab_to_symtab_1 (struct objfile
*objfile
,
258 struct partial_symtab
*, const char *);
260 static void add_block (struct block
*, struct symtab
*);
262 static void add_symbol (struct symbol
*, struct symtab
*, struct block
*);
264 static int add_line (struct linetable
*, int, CORE_ADDR
, int);
266 static struct linetable
*shrink_linetable (struct linetable
*);
268 static void handle_psymbol_enumerators (struct objfile
*, FDR
*, int,
271 static char *mdebug_next_symbol_text (struct objfile
*);
273 /* Exported procedure: Builds a symtab from the PST partial one.
274 Restores the environment in effect when PST was created, delegates
275 most of the work to an ancillary procedure, and sorts
276 and reorders the symtab list at the end. */
279 mdebug_psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
286 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
287 gdb_flush (gdb_stdout
);
290 next_symbol_text_func
= mdebug_next_symbol_text
;
292 psymtab_to_symtab_1 (objfile
, pst
, pst
->filename
);
294 /* Match with global symbols. This only needs to be done once,
295 after all of the symtabs and dependencies have been read in. */
296 scan_file_globals (objfile
);
299 printf_filtered (_("done.\n"));
302 /* File-level interface functions. */
304 /* Find a file descriptor given its index RF relative to a file CF. */
307 get_rfd (int cf
, int rf
)
313 fdrs
= debug_info
->fdr
;
315 /* Object files do not have the RFD table, all refs are absolute. */
318 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
319 ((char *) debug_info
->external_rfd
321 * debug_swap
->external_rfd_size
)),
326 /* Return a safer print NAME for a file descriptor. */
332 return "<stripped file>";
335 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
339 /* Read in and parse the symtab of the file OBJFILE. Symbols from
340 different sections are relocated via the SECTION_OFFSETS. */
343 mdebug_build_psymtabs (struct objfile
*objfile
,
344 const struct ecoff_debug_swap
*swap
,
345 struct ecoff_debug_info
*info
)
347 cur_bfd
= objfile
->obfd
;
351 stabsread_new_init ();
352 buildsym_new_init ();
353 free_header_files ();
354 init_header_files ();
356 /* Make sure all the FDR information is swapped in. */
357 if (info
->fdr
== (FDR
*) NULL
)
363 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->objfile_obstack
,
364 (info
->symbolic_header
.ifdMax
366 fdr_src
= info
->external_fdr
;
368 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
370 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
371 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
374 parse_partial_symbols (objfile
);
377 /* Check to make sure file was compiled with -g. If not, warn the
378 user of this limitation. */
379 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
381 if (max_gdbinfo
== 0)
382 printf_unfiltered (_("\n%s not compiled with -g, "
383 "debugging support is limited.\n"),
385 printf_unfiltered (_("You should compile with -g2 or "
386 "-g3 for best debugging support.\n"));
387 gdb_flush (gdb_stdout
);
392 /* Local utilities */
394 /* Map of FDR indexes to partial symtabs. */
398 struct partial_symtab
*pst
; /* the psymtab proper */
399 long n_globals
; /* exported globals (external symbols) */
400 long globals_offset
; /* cumulative */
404 /* Utility stack, used to nest procedures and blocks properly.
405 It is a doubly linked list, to avoid too many alloc/free.
406 Since we might need it quite a few times it is NOT deallocated
409 static struct parse_stack
411 struct parse_stack
*next
, *prev
;
412 struct symtab
*cur_st
; /* Current symtab. */
413 struct block
*cur_block
; /* Block in it. */
415 /* What are we parsing. stFile, or stBlock are for files and
416 blocks. stProc or stStaticProc means we have seen the start of a
417 procedure, but not the start of the block within in. When we see
418 the start of that block, we change it to stNil, without pushing a
419 new block, i.e. stNil means both a procedure and a block. */
423 struct type
*cur_type
; /* Type we parse fields for. */
424 int cur_field
; /* Field number in cur_type. */
425 CORE_ADDR procadr
; /* Start addres of this procedure. */
426 int numargs
; /* Its argument count. */
429 *top_stack
; /* Top stack ptr */
432 /* Enter a new lexical context. */
435 push_parse_stack (void)
437 struct parse_stack
*new;
439 /* Reuse frames if possible. */
440 if (top_stack
&& top_stack
->prev
)
441 new = top_stack
->prev
;
443 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
444 /* Initialize new frame with previous content. */
447 struct parse_stack
*prev
= new->prev
;
450 top_stack
->prev
= new;
452 new->next
= top_stack
;
457 /* Exit a lexical context. */
460 pop_parse_stack (void)
465 top_stack
= top_stack
->next
;
469 /* Cross-references might be to things we haven't looked at
470 yet, e.g. type references. To avoid too many type
471 duplications we keep a quick fixup table, an array
472 of lists of references indexed by file descriptor. */
474 struct mdebug_pending
476 struct mdebug_pending
*next
; /* link */
477 char *s
; /* the unswapped symbol */
478 struct type
*t
; /* its partial type descriptor */
482 /* The pending information is kept for an entire object file. We
483 allocate the pending information table when we create the partial
484 symbols, and we store a pointer to the single table in each
487 static struct mdebug_pending
**pending_list
;
489 /* Check whether we already saw symbol SH in file FH. */
491 static struct mdebug_pending
*
492 is_pending_symbol (FDR
*fh
, char *sh
)
494 int f_idx
= fh
- debug_info
->fdr
;
495 struct mdebug_pending
*p
;
497 /* Linear search is ok, list is typically no more than 10 deep. */
498 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
504 /* Add a new symbol SH of type T. */
507 add_pending (FDR
*fh
, char *sh
, struct type
*t
)
509 int f_idx
= fh
- debug_info
->fdr
;
510 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
512 /* Make sure we do not make duplicates. */
515 p
= ((struct mdebug_pending
*)
516 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
517 sizeof (struct mdebug_pending
)));
520 p
->next
= pending_list
[f_idx
];
521 pending_list
[f_idx
] = p
;
526 /* Parsing Routines proper. */
528 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
529 For blocks, procedures and types we open a new lexical context.
530 This is basically just a big switch on the symbol's type. Argument
531 AX is the base pointer of aux symbols for this file (fh->iauxBase).
532 EXT_SH points to the unswapped symbol, which is needed for struct,
533 union, etc., types; it is NULL for an EXTR. BIGEND says whether
534 aux symbols are big-endian or little-endian. Return count of
535 SYMR's handled (normally one). */
538 mdebug_reg_to_regnum (struct symbol
*sym
, struct gdbarch
*gdbarch
)
540 return gdbarch_ecoff_reg_to_regnum (gdbarch
, SYMBOL_VALUE (sym
));
543 static const struct symbol_register_ops mdebug_register_funcs
= {
548 parse_symbol (SYMR
*sh
, union aux_ext
*ax
, char *ext_sh
, int bigend
,
549 struct section_offsets
*section_offsets
, struct objfile
*objfile
)
551 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
552 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
553 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
557 struct mdebug_pending
*pend
;
561 enum address_class
class;
563 long svalue
= sh
->value
;
566 if (ext_sh
== (char *) NULL
)
567 name
= debug_info
->ssext
+ sh
->iss
;
569 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
575 /* Do not relocate relative values.
576 The value of a stEnd symbol is the displacement from the
577 corresponding start symbol value.
578 The value of a stBlock symbol is the displacement from the
579 procedure address. */
580 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
581 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
588 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
592 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS (objfile
));
601 case stGlobal
: /* External symbol, goes into global block. */
603 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
605 s
= new_symbol (name
);
606 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
609 case stStatic
: /* Static data, goes into current block. */
611 b
= top_stack
->cur_block
;
612 s
= new_symbol (name
);
613 if (SC_IS_COMMON (sh
->sc
))
615 /* It is a FORTRAN common block. At least for SGI Fortran the
616 address is not in the symbol; we need to fix it later in
617 scan_file_globals. */
618 int bucket
= hashname (SYMBOL_LINKAGE_NAME (s
));
619 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
620 global_sym_chain
[bucket
] = s
;
623 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
626 case stLocal
: /* Local variable, goes into current block. */
627 b
= top_stack
->cur_block
;
628 s
= new_symbol (name
);
629 SYMBOL_VALUE (s
) = svalue
;
630 if (sh
->sc
== scRegister
)
632 class = LOC_REGISTER
;
633 SYMBOL_REGISTER_OPS (s
) = &mdebug_register_funcs
;
638 data
: /* Common code for symbols describing data. */
639 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
640 SYMBOL_CLASS (s
) = class;
641 add_symbol (s
, top_stack
->cur_st
, b
);
643 /* Type could be missing if file is compiled without debugging info. */
644 if (SC_IS_UNDEF (sh
->sc
)
645 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
646 SYMBOL_TYPE (s
) = objfile_type (objfile
)->nodebug_data_symbol
;
648 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
649 /* Value of a data symbol is its memory address. */
652 case stParam
: /* Arg to procedure, goes into current
655 found_ecoff_debugging_info
= 1;
656 top_stack
->numargs
++;
658 /* Special GNU C++ name. */
659 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
660 name
= "this"; /* FIXME, not alloc'd in obstack. */
661 s
= new_symbol (name
);
663 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
664 SYMBOL_IS_ARGUMENT (s
) = 1;
668 /* Pass by value in register. */
669 SYMBOL_CLASS (s
) = LOC_REGISTER
;
670 SYMBOL_REGISTER_OPS (s
) = &mdebug_register_funcs
;
673 /* Pass by reference on stack. */
674 SYMBOL_CLASS (s
) = LOC_REF_ARG
;
677 /* Pass by reference in register. */
678 SYMBOL_CLASS (s
) = LOC_REGPARM_ADDR
;
679 SYMBOL_REGISTER_OPS (s
) = &mdebug_register_funcs
;
682 /* Pass by value on stack. */
683 SYMBOL_CLASS (s
) = LOC_ARG
;
686 SYMBOL_VALUE (s
) = svalue
;
687 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
688 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
691 case stLabel
: /* label, goes into current block. */
692 s
= new_symbol (name
);
693 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
; /* So that it can be used */
694 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused. */
695 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
696 SYMBOL_TYPE (s
) = objfile_type (objfile
)->builtin_int
;
697 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
700 case stProc
: /* Procedure, usually goes into global block. */
701 case stStaticProc
: /* Static procedure, goes into current block. */
702 /* For stProc symbol records, we need to check the storage class
703 as well, as only (stProc, scText) entries represent "real"
704 procedures - See the Compaq document titled "Object File /
705 Symbol Table Format Specification" for more information.
706 If the storage class is not scText, we discard the whole block
707 of symbol records for this stProc. */
708 if (sh
->st
== stProc
&& sh
->sc
!= scText
)
710 char *ext_tsym
= ext_sh
;
711 int keep_counting
= 1;
714 while (keep_counting
)
716 ext_tsym
+= external_sym_size
;
717 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
727 complaint (&symfile_complaints
,
728 _("unknown symbol type 0x%x"), sh
->st
);
734 s
= new_symbol (name
);
735 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
736 SYMBOL_CLASS (s
) = LOC_BLOCK
;
737 /* Type of the return value. */
738 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
739 t
= objfile_type (objfile
)->builtin_int
;
742 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
743 if (strcmp (name
, "malloc") == 0
744 && TYPE_CODE (t
) == TYPE_CODE_VOID
)
746 /* I don't know why, but, at least under Alpha GNU/Linux,
747 when linking against a malloc without debugging
748 symbols, its read as a function returning void---this
749 is bad because it means we cannot call functions with
750 string arguments interactively; i.e., "call
751 printf("howdy\n")" would fail with the error message
752 "program has no memory available". To avoid this, we
753 patch up the type and make it void*
754 instead. (davidm@azstarnet.com). */
755 t
= make_pointer_type (t
, NULL
);
758 b
= top_stack
->cur_block
;
759 if (sh
->st
== stProc
)
761 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
763 /* The next test should normally be true, but provides a
764 hook for nested functions (which we don't want to make
766 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
767 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
768 /* Irix 5 sometimes has duplicate names for the same
769 function. We want to add such names up at the global
770 level, not as a nested function. */
771 else if (sh
->value
== top_stack
->procadr
)
772 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
774 add_symbol (s
, top_stack
->cur_st
, b
);
776 /* Make a type for the procedure itself. */
777 SYMBOL_TYPE (s
) = lookup_function_type (t
);
779 /* All functions in C++ have prototypes. For C we don't have enough
780 information in the debug info. */
781 if (SYMBOL_LANGUAGE (s
) == language_cplus
)
782 TYPE_PROTOTYPED (SYMBOL_TYPE (s
)) = 1;
784 /* Create and enter a new lexical context. */
785 b
= new_block (FUNCTION_BLOCK
);
786 SYMBOL_BLOCK_VALUE (s
) = b
;
787 BLOCK_FUNCTION (b
) = s
;
788 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
789 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
790 add_block (b
, top_stack
->cur_st
);
792 /* Not if we only have partial info. */
793 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
797 top_stack
->cur_block
= b
;
798 top_stack
->blocktype
= sh
->st
;
799 top_stack
->cur_type
= SYMBOL_TYPE (s
);
800 top_stack
->cur_field
= -1;
801 top_stack
->procadr
= sh
->value
;
802 top_stack
->numargs
= 0;
805 /* Beginning of code for structure, union, and enum definitions.
806 They all share a common set of local variables, defined here. */
808 enum type_code type_code
;
814 case stStruct
: /* Start a block defining a struct type. */
815 type_code
= TYPE_CODE_STRUCT
;
816 goto structured_common
;
818 case stUnion
: /* Start a block defining a union type. */
819 type_code
= TYPE_CODE_UNION
;
820 goto structured_common
;
822 case stEnum
: /* Start a block defining an enum type. */
823 type_code
= TYPE_CODE_ENUM
;
824 goto structured_common
;
826 case stBlock
: /* Either a lexical block, or some type. */
827 if (sh
->sc
!= scInfo
&& !SC_IS_COMMON (sh
->sc
))
828 goto case_stBlock_code
; /* Lexical block */
830 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
832 /* Common code for handling struct, union, enum, and/or as-yet-
833 unknown-type blocks of info about structured data. `type_code'
834 has been set to the proper TYPE_CODE, if we know it. */
836 found_ecoff_debugging_info
= 1;
838 top_stack
->blocktype
= stBlock
;
840 /* First count the number of fields and the highest value. */
843 for (ext_tsym
= ext_sh
+ external_sym_size
;
845 ext_tsym
+= external_sym_size
)
849 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
854 /* C++ encodes class types as structures where there the
855 methods are encoded as stProc. The scope of stProc
856 symbols also ends with stEnd, thus creating a risk of
857 taking the wrong stEnd symbol record as the end of
858 the current struct, which would cause GDB to undercount
859 the real number of fields in this struct. To make sure
860 we really reached the right stEnd symbol record, we
861 check the associated name, and match it against the
862 struct name. Since method names are mangled while
863 the class name is not, there is no risk of having a
864 method whose name is identical to the class name
865 (in particular constructor method names are different
866 from the class name). There is therefore no risk that
867 this check stops the count on the StEnd of a method.
869 Also, assume that we're really at the end when tsym.iss
871 if (tsym
.iss
== issNull
872 || strcmp (debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
,
878 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
880 /* If the type of the member is Nil (or Void),
881 without qualifiers, assume the tag is an
883 Alpha cc -migrate enums are recognized by a zero
884 index and a zero symbol value.
885 DU 4.0 cc enums are recognized by a member type of
886 btEnum without qualifiers and a zero symbol value. */
887 if (tsym
.index
== indexNil
888 || (tsym
.index
== 0 && sh
->value
== 0))
889 type_code
= TYPE_CODE_ENUM
;
892 (*debug_swap
->swap_tir_in
) (bigend
,
893 &ax
[tsym
.index
].a_ti
,
895 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
896 || (tir
.bt
== btEnum
&& sh
->value
== 0))
898 type_code
= TYPE_CODE_ENUM
;
902 if (tsym
.value
> max_value
)
903 max_value
= tsym
.value
;
912 /* This is a no-op; is it trying to tell us something
913 we should be checking? */
914 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED */
918 /* This is something like a struct within a
919 struct. Skip over the fields of the inner
920 struct. The -1 is because the for loop will
921 increment ext_tsym. */
922 ext_tsym
= ((char *) debug_info
->external_sym
923 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
924 * external_sym_size
));
930 /* mips cc puts out a typedef for struct x if it is not yet
931 defined when it encounters
932 struct y { struct x *xp; };
937 /* Irix5 cc puts out a stIndirect for struct x if it is not
938 yet defined when it encounters
939 struct y { struct x *xp; };
944 complaint (&symfile_complaints
,
945 _("declaration block contains "
946 "unhandled symbol type %d"),
952 /* In an stBlock, there is no way to distinguish structs,
953 unions, and enums at this point. This is a bug in the
954 original design (that has been fixed with the recent
955 addition of the stStruct, stUnion, and stEnum symbol
956 types.) The way you can tell is if/when you see a variable
957 or field of that type. In that case the variable's type
958 (in the AUX table) says if the type is struct, union, or
959 enum, and points back to the stBlock here. So you can
960 patch the tag kind up later - but only if there actually is
961 a variable or field of that type.
963 So until we know for sure, we will guess at this point.
965 If the first member has index==indexNil or a void type,
966 assume we have an enumeration.
967 Otherwise, if there is more than one member, and all
968 the members have offset 0, assume we have a union.
969 Otherwise, assume we have a struct.
971 The heuristic could guess wrong in the case of of an
972 enumeration with no members or a union with one (or zero)
973 members, or when all except the last field of a struct have
974 width zero. These are uncommon and/or illegal situations,
975 and in any case guessing wrong probably doesn't matter
978 But if we later do find out we were wrong, we fixup the tag
979 kind. Members of an enumeration must be handled
980 differently from struct/union fields, and that is harder to
981 patch up, but luckily we shouldn't need to. (If there are
982 any enumeration members, we can tell for sure it's an enum
985 if (type_code
== TYPE_CODE_UNDEF
)
987 if (nfields
> 1 && max_value
== 0)
988 type_code
= TYPE_CODE_UNION
;
990 type_code
= TYPE_CODE_STRUCT
;
993 /* Create a new type or use the pending type. */
994 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
995 if (pend
== (struct mdebug_pending
*) NULL
)
998 add_pending (cur_fdr
, ext_sh
, t
);
1003 /* Do not set the tag name if it is a compiler generated tag name
1004 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1005 Alpha cc puts out an sh->iss of zero for those. */
1006 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1007 TYPE_TAG_NAME (t
) = NULL
;
1009 TYPE_TAG_NAME (t
) = obconcat (&mdebugread_objfile
->objfile_obstack
,
1010 name
, (char *) NULL
);
1012 TYPE_CODE (t
) = type_code
;
1013 TYPE_LENGTH (t
) = sh
->value
;
1014 TYPE_NFIELDS (t
) = nfields
;
1015 TYPE_FIELDS (t
) = f
= ((struct field
*)
1017 nfields
* sizeof (struct field
)));
1019 if (type_code
== TYPE_CODE_ENUM
)
1021 int unsigned_enum
= 1;
1023 /* This is a non-empty enum. */
1025 /* DEC c89 has the number of enumerators in the sh.value field,
1026 not the type length, so we have to compensate for that
1027 incompatibility quirk.
1028 This might do the wrong thing for an enum with one or two
1029 enumerators and gcc -gcoff -fshort-enums, but these cases
1030 are hopefully rare enough.
1031 Alpha cc -migrate has a sh.value field of zero, we adjust
1033 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
)
1034 || TYPE_LENGTH (t
) == 0)
1035 TYPE_LENGTH (t
) = gdbarch_int_bit (gdbarch
) / HOST_CHAR_BIT
;
1036 for (ext_tsym
= ext_sh
+ external_sym_size
;
1038 ext_tsym
+= external_sym_size
)
1041 struct symbol
*enum_sym
;
1043 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1045 if (tsym
.st
!= stMember
)
1048 SET_FIELD_ENUMVAL (*f
, tsym
.value
);
1049 FIELD_TYPE (*f
) = t
;
1050 FIELD_NAME (*f
) = debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1051 FIELD_BITSIZE (*f
) = 0;
1053 enum_sym
= ((struct symbol
*)
1054 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
1055 sizeof (struct symbol
)));
1056 memset (enum_sym
, 0, sizeof (struct symbol
));
1057 SYMBOL_SET_LINKAGE_NAME
1058 (enum_sym
, obsavestring (f
->name
, strlen (f
->name
),
1059 &mdebugread_objfile
->objfile_obstack
));
1060 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1061 SYMBOL_TYPE (enum_sym
) = t
;
1062 SYMBOL_DOMAIN (enum_sym
) = VAR_DOMAIN
;
1063 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1064 if (SYMBOL_VALUE (enum_sym
) < 0)
1066 add_symbol (enum_sym
, top_stack
->cur_st
, top_stack
->cur_block
);
1068 /* Skip the stMembers that we've handled. */
1073 TYPE_UNSIGNED (t
) = 1;
1075 /* Make this the current type. */
1076 top_stack
->cur_type
= t
;
1077 top_stack
->cur_field
= 0;
1079 /* Do not create a symbol for alpha cc unnamed structs. */
1083 /* gcc puts out an empty struct for an opaque struct definitions,
1084 do not create a symbol for it either. */
1085 if (TYPE_NFIELDS (t
) == 0)
1091 s
= new_symbol (name
);
1092 SYMBOL_DOMAIN (s
) = STRUCT_DOMAIN
;
1093 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1094 SYMBOL_VALUE (s
) = 0;
1095 SYMBOL_TYPE (s
) = t
;
1096 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1099 /* End of local variables shared by struct, union, enum, and
1100 block (as yet unknown struct/union/enum) processing. */
1104 found_ecoff_debugging_info
= 1;
1105 /* Beginnning of (code) block. Value of symbol
1106 is the displacement from procedure start. */
1107 push_parse_stack ();
1109 /* Do not start a new block if this is the outermost block of a
1110 procedure. This allows the LOC_BLOCK symbol to point to the
1111 block with the local variables, so funcname::var works. */
1112 if (top_stack
->blocktype
== stProc
1113 || top_stack
->blocktype
== stStaticProc
)
1115 top_stack
->blocktype
= stNil
;
1119 top_stack
->blocktype
= stBlock
;
1120 b
= new_block (NON_FUNCTION_BLOCK
);
1121 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1122 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1123 top_stack
->cur_block
= b
;
1124 add_block (b
, top_stack
->cur_st
);
1127 case stEnd
: /* end (of anything) */
1128 if (sh
->sc
== scInfo
|| SC_IS_COMMON (sh
->sc
))
1130 /* Finished with type */
1131 top_stack
->cur_type
= 0;
1133 else if (sh
->sc
== scText
&&
1134 (top_stack
->blocktype
== stProc
||
1135 top_stack
->blocktype
== stStaticProc
))
1137 /* Finished with procedure */
1138 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1139 struct mdebug_extra_func_info
*e
;
1140 struct block
*b
= top_stack
->cur_block
;
1141 struct type
*ftype
= top_stack
->cur_type
;
1144 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1146 /* Make up special symbol to contain procedure specific info. */
1147 s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
1148 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
1149 SYMBOL_CLASS (s
) = LOC_CONST
;
1150 SYMBOL_TYPE (s
) = objfile_type (mdebugread_objfile
)->builtin_void
;
1151 e
= ((struct mdebug_extra_func_info
*)
1152 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
1153 sizeof (struct mdebug_extra_func_info
)));
1154 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
1155 SYMBOL_VALUE_BYTES (s
) = (gdb_byte
*) e
;
1156 e
->numargs
= top_stack
->numargs
;
1157 e
->pdr
.framereg
= -1;
1158 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1160 /* f77 emits proc-level with address bounds==[0,0],
1161 So look for such child blocks, and patch them. */
1162 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1164 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1166 if (BLOCK_SUPERBLOCK (b_bad
) == b
1167 && BLOCK_START (b_bad
) == top_stack
->procadr
1168 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1170 BLOCK_START (b_bad
) = BLOCK_START (b
);
1171 BLOCK_END (b_bad
) = BLOCK_END (b
);
1175 if (TYPE_NFIELDS (ftype
) <= 0)
1177 /* No parameter type information is recorded with the function's
1178 type. Set that from the type of the parameter symbols. */
1179 int nparams
= top_stack
->numargs
;
1185 struct block_iterator iter
;
1187 TYPE_NFIELDS (ftype
) = nparams
;
1188 TYPE_FIELDS (ftype
) = (struct field
*)
1189 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1192 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1194 if (iparams
== nparams
)
1197 if (SYMBOL_IS_ARGUMENT (sym
))
1199 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1200 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
1207 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1209 /* End of (code) block. The value of the symbol is the
1210 displacement from the procedure`s start address of the
1211 end of this block. */
1212 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1214 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1216 /* End of outermost block. Pop parse stack and ignore. The
1217 following stEnd of stProc will take care of the block. */
1220 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1222 /* End of file. Pop parse stack and ignore. Higher
1223 level code deals with this. */
1227 complaint (&symfile_complaints
,
1228 _("stEnd with storage class %d not handled"), sh
->sc
);
1230 pop_parse_stack (); /* Restore previous lexical context. */
1233 case stMember
: /* member of struct or union */
1234 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1235 FIELD_NAME (*f
) = name
;
1236 SET_FIELD_BITPOS (*f
, sh
->value
);
1238 FIELD_TYPE (*f
) = parse_type (cur_fd
, ax
, sh
->index
,
1239 &bitsize
, bigend
, name
);
1240 FIELD_BITSIZE (*f
) = bitsize
;
1243 case stIndirect
: /* forward declaration on Irix5 */
1244 /* Forward declarations from Irix5 cc are handled by cross_ref,
1248 case stTypedef
: /* type definition */
1249 found_ecoff_debugging_info
= 1;
1251 /* Typedefs for forward declarations and opaque structs from alpha cc
1252 are handled by cross_ref, skip them. */
1256 /* Parse the type or use the pending type. */
1257 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1258 if (pend
== (struct mdebug_pending
*) NULL
)
1260 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *) NULL
, bigend
, name
);
1261 add_pending (cur_fdr
, ext_sh
, t
);
1266 /* Mips cc puts out a typedef with the name of the struct for forward
1267 declarations. These should not go into the symbol table and
1268 TYPE_NAME should not be set for them.
1269 They can't be distinguished from an intentional typedef to
1270 the same name however:
1272 struct x { int ix; int jx; };
1276 struct xx {int ixx; int jxx; };
1277 generates a cross referencing stTypedef for x and xx.
1278 The user visible effect of this is that the type of a pointer
1279 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1280 The problem is fixed with alpha cc and Irix5 cc. */
1282 /* However if the typedef cross references to an opaque aggregate, it
1283 is safe to omit it from the symbol table. */
1285 if (has_opaque_xref (cur_fdr
, sh
))
1287 s
= new_symbol (name
);
1288 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1289 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1290 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1291 SYMBOL_TYPE (s
) = t
;
1292 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
1294 /* Incomplete definitions of structs should not get a name. */
1295 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1296 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1297 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1298 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1300 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1301 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1303 /* If we are giving a name to a type such as "pointer to
1304 foo" or "function returning foo", we better not set
1305 the TYPE_NAME. If the program contains "typedef char
1306 *caddr_t;", we don't want all variables of type char
1307 * to print as caddr_t. This is not just a
1308 consequence of GDB's type management; CC and GCC (at
1309 least through version 2.4) both output variables of
1310 either type char * or caddr_t with the type
1311 refering to the stTypedef symbol for caddr_t. If a future
1312 compiler cleans this up it GDB is not ready for it
1313 yet, but if it becomes ready we somehow need to
1314 disable this check (without breaking the PCC/GCC2.4
1319 Fortunately, this check seems not to be necessary
1320 for anything except pointers or functions. */
1323 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_LINKAGE_NAME (s
);
1327 case stFile
: /* file name */
1328 push_parse_stack ();
1329 top_stack
->blocktype
= sh
->st
;
1332 /* I`ve never seen these for C */
1334 break; /* register relocation */
1336 break; /* forwarding address */
1338 break; /* constant */
1340 complaint (&symfile_complaints
, _("unknown symbol type 0x%x"), sh
->st
);
1349 static const struct objfile_data
*basic_type_data
;
1351 static struct type
*
1352 basic_type (int bt
, struct objfile
*objfile
)
1354 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1355 struct type
**map_bt
= objfile_data (objfile
, basic_type_data
);
1363 map_bt
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
1364 btMax
, struct type
*);
1365 set_objfile_data (objfile
, basic_type_data
, map_bt
);
1374 tp
= objfile_type (objfile
)->builtin_void
;
1378 tp
= init_type (TYPE_CODE_PTR
, 4, TYPE_FLAG_UNSIGNED
,
1380 TYPE_TARGET_TYPE (tp
) = objfile_type (objfile
)->builtin_void
;
1384 tp
= init_type (TYPE_CODE_INT
, 1, 0,
1389 tp
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
1390 "unsigned char", objfile
);
1394 tp
= init_type (TYPE_CODE_INT
, 2, 0,
1399 tp
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
1400 "unsigned short", objfile
);
1404 tp
= init_type (TYPE_CODE_INT
, 4, 0,
1409 tp
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1410 "unsigned int", objfile
);
1414 tp
= init_type (TYPE_CODE_INT
, 4, 0,
1419 tp
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1420 "unsigned long", objfile
);
1424 tp
= init_type (TYPE_CODE_FLT
,
1425 gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1430 tp
= init_type (TYPE_CODE_FLT
,
1431 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1436 tp
= init_type (TYPE_CODE_COMPLEX
,
1437 2 * gdbarch_float_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1438 "complex", objfile
);
1439 TYPE_TARGET_TYPE (tp
) = basic_type (btFloat
, objfile
);
1443 tp
= init_type (TYPE_CODE_COMPLEX
,
1444 2 * gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1445 "double complex", objfile
);
1446 TYPE_TARGET_TYPE (tp
) = basic_type (btDouble
, objfile
);
1450 /* We use TYPE_CODE_INT to print these as integers. Does this do any
1451 good? Would we be better off with TYPE_CODE_ERROR? Should
1452 TYPE_CODE_ERROR print things in hex if it knows the size? */
1453 tp
= init_type (TYPE_CODE_INT
,
1454 gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1455 "fixed decimal", objfile
);
1459 tp
= init_type (TYPE_CODE_ERROR
,
1460 gdbarch_double_bit (gdbarch
) / TARGET_CHAR_BIT
, 0,
1461 "floating decimal", objfile
);
1465 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
1467 tp
= init_type (TYPE_CODE_STRING
, 1, 0,
1472 tp
= objfile_type (objfile
)->builtin_void
;
1476 tp
= init_type (TYPE_CODE_INT
, 8, 0,
1481 tp
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
1482 "unsigned long", objfile
);
1486 tp
= init_type (TYPE_CODE_INT
, 8, 0,
1487 "long long", objfile
);
1491 tp
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
1492 "unsigned long long", objfile
);
1496 tp
= init_type (TYPE_CODE_PTR
, 8, TYPE_FLAG_UNSIGNED
,
1498 TYPE_TARGET_TYPE (tp
) = objfile_type (objfile
)->builtin_void
;
1502 tp
= init_type (TYPE_CODE_INT
, 8, 0,
1507 tp
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
1508 "unsigned int", objfile
);
1520 /* Parse the type information provided in the raw AX entries for
1521 the symbol SH. Return the bitfield size in BS, in case.
1522 We must byte-swap the AX entries before we use them; BIGEND says whether
1523 they are big-endian or little-endian (from fh->fBigendian). */
1525 static struct type
*
1526 parse_type (int fd
, union aux_ext
*ax
, unsigned int aux_index
, int *bs
,
1527 int bigend
, char *sym_name
)
1530 struct type
*tp
= 0;
1531 enum type_code type_code
= TYPE_CODE_UNDEF
;
1533 /* Handle undefined types, they have indexNil. */
1534 if (aux_index
== indexNil
)
1535 return basic_type (btInt
, mdebugread_objfile
);
1537 /* Handle corrupt aux indices. */
1538 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1540 index_complaint (sym_name
);
1541 return basic_type (btInt
, mdebugread_objfile
);
1545 /* Use aux as a type information record, map its basic type. */
1546 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1547 tp
= basic_type (t
->bt
, mdebugread_objfile
);
1550 /* Cannot use builtin types -- build our own. */
1554 type_code
= TYPE_CODE_STRUCT
;
1557 type_code
= TYPE_CODE_UNION
;
1560 type_code
= TYPE_CODE_ENUM
;
1563 type_code
= TYPE_CODE_RANGE
;
1566 type_code
= TYPE_CODE_SET
;
1569 /* alpha cc -migrate uses this for typedefs. The true type will
1570 be obtained by crossreferencing below. */
1571 type_code
= TYPE_CODE_ERROR
;
1574 /* alpha cc uses this for typedefs. The true type will be
1575 obtained by crossreferencing below. */
1576 type_code
= TYPE_CODE_ERROR
;
1579 basic_type_complaint (t
->bt
, sym_name
);
1580 return basic_type (btInt
, mdebugread_objfile
);
1584 /* Move on to next aux. */
1589 int width
= AUX_GET_WIDTH (bigend
, ax
);
1591 /* Inhibit core dumps if TIR is corrupted. */
1592 if (bs
== (int *) NULL
)
1594 /* Alpha cc -migrate encodes char and unsigned char types
1595 as short and unsigned short types with a field width of 8.
1596 Enum types also have a field width which we ignore for now. */
1597 if (t
->bt
== btShort
&& width
== 8)
1598 tp
= basic_type (btChar
, mdebugread_objfile
);
1599 else if (t
->bt
== btUShort
&& width
== 8)
1600 tp
= basic_type (btUChar
, mdebugread_objfile
);
1601 else if (t
->bt
== btEnum
)
1604 complaint (&symfile_complaints
,
1605 _("can't handle TIR fBitfield for %s"),
1613 /* A btIndirect entry cross references to an aux entry containing
1615 if (t
->bt
== btIndirect
)
1622 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1624 if (rn
->rfd
== 0xfff)
1626 rf
= AUX_GET_ISYM (bigend
, ax
);
1634 complaint (&symfile_complaints
,
1635 _("unable to cross ref btIndirect for %s"), sym_name
);
1636 return basic_type (btInt
, mdebugread_objfile
);
1638 xref_fh
= get_rfd (fd
, rf
);
1639 xref_fd
= xref_fh
- debug_info
->fdr
;
1640 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1641 rn
->index
, (int *) NULL
, xref_fh
->fBigendian
, sym_name
);
1644 /* All these types really point to some (common) MIPS type
1645 definition, and only the type-qualifiers fully identify
1646 them. We'll make the same effort at sharing. */
1647 if (t
->bt
== btStruct
||
1651 /* btSet (I think) implies that the name is a tag name, not a typedef
1652 name. This apparently is a MIPS extension for C sets. */
1657 /* Try to cross reference this type, build new type on failure. */
1658 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1659 if (tp
== (struct type
*) NULL
)
1660 tp
= init_type (type_code
, 0, 0, (char *) NULL
, mdebugread_objfile
);
1662 /* DEC c89 produces cross references to qualified aggregate types,
1663 dereference them. */
1664 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1665 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1666 tp
= TYPE_TARGET_TYPE (tp
);
1668 /* Make sure that TYPE_CODE(tp) has an expected type code.
1669 Any type may be returned from cross_ref if file indirect entries
1671 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1672 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1673 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1675 unexpected_type_code_complaint (sym_name
);
1679 /* Usually, TYPE_CODE(tp) is already type_code. The main
1680 exception is if we guessed wrong re struct/union/enum.
1681 But for struct vs. union a wrong guess is harmless, so
1682 don't complain(). */
1683 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1684 && type_code
!= TYPE_CODE_ENUM
)
1685 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1686 && type_code
== TYPE_CODE_ENUM
))
1688 bad_tag_guess_complaint (sym_name
);
1691 if (TYPE_CODE (tp
) != type_code
)
1693 TYPE_CODE (tp
) = type_code
;
1696 /* Do not set the tag name if it is a compiler generated tag name
1697 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1698 if (name
[0] == '.' || name
[0] == '\0')
1699 TYPE_TAG_NAME (tp
) = NULL
;
1700 else if (TYPE_TAG_NAME (tp
) == NULL
1701 || strcmp (TYPE_TAG_NAME (tp
), name
) != 0)
1703 = obsavestring (name
, strlen (name
),
1704 &mdebugread_objfile
->objfile_obstack
);
1708 /* All these types really point to some (common) MIPS type
1709 definition, and only the type-qualifiers fully identify
1710 them. We'll make the same effort at sharing.
1711 FIXME: We are not doing any guessing on range types. */
1712 if (t
->bt
== btRange
)
1716 /* Try to cross reference this type, build new type on failure. */
1717 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1718 if (tp
== (struct type
*) NULL
)
1719 tp
= init_type (type_code
, 0, 0, (char *) NULL
, mdebugread_objfile
);
1721 /* Make sure that TYPE_CODE(tp) has an expected type code.
1722 Any type may be returned from cross_ref if file indirect entries
1724 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1726 unexpected_type_code_complaint (sym_name
);
1730 /* Usually, TYPE_CODE(tp) is already type_code. The main
1731 exception is if we guessed wrong re struct/union/enum. */
1732 if (TYPE_CODE (tp
) != type_code
)
1734 bad_tag_guess_complaint (sym_name
);
1735 TYPE_CODE (tp
) = type_code
;
1737 if (TYPE_NAME (tp
) == NULL
1738 || strcmp (TYPE_NAME (tp
), name
) != 0)
1739 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1740 &mdebugread_objfile
->objfile_obstack
);
1743 if (t
->bt
== btTypedef
)
1747 /* Try to cross reference this type, it should succeed. */
1748 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1749 if (tp
== (struct type
*) NULL
)
1751 complaint (&symfile_complaints
,
1752 _("unable to cross ref btTypedef for %s"), sym_name
);
1753 tp
= basic_type (btInt
, mdebugread_objfile
);
1757 /* Deal with range types. */
1758 if (t
->bt
== btRange
)
1760 TYPE_NFIELDS (tp
) = 0;
1761 TYPE_RANGE_DATA (tp
) = ((struct range_bounds
*)
1762 TYPE_ZALLOC (tp
, sizeof (struct range_bounds
)));
1763 TYPE_LOW_BOUND (tp
) = AUX_GET_DNLOW (bigend
, ax
);
1765 TYPE_HIGH_BOUND (tp
) = AUX_GET_DNHIGH (bigend
, ax
);
1769 /* Parse all the type qualifiers now. If there are more
1770 than 6 the game will continue in the next aux. */
1774 #define PARSE_TQ(tq) \
1775 if (t->tq != tqNil) \
1776 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1788 /* mips cc 2.x and gcc never put out continued aux entries. */
1792 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1796 /* Complain for illegal continuations due to corrupt aux entries. */
1798 complaint (&symfile_complaints
,
1799 _("illegal TIR continued for %s"), sym_name
);
1804 /* Make up a complex type from a basic one. Type is passed by
1805 reference in TPP and side-effected as necessary. The type
1806 qualifier TQ says how to handle the aux symbols at AX for
1807 the symbol SX we are currently analyzing. BIGEND says whether
1808 aux symbols are big-endian or little-endian.
1809 Returns the number of aux symbols we parsed. */
1812 upgrade_type (int fd
, struct type
**tpp
, int tq
, union aux_ext
*ax
, int bigend
,
1818 /* Used in array processing. */
1829 t
= lookup_pointer_type (*tpp
);
1834 t
= lookup_function_type (*tpp
);
1841 /* Determine and record the domain type (type of index). */
1842 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1848 rf
= AUX_GET_ISYM (bigend
, ax
);
1851 fh
= get_rfd (fd
, rf
);
1853 indx
= parse_type (fh
- debug_info
->fdr
,
1854 debug_info
->external_aux
+ fh
->iauxBase
,
1855 id
, (int *) NULL
, bigend
, sym_name
);
1857 /* The bounds type should be an integer type, but might be anything
1858 else due to corrupt aux entries. */
1859 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1861 complaint (&symfile_complaints
,
1862 _("illegal array index type for %s, assuming int"),
1864 indx
= objfile_type (mdebugread_objfile
)->builtin_int
;
1867 /* Get the bounds, and create the array type. */
1869 lower
= AUX_GET_DNLOW (bigend
, ax
);
1871 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1873 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1875 range
= create_range_type ((struct type
*) NULL
, indx
,
1878 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1880 /* We used to fill in the supplied array element bitsize
1881 here if the TYPE_LENGTH of the target type was zero.
1882 This happens for a `pointer to an array of anonymous structs',
1883 but in this case the array element bitsize is also zero,
1884 so nothing is gained.
1885 And we used to check the TYPE_LENGTH of the target type against
1886 the supplied array element bitsize.
1887 gcc causes a mismatch for `pointer to array of object',
1888 since the sdb directives it uses do not have a way of
1889 specifying the bitsize, but it does no harm (the
1890 TYPE_LENGTH should be correct) and we should be able to
1891 ignore the erroneous bitsize from the auxiliary entry safely.
1892 dbx seems to ignore it too. */
1894 /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */
1895 if (TYPE_LENGTH (*tpp
) == 0)
1896 TYPE_TARGET_STUB (t
) = 1;
1902 /* Volatile -- currently ignored */
1906 /* Const -- currently ignored */
1910 complaint (&symfile_complaints
, _("unknown type qualifier 0x%x"), tq
);
1916 /* Parse a procedure descriptor record PR. Note that the procedure is
1917 parsed _after_ the local symbols, now we just insert the extra
1918 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1919 already been placed in the procedure's main block. Note also that
1920 images that have been partially stripped (ld -x) have been deprived
1921 of local symbols, and we have to cope with them here. FIRST_OFF is
1922 the offset of the first procedure for this FDR; we adjust the
1923 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1924 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1925 in question, or NULL to use top_stack->cur_block. */
1927 static void parse_procedure (PDR
*, struct symtab
*, struct partial_symtab
*);
1930 parse_procedure (PDR
*pr
, struct symtab
*search_symtab
,
1931 struct partial_symtab
*pst
)
1933 struct symbol
*s
, *i
;
1937 /* Simple rule to find files linked "-x". */
1938 if (cur_fdr
->rss
== -1)
1942 /* Static procedure at address pr->adr. Sigh. */
1943 /* FIXME-32x64. assuming pr->adr fits in long. */
1944 complaint (&symfile_complaints
,
1945 _("can't handle PDR for static proc at 0x%lx"),
1946 (unsigned long) pr
->adr
);
1954 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1955 ((char *) debug_info
->external_ext
1957 * debug_swap
->external_ext_size
)),
1959 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1967 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1968 ((char *) debug_info
->external_sym
1969 + ((cur_fdr
->isymBase
+ pr
->isym
)
1970 * debug_swap
->external_sym_size
)),
1972 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1975 if (search_symtab
!= NULL
)
1978 /* This loses both in the case mentioned (want a static, find a global),
1979 but also if we are looking up a non-mangled name which happens to
1980 match the name of a mangled function. */
1981 /* We have to save the cur_fdr across the call to lookup_symbol.
1982 If the pdr is for a static function and if a global function with
1983 the same name exists, lookup_symbol will eventually read in the symtab
1984 for the global function and clobber cur_fdr. */
1985 FDR
*save_cur_fdr
= cur_fdr
;
1987 s
= lookup_symbol (sh_name
, NULL
, VAR_DOMAIN
, 0);
1988 cur_fdr
= save_cur_fdr
;
1992 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1998 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1999 VAR_DOMAIN
, LOC_BLOCK
);
2003 b
= SYMBOL_BLOCK_VALUE (s
);
2007 complaint (&symfile_complaints
, _("PDR for %s, but no symbol"), sh_name
);
2011 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
2012 s
= new_symbol (sh_name
);
2013 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
2014 SYMBOL_CLASS (s
) = LOC_BLOCK
;
2015 /* Donno its type, hope int is ok. */
2017 = lookup_function_type (objfile_type (pst
->objfile
)->builtin_int
);
2018 add_symbol (s
, top_stack
->cur_st
, top_stack
->cur_block
);
2019 /* Won't have symbols for this one. */
2021 SYMBOL_BLOCK_VALUE (s
) = b
;
2022 BLOCK_FUNCTION (b
) = s
;
2023 BLOCK_START (b
) = pr
->adr
;
2024 /* BOUND used to be the end of procedure's text, but the
2025 argument is no longer passed in. */
2026 BLOCK_END (b
) = bound
;
2027 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
2028 add_block (b
, top_stack
->cur_st
);
2032 i
= mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME
, b
, LABEL_DOMAIN
, LOC_CONST
);
2036 struct mdebug_extra_func_info
*e
;
2038 e
= (struct mdebug_extra_func_info
*) SYMBOL_VALUE_BYTES (i
);
2041 /* GDB expects the absolute function start address for the
2042 procedure descriptor in e->pdr.adr.
2043 As the address in the procedure descriptor is usually relative,
2044 we would have to relocate e->pdr.adr with cur_fdr->adr and
2045 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
2046 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2047 in shared libraries on some systems, and on other systems
2048 e->pdr.adr is sometimes offset by a bogus value.
2049 To work around these problems, we replace e->pdr.adr with
2050 the start address of the function. */
2051 e
->pdr
.adr
= BLOCK_START (b
);
2054 /* It would be reasonable that functions that have been compiled
2055 without debugging info have a btNil type for their return value,
2056 and functions that are void and are compiled with debugging info
2058 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2059 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2061 The glevel field in cur_fdr could be used to determine the presence
2062 of debugging info, but GCC doesn't always pass the -g switch settings
2063 to the assembler and GAS doesn't set the glevel field from the -g switch
2065 To work around these problems, the return value type of a TYPE_CODE_VOID
2066 function is adjusted accordingly if no debugging info was found in the
2067 compilation unit. */
2069 if (processing_gcc_compilation
== 0
2070 && found_ecoff_debugging_info
== 0
2071 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
2072 SYMBOL_TYPE (s
) = objfile_type (mdebugread_objfile
)->nodebug_text_symbol
;
2075 /* Parse the external symbol ES. Just call parse_symbol() after
2076 making sure we know where the aux are for it.
2077 BIGEND says whether aux entries are big-endian or little-endian.
2079 This routine clobbers top_stack->cur_block and ->cur_st. */
2081 static void parse_external (EXTR
*, int, struct section_offsets
*,
2085 parse_external (EXTR
*es
, int bigend
, struct section_offsets
*section_offsets
,
2086 struct objfile
*objfile
)
2090 if (es
->ifd
!= ifdNil
)
2093 cur_fdr
= debug_info
->fdr
+ cur_fd
;
2094 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
2098 cur_fdr
= debug_info
->fdr
;
2102 /* Reading .o files */
2103 if (SC_IS_UNDEF (es
->asym
.sc
) || es
->asym
.sc
== scNil
)
2106 switch (es
->asym
.st
)
2109 /* These are generated for static symbols in .o files,
2130 /* FIXME: Turn this into a complaint? */
2132 printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
2133 what
, debug_info
->ssext
+ es
->asym
.iss
,
2134 fdr_name (cur_fdr
));
2138 switch (es
->asym
.st
)
2142 /* There is no need to parse the external procedure symbols.
2143 If they are from objects compiled without -g, their index will
2144 be indexNil, and the symbol definition from the minimal symbol
2145 is preferrable (yielding a function returning int instead of int).
2146 If the index points to a local procedure symbol, the local
2147 symbol already provides the correct type.
2148 Note that the index of the external procedure symbol points
2149 to the local procedure symbol in the local symbol table, and
2150 _not_ to the auxiliary symbol info. */
2154 /* Global common symbols are resolved by the runtime loader,
2156 if (SC_IS_COMMON (es
->asym
.sc
))
2159 /* Note that the case of a symbol with indexNil must be handled
2160 anyways by parse_symbol(). */
2161 parse_symbol (&es
->asym
, ax
, (char *) NULL
,
2162 bigend
, section_offsets
, objfile
);
2169 /* Parse the line number info for file descriptor FH into
2170 GDB's linetable LT. MIPS' encoding requires a little bit
2171 of magic to get things out. Note also that MIPS' line
2172 numbers can go back and forth, apparently we can live
2173 with that and do not need to reorder our linetables. */
2175 static void parse_lines (FDR
*, PDR
*, struct linetable
*, int,
2176 struct partial_symtab
*, CORE_ADDR
);
2179 parse_lines (FDR
*fh
, PDR
*pr
, struct linetable
*lt
, int maxlines
,
2180 struct partial_symtab
*pst
, CORE_ADDR lowest_pdr_addr
)
2182 unsigned char *base
;
2184 int delta
, count
, lineno
= 0;
2186 if (fh
->cbLine
== 0)
2189 /* Scan by procedure descriptors. */
2191 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2195 unsigned char *halt
;
2197 /* No code for this one. */
2198 if (pr
->iline
== ilineNil
||
2199 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2202 /* Determine start and end address of compressed line bytes for
2204 base
= debug_info
->line
+ fh
->cbLineOffset
;
2205 if (j
!= (fh
->cpd
- 1))
2206 halt
= base
+ pr
[1].cbLineOffset
;
2208 halt
= base
+ fh
->cbLine
;
2209 base
+= pr
->cbLineOffset
;
2211 adr
= pst
->textlow
+ pr
->adr
- lowest_pdr_addr
;
2213 l
= adr
>> 2; /* in words */
2214 for (lineno
= pr
->lnLow
; base
< halt
;)
2216 count
= *base
& 0x0f;
2217 delta
= *base
++ >> 4;
2222 delta
= (base
[0] << 8) | base
[1];
2223 if (delta
>= 0x8000)
2227 lineno
+= delta
; /* first delta is 0 */
2229 /* Complain if the line table overflows. Could happen
2230 with corrupt binaries. */
2231 if (lt
->nitems
>= maxlines
)
2233 complaint (&symfile_complaints
,
2234 _("guessed size of linetable for %s incorrectly"),
2238 k
= add_line (lt
, lineno
, l
, k
);
2245 function_outside_compilation_unit_complaint (const char *arg1
)
2247 complaint (&symfile_complaints
,
2248 _("function `%s' appears to be defined "
2249 "outside of all compilation units"),
2253 /* Use the STORAGE_CLASS to compute which section the given symbol
2254 belongs to, and then records this new minimal symbol. */
2257 record_minimal_symbol (const char *name
, const CORE_ADDR address
,
2258 enum minimal_symbol_type ms_type
, int storage_class
,
2259 struct objfile
*objfile
)
2262 asection
*bfd_section
;
2264 switch (storage_class
)
2267 section
= SECT_OFF_TEXT (objfile
);
2268 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".text");
2271 section
= SECT_OFF_DATA (objfile
);
2272 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".data");
2275 section
= SECT_OFF_BSS (objfile
);
2276 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".bss");
2279 section
= get_section_index (objfile
, ".sdata");
2280 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".sdata");
2283 section
= get_section_index (objfile
, ".sbss");
2284 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".sbss");
2287 section
= get_section_index (objfile
, ".rdata");
2288 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".rdata");
2291 section
= get_section_index (objfile
, ".init");
2292 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".init");
2295 section
= get_section_index (objfile
, ".xdata");
2296 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".xdata");
2299 section
= get_section_index (objfile
, ".pdata");
2300 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".pdata");
2303 section
= get_section_index (objfile
, ".fini");
2304 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".fini");
2307 section
= get_section_index (objfile
, ".rconst");
2308 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".rconst");
2312 section
= get_section_index (objfile
, ".tlsdata");
2313 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".tlsdata");
2318 section
= get_section_index (objfile
, ".tlsbss");
2319 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".tlsbss");
2323 /* This kind of symbol is not associated to a section. */
2328 prim_record_minimal_symbol_and_info (name
, address
, ms_type
,
2329 section
, bfd_section
, objfile
);
2332 /* Master parsing procedure for first-pass reading of file symbols
2333 into a partial_symtab. */
2336 parse_partial_symbols (struct objfile
*objfile
)
2338 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2339 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2340 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2341 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2342 void (*const swap_ext_in
) (bfd
*, void *, EXTR
*) = debug_swap
->swap_ext_in
;
2343 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
2344 void (*const swap_rfd_in
) (bfd
*, void *, RFDT
*) = debug_swap
->swap_rfd_in
;
2346 HDRR
*hdr
= &debug_info
->symbolic_header
;
2347 /* Running pointers */
2355 struct partial_symtab
*pst
;
2356 int textlow_not_set
= 1;
2357 int past_first_source_file
= 0;
2359 /* List of current psymtab's include files. */
2360 const char **psymtab_include_list
;
2361 int includes_allocated
;
2364 struct pst_map
*fdr_to_pst
;
2365 /* Index within current psymtab dependency list. */
2366 struct partial_symtab
**dependency_list
;
2367 int dependencies_used
, dependencies_allocated
;
2368 struct cleanup
*old_chain
;
2370 enum language prev_language
;
2371 asection
*text_sect
;
2372 int relocatable
= 0;
2374 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2375 the shared libraries are prelinked at a high memory address.
2376 We have to adjust the start address of the object file for this case,
2377 by setting it to the start address of the first procedure in the file.
2378 But we should do no adjustments if we are debugging a .o file, where
2379 the text section (and fh->adr) really starts at zero. */
2380 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2381 if (text_sect
!= NULL
2382 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2385 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->objfile_obstack
,
2386 sizeof (EXTR
) * hdr
->iextMax
);
2388 includes_allocated
= 30;
2390 psymtab_include_list
= (const char **) alloca (includes_allocated
*
2391 sizeof (const char *));
2392 next_symbol_text_func
= mdebug_next_symbol_text
;
2394 dependencies_allocated
= 30;
2395 dependencies_used
= 0;
2397 (struct partial_symtab
**) alloca (dependencies_allocated
*
2398 sizeof (struct partial_symtab
*));
2400 last_source_file
= NULL
;
2405 * Only parse the Local and External symbols, and the Relative FDR.
2406 * Fixup enough of the loader symtab to be able to use it.
2407 * Allocate space only for the file's portions we need to
2412 max_glevel
= MIN_GLEVEL
;
2414 /* Allocate the map FDR -> PST.
2415 Minor hack: -O3 images might claim some global data belongs
2416 to FDR -1. We`ll go along with that. */
2417 fdr_to_pst
= (struct pst_map
*)
2418 xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2419 old_chain
= make_cleanup (xfree
, fdr_to_pst
);
2422 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2424 fdr_to_pst
[-1].pst
= pst
;
2428 /* Allocate the global pending list. */
2430 ((struct mdebug_pending
**)
2431 obstack_alloc (&objfile
->objfile_obstack
,
2432 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2433 memset (pending_list
, 0,
2434 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2436 /* Pass 0 over external syms: swap them in. */
2437 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2438 make_cleanup (xfree
, ext_block
);
2440 ext_out
= (char *) debug_info
->external_ext
;
2441 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2443 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2444 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2446 /* Pass 1 over external syms: Presize and partition the list. */
2448 ext_in_end
= ext_in
+ hdr
->iextMax
;
2449 for (; ext_in
< ext_in_end
; ext_in
++)
2451 /* See calls to complain below. */
2452 if (ext_in
->ifd
>= -1
2453 && ext_in
->ifd
< hdr
->ifdMax
2454 && ext_in
->asym
.iss
>= 0
2455 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2456 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2459 /* Pass 1.5 over files: partition out global symbol space. */
2461 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2463 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2464 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2465 fdr_to_pst
[f_idx
].n_globals
= 0;
2470 For ECOFF in ELF, we skip the creation of the minimal symbols.
2471 The ECOFF symbols should be a subset of the Elf symbols, and the
2472 section information of the elf symbols will be more accurate.
2473 FIXME! What about Irix 5's native linker?
2475 By default, Elf sections which don't exist in ECOFF
2476 get put in ECOFF's absolute section by the gnu linker.
2477 Since absolute sections don't get relocated, we
2478 end up calculating an address different from that of
2479 the symbol's minimal symbol (created earlier from the
2482 To fix this, either :
2483 1) don't create the duplicate symbol
2484 (assumes ECOFF symtab is a subset of the ELF symtab;
2485 assumes no side-effects result from ignoring ECOFF symbol)
2486 2) create it, only if lookup for existing symbol in ELF's minimal
2489 assumes no side-effects result from ignoring ECOFF symbol)
2490 3) create it, but lookup ELF's minimal symbol and use it's section
2491 during relocation, then modify "uniqify" phase to merge and
2492 eliminate the duplicate symbol
2493 (highly inefficient)
2495 I've implemented #1 here...
2496 Skip the creation of the minimal symbols based on the ECOFF
2499 /* Pass 2 over external syms: fill in external symbols. */
2501 ext_in_end
= ext_in
+ hdr
->iextMax
;
2502 for (; ext_in
< ext_in_end
; ext_in
++)
2504 enum minimal_symbol_type ms_type
= mst_text
;
2505 CORE_ADDR svalue
= ext_in
->asym
.value
;
2507 /* The Irix 5 native tools seem to sometimes generate bogus
2508 external symbols. */
2509 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2511 complaint (&symfile_complaints
,
2512 _("bad ifd for external symbol: %d (max %ld)"),
2513 ext_in
->ifd
, hdr
->ifdMax
);
2516 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2518 complaint (&symfile_complaints
,
2519 _("bad iss for external symbol: %ld (max %ld)"),
2520 ext_in
->asym
.iss
, hdr
->issExtMax
);
2524 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2525 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2528 if (SC_IS_UNDEF (ext_in
->asym
.sc
) || ext_in
->asym
.sc
== scNil
)
2532 /* Pass 3 over files, over local syms: fill in static symbols. */
2533 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2535 /* Process ECOFF Symbol Types and Storage Classes. */
2536 switch (ext_in
->asym
.st
)
2539 /* Beginnning of Procedure */
2540 svalue
+= ANOFFSET (objfile
->section_offsets
,
2541 SECT_OFF_TEXT (objfile
));
2544 /* Load time only static procs */
2545 ms_type
= mst_file_text
;
2546 svalue
+= ANOFFSET (objfile
->section_offsets
,
2547 SECT_OFF_TEXT (objfile
));
2550 /* External symbol */
2551 if (SC_IS_COMMON (ext_in
->asym
.sc
))
2553 /* The value of a common symbol is its size, not its address.
2557 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2560 svalue
+= ANOFFSET (objfile
->section_offsets
,
2561 SECT_OFF_DATA (objfile
));
2563 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2566 svalue
+= ANOFFSET (objfile
->section_offsets
,
2567 SECT_OFF_BSS (objfile
));
2569 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2572 svalue
+= ANOFFSET (objfile
->section_offsets
,
2573 get_section_index (objfile
, ".sbss"));
2581 /* On certain platforms, some extra label symbols can be
2582 generated by the linker. One possible usage for this kind
2583 of symbols is to represent the address of the begining of a
2584 given section. For instance, on Tru64 5.1, the address of
2585 the _ftext label is the start address of the .text section.
2587 The storage class of these symbols is usually directly
2588 related to the section to which the symbol refers. For
2589 instance, on Tru64 5.1, the storage class for the _fdata
2590 label is scData, refering to the .data section.
2592 It is actually possible that the section associated to the
2593 storage class of the label does not exist. On True64 5.1
2594 for instance, the libm.so shared library does not contain
2595 any .data section, although it contains a _fpdata label
2596 which storage class is scData... Since these symbols are
2597 usually useless for the debugger user anyway, we just
2598 discard these symbols. */
2600 if (SC_IS_TEXT (ext_in
->asym
.sc
))
2602 if (objfile
->sect_index_text
== -1)
2605 ms_type
= mst_file_text
;
2606 svalue
+= ANOFFSET (objfile
->section_offsets
,
2607 SECT_OFF_TEXT (objfile
));
2609 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2611 if (objfile
->sect_index_data
== -1)
2614 ms_type
= mst_file_data
;
2615 svalue
+= ANOFFSET (objfile
->section_offsets
,
2616 SECT_OFF_DATA (objfile
));
2618 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2620 if (objfile
->sect_index_bss
== -1)
2623 ms_type
= mst_file_bss
;
2624 svalue
+= ANOFFSET (objfile
->section_offsets
,
2625 SECT_OFF_BSS (objfile
));
2627 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2629 const int sbss_sect_index
= get_section_index (objfile
, ".sbss");
2631 if (sbss_sect_index
== -1)
2634 ms_type
= mst_file_bss
;
2635 svalue
+= ANOFFSET (objfile
->section_offsets
, sbss_sect_index
);
2642 /* The alpha has the section start addresses in stLocal symbols
2643 whose name starts with a `.'. Skip those but complain for all
2644 other stLocal symbols.
2645 Irix6 puts the section start addresses in stNil symbols, skip
2651 ms_type
= mst_unknown
;
2652 unknown_ext_complaint (name
);
2654 if (!ECOFF_IN_ELF (cur_bfd
))
2655 record_minimal_symbol (name
, svalue
, ms_type
, ext_in
->asym
.sc
,
2659 /* Pass 3 over files, over local syms: fill in static symbols. */
2660 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2662 struct partial_symtab
*save_pst
;
2666 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2670 fdr_to_pst
[f_idx
].pst
= NULL
;
2674 /* Determine the start address for this object file from the
2675 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2679 if (relocatable
|| textlow
!= 0)
2680 textlow
+= ANOFFSET (objfile
->section_offsets
,
2681 SECT_OFF_TEXT (objfile
));
2685 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
2688 objfile
->global_psymbols
.next
,
2689 objfile
->static_psymbols
.next
);
2690 pst
->read_symtab_private
= obstack_alloc (&objfile
->objfile_obstack
,
2691 sizeof (struct symloc
));
2692 memset (pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2695 FDR_IDX (pst
) = f_idx
;
2696 CUR_BFD (pst
) = cur_bfd
;
2697 DEBUG_SWAP (pst
) = debug_swap
;
2698 DEBUG_INFO (pst
) = debug_info
;
2699 PENDING_LIST (pst
) = pending_list
;
2701 /* The way to turn this into a symtab is to call... */
2702 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2704 /* Set up language for the pst.
2705 The language from the FDR is used if it is unambigious (e.g. cfront
2706 with native cc and g++ will set the language to C).
2707 Otherwise we have to deduce the language from the filename.
2708 Native ecoff has every header file in a separate FDR, so
2709 deduce_language_from_filename will return language_unknown for
2710 a header file, which is not what we want.
2711 But the FDRs for the header files are after the FDR for the source
2712 file, so we can assign the language of the source file to the
2713 following header files. Then we save the language in the private
2714 pst data so that we can reuse it when building symtabs. */
2715 prev_language
= psymtab_language
;
2719 case langCplusplusV2
:
2720 psymtab_language
= language_cplus
;
2723 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2726 if (psymtab_language
== language_unknown
)
2727 psymtab_language
= prev_language
;
2728 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2730 pst
->texthigh
= pst
->textlow
;
2732 /* For stabs-in-ecoff files, the second symbol must be @stab.
2733 This symbol is emitted by mips-tfile to signal that the
2734 current object file uses encapsulated stabs instead of mips
2735 ecoff for local symbols. (It is the second symbol because
2736 the first symbol is the stFile used to signal the start of a
2738 processing_gcc_compilation
= 0;
2741 (*swap_sym_in
) (cur_bfd
,
2742 ((char *) debug_info
->external_sym
2743 + (fh
->isymBase
+ 1) * external_sym_size
),
2745 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2747 processing_gcc_compilation
= 2;
2750 if (processing_gcc_compilation
!= 0)
2752 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2755 const char *namestring
;
2757 (*swap_sym_in
) (cur_bfd
,
2758 (((char *) debug_info
->external_sym
)
2759 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2761 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2762 if (!ECOFF_IS_STAB (&sh
))
2764 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2769 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2770 SECT_OFF_TEXT (objfile
));
2771 if (sh
.st
== stStaticProc
)
2773 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2774 record_minimal_symbol (namestring
, sh
.value
,
2775 mst_file_text
, sh
.sc
,
2778 procaddr
= sh
.value
;
2780 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2781 (debug_info
->external_aux
2784 (*swap_sym_in
) (cur_bfd
,
2785 ((char *) debug_info
->external_sym
2786 + ((fh
->isymBase
+ isym
- 1)
2787 * external_sym_size
)),
2791 CORE_ADDR high
= procaddr
+ sh
.value
;
2793 /* Kludge for Irix 5.2 zero fh->adr. */
2795 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2796 pst
->textlow
= procaddr
;
2797 if (high
> pst
->texthigh
)
2798 pst
->texthigh
= high
;
2801 else if (sh
.st
== stStatic
)
2816 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2817 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2818 SECT_OFF_DATA (objfile
));
2819 record_minimal_symbol (namestring
, sh
.value
,
2820 mst_file_data
, sh
.sc
,
2825 /* FIXME! Shouldn't this use cases for bss,
2826 then have the default be abs? */
2827 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2828 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2829 SECT_OFF_BSS (objfile
));
2830 record_minimal_symbol (namestring
, sh
.value
,
2831 mst_file_bss
, sh
.sc
,
2838 /* Handle stabs continuation. */
2840 char *stabstring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2841 int len
= strlen (stabstring
);
2843 while (stabstring
[len
- 1] == '\\')
2846 char *stabstring1
= stabstring
;
2850 /* Ignore continuation char from 1st string. */
2853 /* Read next stabstring. */
2855 (*swap_sym_in
) (cur_bfd
,
2856 (((char *) debug_info
->external_sym
)
2857 + (fh
->isymBase
+ cur_sdx
)
2858 * external_sym_size
),
2860 stabstring2
= debug_info
->ss
+ fh
->issBase
+ sh2
.iss
;
2861 len2
= strlen (stabstring2
);
2863 /* Concatinate stabstring2 with stabstring1. */
2865 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
2866 stabstring
= xrealloc (stabstring
, len
+ len2
+ 1);
2869 stabstring
= xmalloc (len
+ len2
+ 1);
2870 strcpy (stabstring
, stabstring1
);
2872 strcpy (stabstring
+ len
, stabstring2
);
2880 /* Standard, external, non-debugger, symbols. */
2882 case N_TEXT
| N_EXT
:
2883 case N_NBTEXT
| N_EXT
:
2884 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2885 SECT_OFF_TEXT (objfile
));
2888 case N_DATA
| N_EXT
:
2889 case N_NBDATA
| N_EXT
:
2890 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2891 SECT_OFF_DATA (objfile
));
2896 case N_NBBSS
| N_EXT
:
2897 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
2898 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2899 SECT_OFF_BSS (objfile
));
2906 /* Standard, local, non-debugger, symbols. */
2910 /* We need to be able to deal with both N_FN or
2911 N_TEXT, because we have no way of knowing
2912 whether the sys-supplied ld or GNU ld was used
2913 to make the executable. Sequents throw in
2914 another wrinkle -- they renumbered N_FN. */
2922 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
2923 SECT_OFF_DATA (objfile
));
2926 case N_UNDF
| N_EXT
:
2927 continue; /* Just undefined, not COMMON. */
2932 /* Lots of symbol types we can just ignore. */
2939 /* Keep going . . . */
2942 * Special symbol types for GNU
2945 case N_INDR
| N_EXT
:
2947 case N_SETA
| N_EXT
:
2949 case N_SETT
| N_EXT
:
2951 case N_SETD
| N_EXT
:
2953 case N_SETB
| N_EXT
:
2964 static int prev_so_symnum
= -10;
2965 static int first_so_symnum
;
2967 int prev_textlow_not_set
;
2969 valu
= sh
.value
+ ANOFFSET (objfile
->section_offsets
,
2970 SECT_OFF_TEXT (objfile
));
2972 prev_textlow_not_set
= textlow_not_set
;
2974 /* A zero value is probably an indication for the
2975 SunPRO 3.0 compiler. end_psymtab explicitly tests
2976 for zero, so don't relocate it. */
2979 && gdbarch_sofun_address_maybe_missing (gdbarch
))
2981 textlow_not_set
= 1;
2985 textlow_not_set
= 0;
2987 past_first_source_file
= 1;
2989 if (prev_so_symnum
!= symnum
- 1)
2990 { /* Here if prev stab wasn't N_SO. */
2991 first_so_symnum
= symnum
;
2995 pst
= (struct partial_symtab
*) 0;
2997 dependencies_used
= 0;
3001 prev_so_symnum
= symnum
;
3003 /* End the current partial symtab and start a
3006 /* SET_NAMESTRING ();*/
3007 namestring
= stabstring
;
3009 /* Null name means end of .o file. Don't start a new
3011 if (*namestring
== '\000')
3014 /* Some compilers (including gcc) emit a pair of
3015 initial N_SOs. The first one is a directory name;
3016 the second the file name. If pst exists, is
3017 empty, and has a filename ending in '/', we assume
3018 the previous N_SO was a directory name. */
3019 p
= lbasename (namestring
);
3020 if (p
!= namestring
&& *p
== '\000')
3021 continue; /* Simply ignore directory
3024 /* Some other compilers (C++ ones in particular) emit
3025 useless SOs for non-existant .c files. We ignore
3026 all subsequent SOs that immediately follow the
3039 enum language tmp_language
;
3041 /* Mark down an include file in the current psymtab. */
3043 /* SET_NAMESTRING (); */
3044 namestring
= stabstring
;
3047 = deduce_language_from_filename (namestring
);
3049 /* Only change the psymtab's language if we've
3050 learned something useful (eg. tmp_language is not
3051 language_unknown). In addition, to match what
3052 start_subfile does, never change from C++ to
3054 if (tmp_language
!= language_unknown
3055 && (tmp_language
!= language_c
3056 || psymtab_language
!= language_cplus
))
3057 psymtab_language
= tmp_language
;
3059 /* In C++, one may expect the same filename to come
3060 round many times, when code is coming alternately
3061 from the main file and from inline functions in
3062 other files. So I check to see if this is a file
3063 we've seen before -- either the main source file,
3064 or a previously included file.
3066 This seems to be a lot of time to be spending on
3067 N_SOL, but things like "break c-exp.y:435" need to
3068 work (I suppose the psymtab_include_list could be
3069 hashed or put in a binary tree, if profiling shows
3070 this is a major hog). */
3071 if (pst
&& filename_cmp (namestring
, pst
->filename
) == 0)
3077 for (i
= 0; i
< includes_used
; i
++)
3078 if (filename_cmp (namestring
,
3079 psymtab_include_list
[i
]) == 0)
3088 psymtab_include_list
[includes_used
++] = namestring
;
3089 if (includes_used
>= includes_allocated
)
3091 const char **orig
= psymtab_include_list
;
3093 psymtab_include_list
= (const char **)
3094 alloca ((includes_allocated
*= 2) *
3095 sizeof (const char *));
3096 memcpy (psymtab_include_list
, orig
,
3097 includes_used
* sizeof (const char *));
3101 case N_LSYM
: /* Typedef or automatic variable. */
3102 case N_STSYM
: /* Data seg var -- static */
3103 case N_LCSYM
: /* BSS " */
3104 case N_ROSYM
: /* Read-only data seg var -- static. */
3105 case N_NBSTS
: /* Gould nobase. */
3106 case N_NBLCS
: /* symbols. */
3108 case N_GSYM
: /* Global (extern) variable; can be
3109 data or bss (sigh FIXME). */
3111 /* Following may probably be ignored; I'll leave them here
3112 for now (until I do Pascal and Modula 2 extensions). */
3114 case N_PC
: /* I may or may not need this; I
3116 case N_M2C
: /* I suspect that I can ignore this
3118 case N_SCOPE
: /* Same. */
3120 /* SET_NAMESTRING (); */
3121 namestring
= stabstring
;
3122 p
= (char *) strchr (namestring
, ':');
3124 continue; /* Not a debugging symbol. */
3128 /* Main processing section for debugging symbols which
3129 the initial read through the symbol tables needs to
3130 worry about. If we reach this point, the symbol
3131 which we are considering is definitely one we are
3132 interested in. p must also contain the (valid)
3133 index into the namestring which indicates the
3134 debugging type symbol. */
3139 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3140 SECT_OFF_DATA (objfile
));
3142 if (gdbarch_static_transform_name_p (gdbarch
))
3143 namestring
= gdbarch_static_transform_name
3144 (gdbarch
, namestring
);
3146 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3147 VAR_DOMAIN
, LOC_STATIC
,
3148 &objfile
->static_psymbols
,
3150 psymtab_language
, objfile
);
3153 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3154 SECT_OFF_DATA (objfile
));
3155 /* The addresses in these entries are reported
3156 to be wrong. See the code that reads 'G's
3158 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3159 VAR_DOMAIN
, LOC_STATIC
,
3160 &objfile
->global_psymbols
,
3162 psymtab_language
, objfile
);
3166 /* When a 'T' entry is defining an anonymous enum, it
3167 may have a name which is the empty string, or a
3168 single space. Since they're not really defining a
3169 symbol, those shouldn't go in the partial symbol
3170 table. We do pick up the elements of such enums at
3171 'check_enum:', below. */
3172 if (p
>= namestring
+ 2
3173 || (p
== namestring
+ 1
3174 && namestring
[0] != ' '))
3176 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3177 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3178 &objfile
->static_psymbols
,
3180 psymtab_language
, objfile
);
3183 /* Also a typedef with the same name. */
3184 add_psymbol_to_list (namestring
,
3186 VAR_DOMAIN
, LOC_TYPEDEF
,
3187 &objfile
->static_psymbols
,
3196 if (p
!= namestring
) /* a name is there, not
3199 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3200 VAR_DOMAIN
, LOC_TYPEDEF
,
3201 &objfile
->static_psymbols
,
3203 psymtab_language
, objfile
);
3206 /* If this is an enumerated type, we need to add
3207 all the enum constants to the partial symbol
3208 table. This does not cover enums without names,
3209 e.g. "enum {a, b} c;" in C, but fortunately
3210 those are rare. There is no way for GDB to find
3211 those from the enum type without spending too
3212 much time on it. Thus to solve this problem,
3213 the compiler needs to put out the enum in a
3214 nameless type. GCC2 does this. */
3216 /* We are looking for something of the form
3217 <name> ":" ("t" | "T") [<number> "="] "e"
3218 {<constant> ":" <value> ","} ";". */
3220 /* Skip over the colon and the 't' or 'T'. */
3222 /* This type may be given a number. Also, numbers
3223 can come in pairs like (0,26). Skip over it. */
3224 while ((*p
>= '0' && *p
<= '9')
3225 || *p
== '(' || *p
== ',' || *p
== ')'
3231 /* The aix4 compiler emits extra crud before
3235 /* Skip over the type (?). */
3239 /* Skip over the colon. */
3243 /* We have found an enumerated type. */
3244 /* According to comments in read_enum_type
3245 a comma could end it instead of a semicolon.
3246 I don't know where that happens.
3248 while (*p
&& *p
!= ';' && *p
!= ',')
3252 /* Check for and handle cretinous dbx
3253 symbol name continuation! */
3254 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
3255 p
= next_symbol_text (objfile
);
3257 /* Point to the character after the name
3258 of the enum constant. */
3259 for (q
= p
; *q
&& *q
!= ':'; q
++)
3261 /* Note that the value doesn't matter for
3262 enum constants in psymtabs, just in
3264 add_psymbol_to_list (p
, q
- p
, 1,
3265 VAR_DOMAIN
, LOC_CONST
,
3266 &objfile
->static_psymbols
,
3267 0, 0, psymtab_language
,
3269 /* Point past the name. */
3271 /* Skip over the value. */
3272 while (*p
&& *p
!= ',')
3274 /* Advance past the comma. */
3281 /* Constant, e.g. from "const" in Pascal. */
3282 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3283 VAR_DOMAIN
, LOC_CONST
,
3284 &objfile
->static_psymbols
,
3285 sh
.value
, 0, psymtab_language
,
3292 int name_len
= p
- namestring
;
3293 char *name
= xmalloc (name_len
+ 1);
3295 memcpy (name
, namestring
, name_len
);
3296 name
[name_len
] = '\0';
3297 function_outside_compilation_unit_complaint (name
);
3300 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3301 SECT_OFF_TEXT (objfile
));
3302 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3303 VAR_DOMAIN
, LOC_BLOCK
,
3304 &objfile
->static_psymbols
,
3306 psymtab_language
, objfile
);
3309 /* Global functions were ignored here, but now they
3310 are put into the global psymtab like one would
3311 expect. They're also in the minimal symbol
3316 int name_len
= p
- namestring
;
3317 char *name
= xmalloc (name_len
+ 1);
3319 memcpy (name
, namestring
, name_len
);
3320 name
[name_len
] = '\0';
3321 function_outside_compilation_unit_complaint (name
);
3324 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3325 SECT_OFF_TEXT (objfile
));
3326 add_psymbol_to_list (namestring
, p
- namestring
, 1,
3327 VAR_DOMAIN
, LOC_BLOCK
,
3328 &objfile
->global_psymbols
,
3330 psymtab_language
, objfile
);
3333 /* Two things show up here (hopefully); static
3334 symbols of local scope (static used inside
3335 braces) or extensions of structure symbols. We
3350 case '#': /* For symbol identification (used
3355 /* It is a C++ nested symbol. We don't need to
3356 record it (I don't think); if we try to look up
3357 foo::bar::baz, then symbols for the symtab
3358 containing foo should get read in, I think. */
3359 /* Someone says sun cc puts out symbols like
3360 /foo/baz/maclib::/usr/local/bin/maclib,
3361 which would get here with a symbol type of ':'. */
3365 /* Unexpected symbol descriptor. The second and
3366 subsequent stabs of a continued stab can show up
3367 here. The question is whether they ever can
3368 mimic a normal stab--it would be nice if not,
3369 since we certainly don't want to spend the time
3370 searching to the end of every string looking for
3373 complaint (&symfile_complaints
,
3374 _("unknown symbol descriptor `%c'"), p
[1]);
3376 /* Ignore it; perhaps it is an extension that we don't
3385 /* Solaris 2 end of module, finish current partial
3386 symbol table. END_PSYMTAB will set
3387 pst->texthigh to the proper value, which is
3388 necessary if a module compiled without
3389 debugging info follows this module. */
3391 && gdbarch_sofun_address_maybe_missing (gdbarch
))
3393 pst
= (struct partial_symtab
*) 0;
3395 dependencies_used
= 0;
3400 if (sh
.value
> save_pst
->texthigh
)
3401 save_pst
->texthigh
= sh
.value
;
3406 case N_SSYM
: /* Claim: Structure or union
3407 element. Hopefully, I can
3409 case N_ENTRY
: /* Alternate entry point; can
3411 case N_MAIN
: /* Can definitely ignore this. */
3412 case N_CATCH
: /* These are GNU C++ extensions. */
3413 case N_EHDECL
: /* that can safely be ignored here. */
3423 case N_NSYMS
: /* Ultrix 4.0: symbol count */
3424 case N_DEFD
: /* GNU Modula-2 */
3425 case N_ALIAS
: /* SunPro F77: alias name, ignore
3428 case N_OBJ
: /* Useless types from Solaris. */
3430 /* These symbols aren't interesting; don't worry about
3436 /* If we haven't found it yet, ignore it. It's
3437 probably some new type we don't know about yet. */
3438 complaint (&symfile_complaints
,
3439 _("unknown symbol type %s"),
3440 hex_string (type_code
)); /* CUR_SYMBOL_TYPE */
3444 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
3447 /* end - Handle continuation */
3452 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
3455 enum address_class
class;
3457 (*swap_sym_in
) (cur_bfd
,
3458 ((char *) debug_info
->external_sym
3459 + ((fh
->isymBase
+ cur_sdx
)
3460 * external_sym_size
)),
3463 if (ECOFF_IS_STAB (&sh
))
3469 /* Non absolute static symbols go into the minimal table. */
3470 if (SC_IS_UNDEF (sh
.sc
) || sh
.sc
== scNil
3471 || (sh
.index
== indexNil
3472 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
3474 /* FIXME, premature? */
3479 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3485 /* The value of a stEnd symbol is the displacement from the
3486 corresponding start symbol value, do not relocate it. */
3488 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3489 SECT_OFF_TEXT (objfile
));
3496 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3497 SECT_OFF_DATA (objfile
));
3501 sh
.value
+= ANOFFSET (objfile
->section_offsets
,
3502 SECT_OFF_BSS (objfile
));
3513 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3515 SECT_OFF_TEXT (objfile
),
3521 /* Ignore all parameter symbol records. */
3522 if (sh
.index
>= hdr
->iauxMax
)
3524 /* Should not happen, but does when cross-compiling
3525 with the MIPS compiler. FIXME -- pull later. */
3526 index_complaint (name
);
3527 new_sdx
= cur_sdx
+ 1; /* Don't skip at all. */
3530 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
3531 (debug_info
->external_aux
3535 if (new_sdx
<= cur_sdx
)
3537 /* This should not happen either... FIXME. */
3538 complaint (&symfile_complaints
,
3539 _("bad proc end in aux found from symbol %s"),
3541 new_sdx
= cur_sdx
+ 1; /* Don't skip backward. */
3544 /* For stProc symbol records, we need to check the
3545 storage class as well, as only (stProc, scText)
3546 entries represent "real" procedures - See the
3547 Compaq document titled "Object File / Symbol Table
3548 Format Specification" for more information. If the
3549 storage class is not scText, we discard the whole
3550 block of symbol records for this stProc. */
3551 if (sh
.st
== stProc
&& sh
.sc
!= scText
)
3554 /* Usually there is a local and a global stProc symbol
3555 for a function. This means that the function name
3556 has already been entered into the mimimal symbol table
3557 while processing the global symbols in pass 2 above.
3558 One notable exception is the PROGRAM name from
3559 f77 compiled executables, it is only put out as
3560 local stProc symbol, and a global MAIN__ stProc symbol
3561 points to it. It doesn't matter though, as gdb is
3562 still able to find the PROGRAM name via the partial
3563 symbol table, and the MAIN__ symbol via the minimal
3565 if (sh
.st
== stProc
)
3566 add_psymbol_to_list (name
, strlen (name
), 1,
3567 VAR_DOMAIN
, LOC_BLOCK
,
3568 &objfile
->global_psymbols
,
3569 0, sh
.value
, psymtab_language
, objfile
);
3571 add_psymbol_to_list (name
, strlen (name
), 1,
3572 VAR_DOMAIN
, LOC_BLOCK
,
3573 &objfile
->static_psymbols
,
3574 0, sh
.value
, psymtab_language
, objfile
);
3576 procaddr
= sh
.value
;
3579 (*swap_sym_in
) (cur_bfd
,
3580 ((char *) debug_info
->external_sym
3581 + ((fh
->isymBase
+ cur_sdx
- 1)
3582 * external_sym_size
)),
3587 /* Kludge for Irix 5.2 zero fh->adr. */
3589 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
3590 pst
->textlow
= procaddr
;
3592 high
= procaddr
+ sh
.value
;
3593 if (high
> pst
->texthigh
)
3594 pst
->texthigh
= high
;
3597 case stStatic
: /* Variable */
3598 if (SC_IS_DATA (sh
.sc
))
3599 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3601 SECT_OFF_DATA (objfile
),
3605 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3607 SECT_OFF_BSS (objfile
),
3613 case stIndirect
: /* Irix5 forward declaration */
3614 /* Skip forward declarations from Irix5 cc. */
3617 case stTypedef
: /* Typedef */
3618 /* Skip typedefs for forward declarations and opaque
3619 structs from alpha and mips cc. */
3620 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
3622 class = LOC_TYPEDEF
;
3625 case stConstant
: /* Constant decl */
3632 case stBlock
: /* { }, str, un, enum */
3633 /* Do not create a partial symbol for cc unnamed aggregates
3634 and gcc empty aggregates. */
3635 if ((sh
.sc
== scInfo
3636 || SC_IS_COMMON (sh
.sc
))
3638 && sh
.index
!= cur_sdx
+ 2)
3640 add_psymbol_to_list (name
, strlen (name
), 1,
3641 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3642 &objfile
->static_psymbols
,
3644 psymtab_language
, objfile
);
3646 handle_psymbol_enumerators (objfile
, fh
, sh
.st
, sh
.value
);
3648 /* Skip over the block. */
3650 if (new_sdx
<= cur_sdx
)
3652 /* This happens with the Ultrix kernel. */
3653 complaint (&symfile_complaints
,
3654 _("bad aux index at block symbol %s"), name
);
3655 new_sdx
= cur_sdx
+ 1; /* Don't skip backward. */
3660 case stFile
: /* File headers */
3661 case stLabel
: /* Labels */
3662 case stEnd
: /* Ends of files */
3665 case stLocal
: /* Local variables */
3666 /* Normally these are skipped because we skip over
3667 all blocks we see. However, these can occur
3668 as visible symbols in a .h file that contains code. */
3672 /* Both complaints are valid: one gives symbol name,
3673 the other the offending symbol type. */
3674 complaint (&symfile_complaints
, _("unknown local symbol %s"),
3676 complaint (&symfile_complaints
, _("with type %d"), sh
.st
);
3680 /* Use this gdb symbol. */
3681 add_psymbol_to_list (name
, strlen (name
), 1,
3683 &objfile
->static_psymbols
,
3684 0, sh
.value
, psymtab_language
, objfile
);
3686 cur_sdx
++; /* Go to next file symbol. */
3689 /* Now do enter the external symbols. */
3690 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
3691 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
3692 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
3693 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
3694 for (; --cur_sdx
>= 0; ext_ptr
++)
3696 enum address_class
class;
3701 if (ext_ptr
->ifd
!= f_idx
)
3702 internal_error (__FILE__
, __LINE__
,
3703 _("failed internal consistency check"));
3704 psh
= &ext_ptr
->asym
;
3706 /* Do not add undefined symbols to the partial symbol table. */
3707 if (SC_IS_UNDEF (psh
->sc
) || psh
->sc
== scNil
)
3710 svalue
= psh
->value
;
3715 svalue
+= ANOFFSET (objfile
->section_offsets
,
3716 SECT_OFF_TEXT (objfile
));
3723 svalue
+= ANOFFSET (objfile
->section_offsets
,
3724 SECT_OFF_DATA (objfile
));
3728 svalue
+= ANOFFSET (objfile
->section_offsets
,
3729 SECT_OFF_BSS (objfile
));
3736 /* These are generated for static symbols in .o files,
3741 /* External procedure symbols have been entered
3742 into the minimal symbol table in pass 2 above.
3743 Ignore them, as parse_external will ignore them too. */
3749 unknown_ext_complaint (debug_info
->ssext
+ psh
->iss
);
3750 /* Fall through, pretend it's global. */
3752 /* Global common symbols are resolved by the runtime loader,
3754 if (SC_IS_COMMON (psh
->sc
))
3760 name
= debug_info
->ssext
+ psh
->iss
;
3761 add_psymbol_to_list (name
, strlen (name
), 1,
3763 &objfile
->global_psymbols
,
3765 psymtab_language
, objfile
);
3769 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3770 empty and put on the free list. */
3771 fdr_to_pst
[f_idx
].pst
= end_psymtab (objfile
, save_pst
,
3772 psymtab_include_list
, includes_used
,
3773 -1, save_pst
->texthigh
,
3774 dependency_list
, dependencies_used
, textlow_not_set
);
3776 dependencies_used
= 0;
3778 /* The objfile has its functions reordered if this partial symbol
3779 table overlaps any other partial symbol table.
3780 We cannot assume a reordered objfile if a partial symbol table
3781 is contained within another partial symbol table, as partial symbol
3782 tables for include files with executable code are contained
3783 within the partial symbol table for the including source file,
3784 and we do not want to flag the objfile reordered for these cases.
3786 This strategy works well for Irix-5.2 shared libraries, but we
3787 might have to use a more elaborate (and slower) algorithm for
3789 save_pst
= fdr_to_pst
[f_idx
].pst
;
3790 if (save_pst
!= NULL
3791 && save_pst
->textlow
!= 0
3792 && !(objfile
->flags
& OBJF_REORDERED
))
3794 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
3797 && save_pst
->textlow
>= pst
->textlow
3798 && save_pst
->textlow
< pst
->texthigh
3799 && save_pst
->texthigh
> pst
->texthigh
)
3801 objfile
->flags
|= OBJF_REORDERED
;
3808 /* Now scan the FDRs for dependencies. */
3809 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3811 fh
= f_idx
+ debug_info
->fdr
;
3812 pst
= fdr_to_pst
[f_idx
].pst
;
3814 if (pst
== (struct partial_symtab
*) NULL
)
3817 /* This should catch stabs-in-ecoff. */
3821 /* Skip the first file indirect entry as it is a self dependency for
3822 source files or a reverse .h -> .c dependency for header files. */
3823 pst
->number_of_dependencies
= 0;
3825 ((struct partial_symtab
**)
3826 obstack_alloc (&objfile
->objfile_obstack
,
3828 * sizeof (struct partial_symtab
*))));
3829 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3833 (*swap_rfd_in
) (cur_bfd
,
3834 ((char *) debug_info
->external_rfd
3835 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3837 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3839 complaint (&symfile_complaints
, _("bad file number %ld"), rh
);
3843 /* Skip self dependencies of header files. */
3847 /* Do not add to dependeny list if psymtab was empty. */
3848 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*) NULL
)
3850 pst
->dependencies
[pst
->number_of_dependencies
++]
3851 = fdr_to_pst
[rh
].pst
;
3855 /* Remove the dummy psymtab created for -O3 images above, if it is
3856 still empty, to enable the detection of stripped executables. */
3857 if (objfile
->psymtabs
->next
== NULL
3858 && objfile
->psymtabs
->number_of_dependencies
== 0
3859 && objfile
->psymtabs
->n_global_syms
== 0
3860 && objfile
->psymtabs
->n_static_syms
== 0)
3861 objfile
->psymtabs
= NULL
;
3862 do_cleanups (old_chain
);
3865 /* If the current psymbol has an enumerated type, we need to add
3866 all the enum constants to the partial symbol table. */
3869 handle_psymbol_enumerators (struct objfile
*objfile
, FDR
*fh
, int stype
,
3872 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3873 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
3874 char *ext_sym
= ((char *) debug_info
->external_sym
3875 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3885 /* It is an enumerated type if the next symbol entry is a stMember
3886 and its auxiliary index is indexNil or its auxiliary entry
3887 is a plain btNil or btVoid.
3888 Alpha cc -migrate enums are recognized by a zero index and
3889 a zero symbol value.
3890 DU 4.0 cc enums are recognized by a member type of btEnum without
3891 qualifiers and a zero symbol value. */
3892 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3893 if (sh
.st
!= stMember
)
3896 if (sh
.index
== indexNil
3897 || (sh
.index
== 0 && svalue
== 0))
3899 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3900 &(debug_info
->external_aux
3901 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3903 if ((tir
.bt
!= btNil
3905 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3906 || tir
.tq0
!= tqNil
)
3918 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3919 if (sh
.st
!= stMember
)
3921 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3923 /* Note that the value doesn't matter for enum constants
3924 in psymtabs, just in symtabs. */
3925 add_psymbol_to_list (name
, strlen (name
), 1,
3926 VAR_DOMAIN
, LOC_CONST
,
3927 &objfile
->static_psymbols
, 0,
3928 (CORE_ADDR
) 0, psymtab_language
, objfile
);
3929 ext_sym
+= external_sym_size
;
3933 /* Get the next symbol. OBJFILE is unused. */
3936 mdebug_next_symbol_text (struct objfile
*objfile
)
3941 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3942 ((char *) debug_info
->external_sym
3943 + ((cur_fdr
->isymBase
+ cur_sdx
)
3944 * debug_swap
->external_sym_size
)),
3946 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3949 /* Ancillary function to psymtab_to_symtab(). Does all the work
3950 for turning the partial symtab PST into a symtab, recurring
3951 first on all dependent psymtabs. The argument FILENAME is
3952 only passed so we can see in debug stack traces what file
3955 This function has a split personality, based on whether the
3956 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3957 The flow of control and even the memory allocation differs. FIXME. */
3960 psymtab_to_symtab_1 (struct objfile
*objfile
,
3961 struct partial_symtab
*pst
, const char *filename
)
3963 bfd_size_type external_sym_size
;
3964 bfd_size_type external_pdr_size
;
3965 void (*swap_sym_in
) (bfd
*, void *, SYMR
*);
3966 void (*swap_pdr_in
) (bfd
*, void *, PDR
*);
3968 struct symtab
*st
= NULL
;
3970 struct linetable
*lines
;
3971 CORE_ADDR lowest_pdr_addr
= 0;
3972 int last_symtab_ended
= 0;
3978 /* Read in all partial symbtabs on which this one is dependent.
3979 NOTE that we do have circular dependencies, sigh. We solved
3980 that by setting pst->readin before this point. */
3982 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3983 if (!pst
->dependencies
[i
]->readin
)
3985 /* Inform about additional files to be read in. */
3988 fputs_filtered (" ", gdb_stdout
);
3990 fputs_filtered ("and ", gdb_stdout
);
3992 printf_filtered ("%s...",
3993 pst
->dependencies
[i
]->filename
);
3994 wrap_here (""); /* Flush output */
3995 gdb_flush (gdb_stdout
);
3997 /* We only pass the filename for debug purposes. */
3998 psymtab_to_symtab_1 (objfile
, pst
->dependencies
[i
],
3999 pst
->dependencies
[i
]->filename
);
4002 /* Do nothing if this is a dummy psymtab. */
4004 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
4005 && pst
->textlow
== 0 && pst
->texthigh
== 0)
4008 /* Now read the symbols for this symtab. */
4010 cur_bfd
= CUR_BFD (pst
);
4011 debug_swap
= DEBUG_SWAP (pst
);
4012 debug_info
= DEBUG_INFO (pst
);
4013 pending_list
= PENDING_LIST (pst
);
4014 external_sym_size
= debug_swap
->external_sym_size
;
4015 external_pdr_size
= debug_swap
->external_pdr_size
;
4016 swap_sym_in
= debug_swap
->swap_sym_in
;
4017 swap_pdr_in
= debug_swap
->swap_pdr_in
;
4018 mdebugread_objfile
= objfile
;
4019 cur_fd
= FDR_IDX (pst
);
4020 fh
= ((cur_fd
== -1)
4022 : debug_info
->fdr
+ cur_fd
);
4025 /* See comment in parse_partial_symbols about the @stabs sentinel. */
4026 processing_gcc_compilation
= 0;
4027 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
4031 (*swap_sym_in
) (cur_bfd
,
4032 ((char *) debug_info
->external_sym
4033 + (fh
->isymBase
+ 1) * external_sym_size
),
4035 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
4038 /* We indicate that this is a GCC compilation so that certain
4039 features will be enabled in stabsread/dbxread. */
4040 processing_gcc_compilation
= 2;
4044 if (processing_gcc_compilation
!= 0)
4046 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4048 /* This symbol table contains stabs-in-ecoff entries. */
4050 /* Parse local symbols first. */
4052 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr. */
4054 mdebugread_objfile
= NULL
;
4057 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
4063 (*swap_sym_in
) (cur_bfd
,
4064 (((char *) debug_info
->external_sym
)
4065 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
4067 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4069 /* XXX This is a hack. It will go away! */
4070 if (ECOFF_IS_STAB (&sh
) || (name
[0] == '#'))
4072 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
4074 /* We should never get non N_STAB symbols here, but they
4075 should be harmless, so keep process_one_symbol from
4076 complaining about them. */
4077 if (type_code
& N_STAB
)
4079 /* If we found a trailing N_SO with no name, process
4080 it here instead of in process_one_symbol, so we
4081 can keep a handle to its symtab. The symtab
4082 would otherwise be ended twice, once in
4083 process_one_symbol, and once after this loop. */
4084 if (type_code
== N_SO
4086 && previous_stab_code
!= (unsigned char) N_SO
4089 valu
+= ANOFFSET (pst
->section_offsets
,
4090 SECT_OFF_TEXT (objfile
));
4091 previous_stab_code
= N_SO
;
4092 st
= end_symtab (valu
, objfile
,
4093 SECT_OFF_TEXT (objfile
));
4095 last_symtab_ended
= 1;
4099 last_symtab_ended
= 0;
4100 process_one_symbol (type_code
, 0, valu
, name
,
4101 pst
->section_offsets
, objfile
);
4104 /* Similarly a hack. */
4105 else if (name
[0] == '#')
4107 process_one_symbol (N_SLINE
, 0, valu
, name
,
4108 pst
->section_offsets
, objfile
);
4110 if (type_code
== N_FUN
)
4112 /* Make up special symbol to contain
4113 procedure specific info. */
4114 struct mdebug_extra_func_info
*e
=
4115 ((struct mdebug_extra_func_info
*)
4116 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
4117 sizeof (struct mdebug_extra_func_info
)));
4118 struct symbol
*s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
4120 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
4121 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
4122 SYMBOL_CLASS (s
) = LOC_CONST
;
4123 SYMBOL_TYPE (s
) = objfile_type (objfile
)->builtin_void
;
4124 SYMBOL_VALUE_BYTES (s
) = (gdb_byte
*) e
;
4125 e
->pdr
.framereg
= -1;
4126 add_symbol_to_list (s
, &local_symbols
);
4129 else if (sh
.st
== stLabel
)
4131 if (sh
.index
== indexNil
)
4133 /* This is what the gcc2_compiled and __gnu_compiled_*
4134 show up as. So don't complain. */
4139 /* Handle encoded stab line number. */
4140 valu
+= ANOFFSET (pst
->section_offsets
,
4141 SECT_OFF_TEXT (objfile
));
4142 record_line (current_subfile
, sh
.index
,
4143 gdbarch_addr_bits_remove (gdbarch
, valu
));
4146 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
4147 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
4148 /* These are generated by gcc-2.x, do not complain. */
4151 complaint (&symfile_complaints
,
4152 _("unknown stabs symbol %s"), name
);
4155 if (! last_symtab_ended
)
4157 st
= end_symtab (pst
->texthigh
, objfile
,
4158 SECT_OFF_TEXT (objfile
));
4162 /* There used to be a call to sort_blocks here, but this should not
4163 be necessary for stabs symtabs. And as sort_blocks modifies the
4164 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
4165 it did the wrong thing if the first procedure in a file was
4166 generated via asm statements. */
4168 /* Fill in procedure info next. */
4172 struct cleanup
*old_chain
;
4178 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4179 old_chain
= make_cleanup (xfree
, pr_block
);
4181 pdr_ptr
= ((char *) debug_info
->external_pdr
4182 + fh
->ipdFirst
* external_pdr_size
);
4183 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4187 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4189 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4191 /* Determine lowest PDR address, the PDRs are not always
4193 if (pdr_in
== pr_block
)
4194 lowest_pdr_addr
= pdr_in
->adr
;
4195 else if (pdr_in
->adr
< lowest_pdr_addr
)
4196 lowest_pdr_addr
= pdr_in
->adr
;
4200 pdr_in_end
= pdr_in
+ fh
->cpd
;
4201 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4202 parse_procedure (pdr_in
, st
, pst
);
4204 do_cleanups (old_chain
);
4209 /* This symbol table contains ordinary ecoff entries. */
4217 st
= new_symtab ("unknown", 0, objfile
);
4221 maxlines
= 2 * fh
->cline
;
4222 st
= new_symtab (pst
->filename
, maxlines
, objfile
);
4224 /* The proper language was already determined when building
4225 the psymtab, use it. */
4226 st
->language
= PST_PRIVATE (pst
)->pst_language
;
4229 psymtab_language
= st
->language
;
4231 lines
= LINETABLE (st
);
4233 /* Get a new lexical context. */
4235 push_parse_stack ();
4236 top_stack
->cur_st
= st
;
4237 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
4239 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
4240 BLOCK_END (top_stack
->cur_block
) = 0;
4241 top_stack
->blocktype
= stFile
;
4242 top_stack
->cur_type
= 0;
4243 top_stack
->procadr
= 0;
4244 top_stack
->numargs
= 0;
4245 found_ecoff_debugging_info
= 0;
4252 /* Parse local symbols first. */
4253 sym_ptr
= ((char *) debug_info
->external_sym
4254 + fh
->isymBase
* external_sym_size
);
4255 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
4256 while (sym_ptr
< sym_end
)
4261 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
4262 c
= parse_symbol (&sh
,
4263 debug_info
->external_aux
+ fh
->iauxBase
,
4264 sym_ptr
, fh
->fBigendian
,
4265 pst
->section_offsets
, objfile
);
4266 sym_ptr
+= c
* external_sym_size
;
4269 /* Linenumbers. At the end, check if we can save memory.
4270 parse_lines has to look ahead an arbitrary number of PDR
4271 structures, so we swap them all first. */
4275 struct cleanup
*old_chain
;
4281 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4283 old_chain
= make_cleanup (xfree
, pr_block
);
4285 pdr_ptr
= ((char *) debug_info
->external_pdr
4286 + fh
->ipdFirst
* external_pdr_size
);
4287 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4291 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4293 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4295 /* Determine lowest PDR address, the PDRs are not always
4297 if (pdr_in
== pr_block
)
4298 lowest_pdr_addr
= pdr_in
->adr
;
4299 else if (pdr_in
->adr
< lowest_pdr_addr
)
4300 lowest_pdr_addr
= pdr_in
->adr
;
4303 parse_lines (fh
, pr_block
, lines
, maxlines
,
4304 pst
, lowest_pdr_addr
);
4305 if (lines
->nitems
< fh
->cline
)
4306 lines
= shrink_linetable (lines
);
4308 /* Fill in procedure info next. */
4310 pdr_in_end
= pdr_in
+ fh
->cpd
;
4311 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4312 parse_procedure (pdr_in
, 0, pst
);
4314 do_cleanups (old_chain
);
4318 size
= lines
->nitems
;
4321 LINETABLE (st
) = obstack_copy (&mdebugread_objfile
->objfile_obstack
,
4323 (sizeof (struct linetable
)
4324 + size
* sizeof (lines
->item
)));
4327 /* .. and our share of externals.
4328 XXX use the global list to speed up things here. How?
4329 FIXME, Maybe quit once we have found the right number of ext's? */
4330 top_stack
->cur_st
= st
;
4331 top_stack
->cur_block
4332 = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
4334 top_stack
->blocktype
= stFile
;
4336 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
4337 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
4338 parse_external (ext_ptr
, fh
->fBigendian
,
4339 pst
->section_offsets
, objfile
);
4341 /* If there are undefined symbols, tell the user.
4342 The alpha has an undefined symbol for every symbol that is
4343 from a shared library, so tell the user only if verbose is on. */
4344 if (info_verbose
&& n_undef_symbols
)
4346 printf_filtered (_("File %s contains %d unresolved references:"),
4347 st
->filename
, n_undef_symbols
);
4348 printf_filtered ("\n\t%4d variables\n\t%4d "
4349 "procedures\n\t%4d labels\n",
4350 n_undef_vars
, n_undef_procs
, n_undef_labels
);
4351 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
4361 /* Now link the psymtab and the symtab. */
4364 mdebugread_objfile
= NULL
;
4367 /* Ancillary parsing procedures. */
4369 /* Return 1 if the symbol pointed to by SH has a cross reference
4370 to an opaque aggregate type, else 0. */
4373 has_opaque_xref (FDR
*fh
, SYMR
*sh
)
4380 if (sh
->index
== indexNil
)
4383 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
4384 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
4385 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
4389 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
4390 if (rn
->rfd
== 0xfff)
4391 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
4399 /* Lookup the type at relative index RN. Return it in TPP
4400 if found and in any event come up with its name PNAME.
4401 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4402 Return value says how many aux symbols we ate. */
4405 cross_ref (int fd
, union aux_ext
*ax
, struct type
**tpp
,
4406 enum type_code type_code
,
4407 /* Use to alloc new type if none is found. */
4408 char **pname
, int bigend
, char *sym_name
)
4417 struct mdebug_pending
*pend
;
4419 *tpp
= (struct type
*) NULL
;
4421 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
4423 /* Escape index means 'the next one'. */
4424 if (rn
->rfd
== 0xfff)
4427 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
4434 /* mips cc uses a rf of -1 for opaque struct definitions.
4435 Set TYPE_FLAG_STUB for these types so that check_typedef will
4436 resolve them if the struct gets defined in another compilation unit. */
4439 *pname
= "<undefined>";
4440 *tpp
= init_type (type_code
, 0, TYPE_FLAG_STUB
,
4441 (char *) NULL
, mdebugread_objfile
);
4445 /* mips cc uses an escaped rn->index of 0 for struct return types
4446 of procedures that were compiled without -g. These will always remain
4448 if (rn
->rfd
== 0xfff && rn
->index
== 0)
4450 *pname
= "<undefined>";
4454 /* Find the relative file descriptor and the symbol in it. */
4455 fh
= get_rfd (fd
, rf
);
4456 xref_fd
= fh
- debug_info
->fdr
;
4458 if (rn
->index
>= fh
->csym
)
4460 /* File indirect entry is corrupt. */
4461 *pname
= "<illegal>";
4462 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4466 /* If we have processed this symbol then we left a forwarding
4467 pointer to the type in the pending list. If not, we`ll put
4468 it in a list of pending types, to be processed later when
4469 the file will be. In any event, we collect the name for the
4472 esh
= ((char *) debug_info
->external_sym
4473 + ((fh
->isymBase
+ rn
->index
)
4474 * debug_swap
->external_sym_size
));
4475 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
4477 /* Make sure that this type of cross reference can be handled. */
4478 if ((sh
.sc
!= scInfo
4479 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
4480 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
4481 && sh
.st
!= stEnum
))
4482 && (sh
.st
!= stBlock
|| !SC_IS_COMMON (sh
.sc
)))
4484 /* File indirect entry is corrupt. */
4485 *pname
= "<illegal>";
4486 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4490 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4492 pend
= is_pending_symbol (fh
, esh
);
4497 /* We have not yet seen this type. */
4499 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
4503 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4505 a) forward declarations of structs/unions/enums which are not
4506 defined in this compilation unit.
4507 For these the type will be void. This is a bad design decision
4508 as cross referencing across compilation units is impossible
4509 due to the missing name.
4510 b) forward declarations of structs/unions/enums/typedefs which
4511 are defined later in this file or in another file in the same
4512 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4513 Simply cross reference those again to get the true type.
4514 The forward references are not entered in the pending list and
4515 in the symbol table. */
4517 (*debug_swap
->swap_tir_in
) (bigend
,
4518 &(debug_info
->external_aux
4519 + fh
->iauxBase
+ sh
.index
)->a_ti
,
4521 if (tir
.tq0
!= tqNil
)
4522 complaint (&symfile_complaints
,
4523 _("illegal tq0 in forward typedef for %s"), sym_name
);
4527 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4528 mdebugread_objfile
);
4529 *pname
= "<undefined>";
4536 (debug_info
->external_aux
4537 + fh
->iauxBase
+ sh
.index
+ 1),
4538 tpp
, type_code
, pname
,
4539 fh
->fBigendian
, sym_name
);
4543 /* Follow a forward typedef. This might recursively
4544 call cross_ref till we get a non typedef'ed type.
4545 FIXME: This is not correct behaviour, but gdb currently
4546 cannot handle typedefs without type copying. Type
4547 copying is impossible as we might have mutual forward
4548 references between two files and the copied type would not
4549 get filled in when we later parse its definition. */
4550 *tpp
= parse_type (xref_fd
,
4551 debug_info
->external_aux
+ fh
->iauxBase
,
4555 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4556 add_pending (fh
, esh
, *tpp
);
4560 complaint (&symfile_complaints
,
4561 _("illegal bt %d in forward typedef for %s"), tir
.bt
,
4563 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4564 mdebugread_objfile
);
4569 else if (sh
.st
== stTypedef
)
4571 /* Parse the type for a normal typedef. This might recursively call
4572 cross_ref till we get a non typedef'ed type.
4573 FIXME: This is not correct behaviour, but gdb currently
4574 cannot handle typedefs without type copying. But type copying is
4575 impossible as we might have mutual forward references between
4576 two files and the copied type would not get filled in when
4577 we later parse its definition. */
4578 *tpp
= parse_type (xref_fd
,
4579 debug_info
->external_aux
+ fh
->iauxBase
,
4583 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4587 /* Cross reference to a struct/union/enum which is defined
4588 in another file in the same compilation unit but that file
4589 has not been parsed yet.
4590 Initialize the type only, it will be filled in when
4591 it's definition is parsed. */
4592 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, mdebugread_objfile
);
4594 add_pending (fh
, esh
, *tpp
);
4597 /* We used one auxent normally, two if we got a "next one" rf. */
4602 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4603 keeping the symtab sorted. */
4605 static struct symbol
*
4606 mylookup_symbol (char *name
, struct block
*block
,
4607 domain_enum domain
, enum address_class
class)
4609 struct block_iterator iter
;
4614 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
4616 if (SYMBOL_LINKAGE_NAME (sym
)[0] == inc
4617 && SYMBOL_DOMAIN (sym
) == domain
4618 && SYMBOL_CLASS (sym
) == class
4619 && strcmp (SYMBOL_LINKAGE_NAME (sym
), name
) == 0)
4623 block
= BLOCK_SUPERBLOCK (block
);
4625 return mylookup_symbol (name
, block
, domain
, class);
4630 /* Add a new symbol S to a block B. */
4633 add_symbol (struct symbol
*s
, struct symtab
*symtab
, struct block
*b
)
4635 SYMBOL_SYMTAB (s
) = symtab
;
4636 dict_add_symbol (BLOCK_DICT (b
), s
);
4639 /* Add a new block B to a symtab S. */
4642 add_block (struct block
*b
, struct symtab
*s
)
4644 struct blockvector
*bv
= BLOCKVECTOR (s
);
4646 bv
= (struct blockvector
*) xrealloc ((void *) bv
,
4647 (sizeof (struct blockvector
)
4648 + BLOCKVECTOR_NBLOCKS (bv
)
4649 * sizeof (bv
->block
)));
4650 if (bv
!= BLOCKVECTOR (s
))
4651 BLOCKVECTOR (s
) = bv
;
4653 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
4656 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4657 MIPS' linenumber encoding might need more than one byte
4658 to describe it, LAST is used to detect these continuation lines.
4660 Combining lines with the same line number seems like a bad idea.
4661 E.g: There could be a line number entry with the same line number after the
4662 prologue and GDB should not ignore it (this is a better way to find
4663 a prologue than mips_skip_prologue).
4664 But due to the compressed line table format there are line number entries
4665 for the same line which are needed to bridge the gap to the next
4666 line number entry. These entries have a bogus address info with them
4667 and we are unable to tell them from intended duplicate line number
4669 This is another reason why -ggdb debugging format is preferable. */
4672 add_line (struct linetable
*lt
, int lineno
, CORE_ADDR adr
, int last
)
4674 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4675 Change them to something sensible. */
4679 last
= -2; /* Make sure we record first line. */
4681 if (last
== lineno
) /* Skip continuation lines. */
4684 lt
->item
[lt
->nitems
].line
= lineno
;
4685 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
4689 /* Sorting and reordering procedures. */
4691 /* Blocks with a smaller low bound should come first. */
4694 compare_blocks (const void *arg1
, const void *arg2
)
4697 struct block
**b1
= (struct block
**) arg1
;
4698 struct block
**b2
= (struct block
**) arg2
;
4700 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
4702 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
4706 /* Sort the blocks of a symtab S.
4707 Reorder the blocks in the blockvector by code-address,
4708 as required by some MI search routines. */
4711 sort_blocks (struct symtab
*s
)
4713 struct blockvector
*bv
= BLOCKVECTOR (s
);
4715 if (BLOCKVECTOR_NBLOCKS (bv
) <= FIRST_LOCAL_BLOCK
)
4718 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
4719 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
4720 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
4721 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
4725 * This is very unfortunate: normally all functions are compiled in
4726 * the order they are found, but if the file is compiled -O3 things
4727 * are very different. It would be nice to find a reliable test
4728 * to detect -O3 images in advance.
4730 if (BLOCKVECTOR_NBLOCKS (bv
) > FIRST_LOCAL_BLOCK
+ 1)
4731 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
4732 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
4733 sizeof (struct block
*),
4738 int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
4740 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
4741 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
4742 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
4743 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
4746 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
4747 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
4749 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4750 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4751 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4752 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4756 /* Constructor/restructor/destructor procedures. */
4758 /* Allocate a new symtab for NAME. Needs an estimate of how many
4759 linenumbers MAXLINES we'll put in it. */
4761 static struct symtab
*
4762 new_symtab (const char *name
, int maxlines
, struct objfile
*objfile
)
4764 struct symtab
*s
= allocate_symtab (name
, objfile
);
4766 LINETABLE (s
) = new_linetable (maxlines
);
4768 /* All symtabs must have at least two blocks. */
4769 BLOCKVECTOR (s
) = new_bvect (2);
4770 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
)
4771 = new_block (NON_FUNCTION_BLOCK
);
4772 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
4773 = new_block (NON_FUNCTION_BLOCK
);
4774 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
4775 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4777 s
->debugformat
= "ECOFF";
4781 /* Allocate a new partial_symtab NAME. */
4783 static struct partial_symtab
*
4784 new_psymtab (char *name
, struct objfile
*objfile
)
4786 struct partial_symtab
*psymtab
;
4788 psymtab
= allocate_psymtab (name
, objfile
);
4789 psymtab
->section_offsets
= objfile
->section_offsets
;
4791 /* Keep a backpointer to the file's symbols. */
4793 psymtab
->read_symtab_private
= obstack_alloc (&objfile
->objfile_obstack
,
4794 sizeof (struct symloc
));
4795 memset (psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
4796 CUR_BFD (psymtab
) = cur_bfd
;
4797 DEBUG_SWAP (psymtab
) = debug_swap
;
4798 DEBUG_INFO (psymtab
) = debug_info
;
4799 PENDING_LIST (psymtab
) = pending_list
;
4801 /* The way to turn this into a symtab is to call... */
4802 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
4807 /* Allocate a linetable array of the given SIZE. Since the struct
4808 already includes one item, we subtract one when calculating the
4809 proper size to allocate. */
4811 static struct linetable
*
4812 new_linetable (int size
)
4814 struct linetable
*l
;
4818 size
= size
* sizeof (l
->item
) + sizeof (struct linetable
);
4819 l
= (struct linetable
*) xmalloc (size
);
4824 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4825 I am not so sure about the 3.4 ones.
4827 Since the struct linetable already includes one item, we subtract one when
4828 calculating the proper size to allocate. */
4830 static struct linetable
*
4831 shrink_linetable (struct linetable
*lt
)
4833 return (struct linetable
*) xrealloc ((void *) lt
,
4834 (sizeof (struct linetable
)
4836 * sizeof (lt
->item
))));
4839 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4841 static struct blockvector
*
4842 new_bvect (int nblocks
)
4844 struct blockvector
*bv
;
4847 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4848 bv
= (struct blockvector
*) xzalloc (size
);
4850 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4855 /* Allocate and zero a new block, and set its BLOCK_DICT. If function
4856 is non-zero, assume the block is associated to a function, and make
4857 sure that the symbols are stored linearly; otherwise, store them
4860 static struct block
*
4861 new_block (enum block_type type
)
4863 /* FIXME: carlton/2003-09-11: This should use allocate_block to
4864 allocate the block. Which, in turn, suggests that the block
4865 should be allocated on an obstack. */
4866 struct block
*retval
= xzalloc (sizeof (struct block
));
4868 if (type
== FUNCTION_BLOCK
)
4869 BLOCK_DICT (retval
) = dict_create_linear_expandable ();
4871 BLOCK_DICT (retval
) = dict_create_hashed_expandable ();
4876 /* Create a new symbol with printname NAME. */
4878 static struct symbol
*
4879 new_symbol (char *name
)
4881 struct symbol
*s
= ((struct symbol
*)
4882 obstack_alloc (&mdebugread_objfile
->objfile_obstack
,
4883 sizeof (struct symbol
)));
4885 memset (s
, 0, sizeof (*s
));
4886 SYMBOL_SET_LANGUAGE (s
, psymtab_language
);
4887 SYMBOL_SET_NAMES (s
, name
, strlen (name
), 1, mdebugread_objfile
);
4891 /* Create a new type with printname NAME. */
4893 static struct type
*
4894 new_type (char *name
)
4898 t
= alloc_type (mdebugread_objfile
);
4899 TYPE_NAME (t
) = name
;
4900 INIT_CPLUS_SPECIFIC (t
);
4904 /* Read ECOFF debugging information from a BFD section. This is
4905 called from elfread.c. It parses the section into a
4906 ecoff_debug_info struct, and then lets the rest of the file handle
4910 elfmdebug_build_psymtabs (struct objfile
*objfile
,
4911 const struct ecoff_debug_swap
*swap
, asection
*sec
)
4913 bfd
*abfd
= objfile
->obfd
;
4914 struct ecoff_debug_info
*info
;
4915 struct cleanup
*back_to
;
4917 /* FIXME: It's not clear whether we should be getting minimal symbol
4918 information from .mdebug in an ELF file, or whether we will.
4919 Re-initialize the minimal symbol reader in case we do. */
4921 init_minimal_symbol_collection ();
4922 back_to
= make_cleanup_discard_minimal_symbols ();
4924 info
= ((struct ecoff_debug_info
*)
4925 obstack_alloc (&objfile
->objfile_obstack
,
4926 sizeof (struct ecoff_debug_info
)));
4928 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4929 error (_("Error reading ECOFF debugging information: %s"),
4930 bfd_errmsg (bfd_get_error ()));
4932 mdebug_build_psymtabs (objfile
, swap
, info
);
4934 install_minimal_symbols (objfile
);
4935 do_cleanups (back_to
);
4939 _initialize_mdebugread (void)
4941 basic_type_data
= register_objfile_data ();