1 /* Read a symbol table in ECOFF format (Third-Eye).
3 Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
5 Free Software Foundation, Inc.
7 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
8 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
11 This file is part of GDB.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 3 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 /* This module provides the function mdebug_build_psymtabs. It reads
27 ECOFF debugging information into partial symbol tables. The
28 debugging information is read from two structures. A struct
29 ecoff_debug_swap includes the sizes of each ECOFF structure and
30 swapping routines; these are fixed for a particular target. A
31 struct ecoff_debug_info points to the debugging information for a
32 particular object file.
34 ECOFF symbol tables are mostly written in the byte order of the
35 target machine. However, one section of the table (the auxiliary
36 symbol information) is written in the host byte order. There is a
37 bit in the other symbol info which describes which host byte order
38 was used. ECOFF thereby takes the trophy from Intel `b.out' for
39 the most brain-dead adaptation of a file format to byte order.
41 This module can read all four of the known byte-order combinations,
42 on any type of host. */
49 #include "gdb_obstack.h"
51 #include "stabsread.h"
52 #include "complaints.h"
54 #include "gdb_assert.h"
56 #include "dictionary.h"
57 #include "mdebugread.h"
59 #include "gdb_string.h"
63 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
65 #include "libaout.h" /* Private BFD a.out information. */
66 #include "aout/aout64.h"
67 #include "aout/stab_gnu.h" /* STABS information */
69 #include "expression.h"
71 extern void _initialize_mdebugread (void);
73 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
74 We use this define in order to know whether we should override a
75 symbol's ECOFF section with its ELF section. This is necessary in
76 case the symbol's ELF section could not be represented in ECOFF. */
77 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
78 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
81 /* We put a pointer to this structure in the read_symtab_private field
86 /* Index of the FDR that this psymtab represents. */
88 /* The BFD that the psymtab was created from. */
90 const struct ecoff_debug_swap
*debug_swap
;
91 struct ecoff_debug_info
*debug_info
;
92 struct mdebug_pending
**pending_list
;
93 /* Pointer to external symbols for this file. */
95 /* Size of extern_tab. */
97 enum language pst_language
;
100 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
101 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
102 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
103 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
104 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
105 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
107 #define SC_IS_TEXT(sc) ((sc) == scText \
108 || (sc) == scRConst \
111 #define SC_IS_DATA(sc) ((sc) == scData \
116 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
117 #define SC_IS_BSS(sc) ((sc) == scBss)
118 #define SC_IS_SBSS(sc) ((sc) == scSBss)
119 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
121 /* Various complaints about symbol reading that don't abort the process */
123 index_complaint (const char *arg1
)
125 complaint (&symfile_complaints
, _("bad aux index at symbol %s"), arg1
);
129 unknown_ext_complaint (const char *arg1
)
131 complaint (&symfile_complaints
, _("unknown external symbol %s"), arg1
);
135 basic_type_complaint (int arg1
, const char *arg2
)
137 complaint (&symfile_complaints
, _("cannot map ECOFF basic type 0x%x for %s"),
142 bad_tag_guess_complaint (const char *arg1
)
144 complaint (&symfile_complaints
, _("guessed tag type of %s incorrectly"), arg1
);
148 bad_rfd_entry_complaint (const char *arg1
, int arg2
, int arg3
)
150 complaint (&symfile_complaints
, _("bad rfd entry for %s: file %d, index %d"),
155 unexpected_type_code_complaint (const char *arg1
)
157 complaint (&symfile_complaints
, _("unexpected type code for %s"), arg1
);
160 /* Macros and extra defs */
162 /* Puns: hard to find whether -g was used and how */
164 #define MIN_GLEVEL GLEVEL_0
165 #define compare_glevel(a,b) \
166 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
167 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
169 /* Things that really are local to this module */
171 /* Remember what we deduced to be the source language of this psymtab. */
173 static enum language psymtab_language
= language_unknown
;
179 /* How to parse debugging information for CUR_BFD. */
181 static const struct ecoff_debug_swap
*debug_swap
;
183 /* Pointers to debugging information for CUR_BFD. */
185 static struct ecoff_debug_info
*debug_info
;
187 /* Pointer to current file decriptor record, and its index */
192 /* Index of current symbol */
196 /* Note how much "debuggable" this image is. We would like
197 to see at least one FDR with full symbols */
199 static int max_gdbinfo
;
200 static int max_glevel
;
202 /* When examining .o files, report on undefined symbols */
204 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
206 /* Pseudo symbol to use when putting stabs into the symbol table. */
208 static char stabs_symbol
[] = STABS_SYMBOL
;
210 /* Types corresponding to mdebug format bt* basic types. */
212 static struct type
*mdebug_type_void
;
213 static struct type
*mdebug_type_char
;
214 static struct type
*mdebug_type_short
;
215 static struct type
*mdebug_type_int_32
;
216 #define mdebug_type_int mdebug_type_int_32
217 static struct type
*mdebug_type_int_64
;
218 static struct type
*mdebug_type_long_32
;
219 static struct type
*mdebug_type_long_64
;
220 static struct type
*mdebug_type_long_long_64
;
221 static struct type
*mdebug_type_unsigned_char
;
222 static struct type
*mdebug_type_unsigned_short
;
223 static struct type
*mdebug_type_unsigned_int_32
;
224 static struct type
*mdebug_type_unsigned_int_64
;
225 static struct type
*mdebug_type_unsigned_long_32
;
226 static struct type
*mdebug_type_unsigned_long_64
;
227 static struct type
*mdebug_type_unsigned_long_long_64
;
228 static struct type
*mdebug_type_adr_32
;
229 static struct type
*mdebug_type_adr_64
;
230 static struct type
*mdebug_type_float
;
231 static struct type
*mdebug_type_double
;
232 static struct type
*mdebug_type_complex
;
233 static struct type
*mdebug_type_double_complex
;
234 static struct type
*mdebug_type_fixed_dec
;
235 static struct type
*mdebug_type_float_dec
;
236 static struct type
*mdebug_type_string
;
238 /* Nonzero if we have seen ecoff debugging info for a file. */
240 static int found_ecoff_debugging_info
;
242 /* Forward declarations */
244 static int upgrade_type (int, struct type
**, int, union aux_ext
*,
247 static void parse_partial_symbols (struct objfile
*);
249 static int has_opaque_xref (FDR
*, SYMR
*);
251 static int cross_ref (int, union aux_ext
*, struct type
**, enum type_code
,
252 char **, int, char *);
254 static struct symbol
*new_symbol (char *);
256 static struct type
*new_type (char *);
258 enum block_type
{ FUNCTION_BLOCK
, NON_FUNCTION_BLOCK
};
260 static struct block
*new_block (enum block_type
);
262 static struct symtab
*new_symtab (char *, int, struct objfile
*);
264 static struct linetable
*new_linetable (int);
266 static struct blockvector
*new_bvect (int);
268 static struct type
*parse_type (int, union aux_ext
*, unsigned int, int *,
271 static struct symbol
*mylookup_symbol (char *, struct block
*, domain_enum
,
274 static void sort_blocks (struct symtab
*);
276 static struct partial_symtab
*new_psymtab (char *, struct objfile
*);
278 static void psymtab_to_symtab_1 (struct partial_symtab
*, char *);
280 static void add_block (struct block
*, struct symtab
*);
282 static void add_symbol (struct symbol
*, struct block
*);
284 static int add_line (struct linetable
*, int, CORE_ADDR
, int);
286 static struct linetable
*shrink_linetable (struct linetable
*);
288 static void handle_psymbol_enumerators (struct objfile
*, FDR
*, int,
291 static char *mdebug_next_symbol_text (struct objfile
*);
293 /* Exported procedure: Builds a symtab from the PST partial one.
294 Restores the environment in effect when PST was created, delegates
295 most of the work to an ancillary procedure, and sorts
296 and reorders the symtab list at the end */
299 mdebug_psymtab_to_symtab (struct partial_symtab
*pst
)
307 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
308 gdb_flush (gdb_stdout
);
311 next_symbol_text_func
= mdebug_next_symbol_text
;
313 psymtab_to_symtab_1 (pst
, pst
->filename
);
315 /* Match with global symbols. This only needs to be done once,
316 after all of the symtabs and dependencies have been read in. */
317 scan_file_globals (pst
->objfile
);
320 printf_filtered (_("done.\n"));
323 /* File-level interface functions */
325 /* Find a file descriptor given its index RF relative to a file CF */
328 get_rfd (int cf
, int rf
)
334 fdrs
= debug_info
->fdr
;
336 /* Object files do not have the RFD table, all refs are absolute */
339 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
340 ((char *) debug_info
->external_rfd
342 * debug_swap
->external_rfd_size
)),
347 /* Return a safer print NAME for a file descriptor */
353 return "<stripped file>";
356 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
360 /* Read in and parse the symtab of the file OBJFILE. Symbols from
361 different sections are relocated via the SECTION_OFFSETS. */
364 mdebug_build_psymtabs (struct objfile
*objfile
,
365 const struct ecoff_debug_swap
*swap
,
366 struct ecoff_debug_info
*info
)
368 cur_bfd
= objfile
->obfd
;
372 stabsread_new_init ();
373 buildsym_new_init ();
374 free_header_files ();
375 init_header_files ();
377 /* Make sure all the FDR information is swapped in. */
378 if (info
->fdr
== (FDR
*) NULL
)
384 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->objfile_obstack
,
385 (info
->symbolic_header
.ifdMax
387 fdr_src
= info
->external_fdr
;
389 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
391 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
392 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
395 parse_partial_symbols (objfile
);
398 /* Check to make sure file was compiled with -g. If not, warn the
399 user of this limitation. */
400 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
402 if (max_gdbinfo
== 0)
403 printf_unfiltered (_("\n%s not compiled with -g, debugging support is limited.\n"),
405 printf_unfiltered (_("You should compile with -g2 or -g3 for best debugging support.\n"));
406 gdb_flush (gdb_stdout
);
411 /* Local utilities */
413 /* Map of FDR indexes to partial symtabs */
417 struct partial_symtab
*pst
; /* the psymtab proper */
418 long n_globals
; /* exported globals (external symbols) */
419 long globals_offset
; /* cumulative */
423 /* Utility stack, used to nest procedures and blocks properly.
424 It is a doubly linked list, to avoid too many alloc/free.
425 Since we might need it quite a few times it is NOT deallocated
428 static struct parse_stack
430 struct parse_stack
*next
, *prev
;
431 struct symtab
*cur_st
; /* Current symtab. */
432 struct block
*cur_block
; /* Block in it. */
434 /* What are we parsing. stFile, or stBlock are for files and
435 blocks. stProc or stStaticProc means we have seen the start of a
436 procedure, but not the start of the block within in. When we see
437 the start of that block, we change it to stNil, without pushing a
438 new block, i.e. stNil means both a procedure and a block. */
442 struct type
*cur_type
; /* Type we parse fields for. */
443 int cur_field
; /* Field number in cur_type. */
444 CORE_ADDR procadr
; /* Start addres of this procedure */
445 int numargs
; /* Its argument count */
448 *top_stack
; /* Top stack ptr */
451 /* Enter a new lexical context */
454 push_parse_stack (void)
456 struct parse_stack
*new;
458 /* Reuse frames if possible */
459 if (top_stack
&& top_stack
->prev
)
460 new = top_stack
->prev
;
462 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
463 /* Initialize new frame with previous content */
466 struct parse_stack
*prev
= new->prev
;
469 top_stack
->prev
= new;
471 new->next
= top_stack
;
476 /* Exit a lexical context */
479 pop_parse_stack (void)
484 top_stack
= top_stack
->next
;
488 /* Cross-references might be to things we haven't looked at
489 yet, e.g. type references. To avoid too many type
490 duplications we keep a quick fixup table, an array
491 of lists of references indexed by file descriptor */
493 struct mdebug_pending
495 struct mdebug_pending
*next
; /* link */
496 char *s
; /* the unswapped symbol */
497 struct type
*t
; /* its partial type descriptor */
501 /* The pending information is kept for an entire object file, and used
502 to be in the deprecated_sym_private field. I took it out when I
503 split mdebugread from mipsread, because this might not be the only
504 type of symbols read from an object file. Instead, we allocate the
505 pending information table when we create the partial symbols, and
506 we store a pointer to the single table in each psymtab. */
508 static struct mdebug_pending
**pending_list
;
510 /* Check whether we already saw symbol SH in file FH */
512 static struct mdebug_pending
*
513 is_pending_symbol (FDR
*fh
, char *sh
)
515 int f_idx
= fh
- debug_info
->fdr
;
516 struct mdebug_pending
*p
;
518 /* Linear search is ok, list is typically no more than 10 deep */
519 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
525 /* Add a new symbol SH of type T */
528 add_pending (FDR
*fh
, char *sh
, struct type
*t
)
530 int f_idx
= fh
- debug_info
->fdr
;
531 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
533 /* Make sure we do not make duplicates */
536 p
= ((struct mdebug_pending
*)
537 obstack_alloc (¤t_objfile
->objfile_obstack
,
538 sizeof (struct mdebug_pending
)));
541 p
->next
= pending_list
[f_idx
];
542 pending_list
[f_idx
] = p
;
547 /* Parsing Routines proper. */
549 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
550 For blocks, procedures and types we open a new lexical context.
551 This is basically just a big switch on the symbol's type. Argument
552 AX is the base pointer of aux symbols for this file (fh->iauxBase).
553 EXT_SH points to the unswapped symbol, which is needed for struct,
554 union, etc., types; it is NULL for an EXTR. BIGEND says whether
555 aux symbols are big-endian or little-endian. Return count of
556 SYMR's handled (normally one). */
559 parse_symbol (SYMR
*sh
, union aux_ext
*ax
, char *ext_sh
, int bigend
,
560 struct section_offsets
*section_offsets
, struct objfile
*objfile
)
562 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
563 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
567 struct mdebug_pending
*pend
;
571 enum address_class
class;
573 long svalue
= sh
->value
;
576 if (ext_sh
== (char *) NULL
)
577 name
= debug_info
->ssext
+ sh
->iss
;
579 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
585 /* Do not relocate relative values.
586 The value of a stEnd symbol is the displacement from the
587 corresponding start symbol value.
588 The value of a stBlock symbol is the displacement from the
589 procedure address. */
590 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
591 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
598 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
602 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS (objfile
));
611 case stGlobal
: /* external symbol, goes into global block */
613 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
615 s
= new_symbol (name
);
616 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
619 case stStatic
: /* static data, goes into current block. */
621 b
= top_stack
->cur_block
;
622 s
= new_symbol (name
);
623 if (SC_IS_COMMON (sh
->sc
))
625 /* It is a FORTRAN common block. At least for SGI Fortran the
626 address is not in the symbol; we need to fix it later in
627 scan_file_globals. */
628 int bucket
= hashname (DEPRECATED_SYMBOL_NAME (s
));
629 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
630 global_sym_chain
[bucket
] = s
;
633 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
636 case stLocal
: /* local variable, goes into current block */
637 if (sh
->sc
== scRegister
)
639 class = LOC_REGISTER
;
640 svalue
= gdbarch_ecoff_reg_to_regnum (current_gdbarch
, svalue
);
644 b
= top_stack
->cur_block
;
645 s
= new_symbol (name
);
646 SYMBOL_VALUE (s
) = svalue
;
648 data
: /* Common code for symbols describing data */
649 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
650 SYMBOL_CLASS (s
) = class;
653 /* Type could be missing if file is compiled without debugging info. */
654 if (SC_IS_UNDEF (sh
->sc
)
655 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
656 SYMBOL_TYPE (s
) = builtin_type (current_gdbarch
)->nodebug_data_symbol
;
658 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
659 /* Value of a data symbol is its memory address */
662 case stParam
: /* arg to procedure, goes into current block */
664 found_ecoff_debugging_info
= 1;
665 top_stack
->numargs
++;
667 /* Special GNU C++ name. */
668 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
669 name
= "this"; /* FIXME, not alloc'd in obstack */
670 s
= new_symbol (name
);
672 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
676 /* Pass by value in register. */
677 SYMBOL_CLASS (s
) = LOC_REGPARM
;
678 svalue
= gdbarch_ecoff_reg_to_regnum (current_gdbarch
, svalue
);
681 /* Pass by reference on stack. */
682 SYMBOL_CLASS (s
) = LOC_REF_ARG
;
685 /* Pass by reference in register. */
686 SYMBOL_CLASS (s
) = LOC_REGPARM_ADDR
;
687 svalue
= gdbarch_ecoff_reg_to_regnum (current_gdbarch
, svalue
);
690 /* Pass by value on stack. */
691 SYMBOL_CLASS (s
) = LOC_ARG
;
694 SYMBOL_VALUE (s
) = svalue
;
695 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
696 add_symbol (s
, top_stack
->cur_block
);
699 case stLabel
: /* label, goes into current block */
700 s
= new_symbol (name
);
701 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
; /* so that it can be used */
702 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
703 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
704 SYMBOL_TYPE (s
) = mdebug_type_int
;
705 add_symbol (s
, top_stack
->cur_block
);
708 case stProc
: /* Procedure, usually goes into global block */
709 case stStaticProc
: /* Static procedure, goes into current block */
710 /* For stProc symbol records, we need to check the storage class
711 as well, as only (stProc, scText) entries represent "real"
712 procedures - See the Compaq document titled "Object File /
713 Symbol Table Format Specification" for more information.
714 If the storage class is not scText, we discard the whole block
715 of symbol records for this stProc. */
716 if (sh
->st
== stProc
&& sh
->sc
!= scText
)
718 char *ext_tsym
= ext_sh
;
719 int keep_counting
= 1;
722 while (keep_counting
)
724 ext_tsym
+= external_sym_size
;
725 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
735 complaint (&symfile_complaints
,
736 _("unknown symbol type 0x%x"), sh
->st
);
742 s
= new_symbol (name
);
743 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
744 SYMBOL_CLASS (s
) = LOC_BLOCK
;
745 /* Type of the return value */
746 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
750 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
751 if (strcmp (name
, "malloc") == 0
752 && TYPE_CODE (t
) == TYPE_CODE_VOID
)
754 /* I don't know why, but, at least under Alpha GNU/Linux,
755 when linking against a malloc without debugging
756 symbols, its read as a function returning void---this
757 is bad because it means we cannot call functions with
758 string arguments interactively; i.e., "call
759 printf("howdy\n")" would fail with the error message
760 "program has no memory available". To avoid this, we
761 patch up the type and make it void*
762 instead. (davidm@azstarnet.com)
764 t
= make_pointer_type (t
, NULL
);
767 b
= top_stack
->cur_block
;
768 if (sh
->st
== stProc
)
770 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
771 /* The next test should normally be true, but provides a
772 hook for nested functions (which we don't want to make
774 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
775 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
776 /* Irix 5 sometimes has duplicate names for the same
777 function. We want to add such names up at the global
778 level, not as a nested function. */
779 else if (sh
->value
== top_stack
->procadr
)
780 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
784 /* Make a type for the procedure itself */
785 SYMBOL_TYPE (s
) = lookup_function_type (t
);
787 /* All functions in C++ have prototypes. For C we don't have enough
788 information in the debug info. */
789 if (SYMBOL_LANGUAGE (s
) == language_cplus
)
790 TYPE_FLAGS (SYMBOL_TYPE (s
)) |= TYPE_FLAG_PROTOTYPED
;
792 /* Create and enter a new lexical context */
793 b
= new_block (FUNCTION_BLOCK
);
794 SYMBOL_BLOCK_VALUE (s
) = b
;
795 BLOCK_FUNCTION (b
) = s
;
796 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
797 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
798 add_block (b
, top_stack
->cur_st
);
800 /* Not if we only have partial info */
801 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
805 top_stack
->cur_block
= b
;
806 top_stack
->blocktype
= sh
->st
;
807 top_stack
->cur_type
= SYMBOL_TYPE (s
);
808 top_stack
->cur_field
= -1;
809 top_stack
->procadr
= sh
->value
;
810 top_stack
->numargs
= 0;
813 /* Beginning of code for structure, union, and enum definitions.
814 They all share a common set of local variables, defined here. */
816 enum type_code type_code
;
822 case stStruct
: /* Start a block defining a struct type */
823 type_code
= TYPE_CODE_STRUCT
;
824 goto structured_common
;
826 case stUnion
: /* Start a block defining a union type */
827 type_code
= TYPE_CODE_UNION
;
828 goto structured_common
;
830 case stEnum
: /* Start a block defining an enum type */
831 type_code
= TYPE_CODE_ENUM
;
832 goto structured_common
;
834 case stBlock
: /* Either a lexical block, or some type */
835 if (sh
->sc
!= scInfo
&& !SC_IS_COMMON (sh
->sc
))
836 goto case_stBlock_code
; /* Lexical block */
838 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
840 /* Common code for handling struct, union, enum, and/or as-yet-
841 unknown-type blocks of info about structured data. `type_code'
842 has been set to the proper TYPE_CODE, if we know it. */
844 found_ecoff_debugging_info
= 1;
846 top_stack
->blocktype
= stBlock
;
848 /* First count the number of fields and the highest value. */
851 for (ext_tsym
= ext_sh
+ external_sym_size
;
853 ext_tsym
+= external_sym_size
)
857 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
862 /* C++ encodes class types as structures where there the
863 methods are encoded as stProc. The scope of stProc
864 symbols also ends with stEnd, thus creating a risk of
865 taking the wrong stEnd symbol record as the end of
866 the current struct, which would cause GDB to undercount
867 the real number of fields in this struct. To make sure
868 we really reached the right stEnd symbol record, we
869 check the associated name, and match it against the
870 struct name. Since method names are mangled while
871 the class name is not, there is no risk of having a
872 method whose name is identical to the class name
873 (in particular constructor method names are different
874 from the class name). There is therefore no risk that
875 this check stops the count on the StEnd of a method.
877 Also, assume that we're really at the end when tsym.iss
879 if (tsym
.iss
== issNull
880 || strcmp (debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
,
886 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
888 /* If the type of the member is Nil (or Void),
889 without qualifiers, assume the tag is an
891 Alpha cc -migrate enums are recognized by a zero
892 index and a zero symbol value.
893 DU 4.0 cc enums are recognized by a member type of
894 btEnum without qualifiers and a zero symbol value. */
895 if (tsym
.index
== indexNil
896 || (tsym
.index
== 0 && sh
->value
== 0))
897 type_code
= TYPE_CODE_ENUM
;
900 (*debug_swap
->swap_tir_in
) (bigend
,
901 &ax
[tsym
.index
].a_ti
,
903 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
904 || (tir
.bt
== btEnum
&& sh
->value
== 0))
906 type_code
= TYPE_CODE_ENUM
;
910 if (tsym
.value
> max_value
)
911 max_value
= tsym
.value
;
920 /* This is a no-op; is it trying to tell us something
921 we should be checking? */
922 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED */
926 /* This is something like a struct within a
927 struct. Skip over the fields of the inner
928 struct. The -1 is because the for loop will
929 increment ext_tsym. */
930 ext_tsym
= ((char *) debug_info
->external_sym
931 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
932 * external_sym_size
));
938 /* mips cc puts out a typedef for struct x if it is not yet
939 defined when it encounters
940 struct y { struct x *xp; };
945 /* Irix5 cc puts out a stIndirect for struct x if it is not
946 yet defined when it encounters
947 struct y { struct x *xp; };
952 complaint (&symfile_complaints
,
953 _("declaration block contains unhandled symbol type %d"),
959 /* In an stBlock, there is no way to distinguish structs,
960 unions, and enums at this point. This is a bug in the
961 original design (that has been fixed with the recent
962 addition of the stStruct, stUnion, and stEnum symbol
963 types.) The way you can tell is if/when you see a variable
964 or field of that type. In that case the variable's type
965 (in the AUX table) says if the type is struct, union, or
966 enum, and points back to the stBlock here. So you can
967 patch the tag kind up later - but only if there actually is
968 a variable or field of that type.
970 So until we know for sure, we will guess at this point.
972 If the first member has index==indexNil or a void type,
973 assume we have an enumeration.
974 Otherwise, if there is more than one member, and all
975 the members have offset 0, assume we have a union.
976 Otherwise, assume we have a struct.
978 The heuristic could guess wrong in the case of of an
979 enumeration with no members or a union with one (or zero)
980 members, or when all except the last field of a struct have
981 width zero. These are uncommon and/or illegal situations,
982 and in any case guessing wrong probably doesn't matter
985 But if we later do find out we were wrong, we fixup the tag
986 kind. Members of an enumeration must be handled
987 differently from struct/union fields, and that is harder to
988 patch up, but luckily we shouldn't need to. (If there are
989 any enumeration members, we can tell for sure it's an enum
992 if (type_code
== TYPE_CODE_UNDEF
)
994 if (nfields
> 1 && max_value
== 0)
995 type_code
= TYPE_CODE_UNION
;
997 type_code
= TYPE_CODE_STRUCT
;
1000 /* Create a new type or use the pending type. */
1001 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1002 if (pend
== (struct mdebug_pending
*) NULL
)
1004 t
= new_type (NULL
);
1005 add_pending (cur_fdr
, ext_sh
, t
);
1010 /* Do not set the tag name if it is a compiler generated tag name
1011 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1012 Alpha cc puts out an sh->iss of zero for those. */
1013 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1014 TYPE_TAG_NAME (t
) = NULL
;
1016 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->objfile_obstack
,
1019 TYPE_CODE (t
) = type_code
;
1020 TYPE_LENGTH (t
) = sh
->value
;
1021 TYPE_NFIELDS (t
) = nfields
;
1022 TYPE_FIELDS (t
) = f
= ((struct field
*)
1024 nfields
* sizeof (struct field
)));
1026 if (type_code
== TYPE_CODE_ENUM
)
1028 int unsigned_enum
= 1;
1030 /* This is a non-empty enum. */
1032 /* DEC c89 has the number of enumerators in the sh.value field,
1033 not the type length, so we have to compensate for that
1034 incompatibility quirk.
1035 This might do the wrong thing for an enum with one or two
1036 enumerators and gcc -gcoff -fshort-enums, but these cases
1037 are hopefully rare enough.
1038 Alpha cc -migrate has a sh.value field of zero, we adjust
1040 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
)
1041 || TYPE_LENGTH (t
) == 0)
1043 gdbarch_int_bit (current_gdbarch
) / HOST_CHAR_BIT
;
1044 for (ext_tsym
= ext_sh
+ external_sym_size
;
1046 ext_tsym
+= external_sym_size
)
1049 struct symbol
*enum_sym
;
1051 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1053 if (tsym
.st
!= stMember
)
1056 FIELD_BITPOS (*f
) = tsym
.value
;
1057 FIELD_TYPE (*f
) = t
;
1058 FIELD_NAME (*f
) = debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1059 FIELD_BITSIZE (*f
) = 0;
1060 FIELD_STATIC_KIND (*f
) = 0;
1062 enum_sym
= ((struct symbol
*)
1063 obstack_alloc (¤t_objfile
->objfile_obstack
,
1064 sizeof (struct symbol
)));
1065 memset (enum_sym
, 0, sizeof (struct symbol
));
1066 DEPRECATED_SYMBOL_NAME (enum_sym
) =
1067 obsavestring (f
->name
, strlen (f
->name
),
1068 ¤t_objfile
->objfile_obstack
);
1069 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1070 SYMBOL_TYPE (enum_sym
) = t
;
1071 SYMBOL_DOMAIN (enum_sym
) = VAR_DOMAIN
;
1072 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1073 if (SYMBOL_VALUE (enum_sym
) < 0)
1075 add_symbol (enum_sym
, top_stack
->cur_block
);
1077 /* Skip the stMembers that we've handled. */
1082 TYPE_FLAGS (t
) |= TYPE_FLAG_UNSIGNED
;
1084 /* make this the current type */
1085 top_stack
->cur_type
= t
;
1086 top_stack
->cur_field
= 0;
1088 /* Do not create a symbol for alpha cc unnamed structs. */
1092 /* gcc puts out an empty struct for an opaque struct definitions,
1093 do not create a symbol for it either. */
1094 if (TYPE_NFIELDS (t
) == 0)
1096 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1100 s
= new_symbol (name
);
1101 SYMBOL_DOMAIN (s
) = STRUCT_DOMAIN
;
1102 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1103 SYMBOL_VALUE (s
) = 0;
1104 SYMBOL_TYPE (s
) = t
;
1105 add_symbol (s
, top_stack
->cur_block
);
1108 /* End of local variables shared by struct, union, enum, and
1109 block (as yet unknown struct/union/enum) processing. */
1113 found_ecoff_debugging_info
= 1;
1114 /* beginnning of (code) block. Value of symbol
1115 is the displacement from procedure start */
1116 push_parse_stack ();
1118 /* Do not start a new block if this is the outermost block of a
1119 procedure. This allows the LOC_BLOCK symbol to point to the
1120 block with the local variables, so funcname::var works. */
1121 if (top_stack
->blocktype
== stProc
1122 || top_stack
->blocktype
== stStaticProc
)
1124 top_stack
->blocktype
= stNil
;
1128 top_stack
->blocktype
= stBlock
;
1129 b
= new_block (NON_FUNCTION_BLOCK
);
1130 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1131 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1132 top_stack
->cur_block
= b
;
1133 add_block (b
, top_stack
->cur_st
);
1136 case stEnd
: /* end (of anything) */
1137 if (sh
->sc
== scInfo
|| SC_IS_COMMON (sh
->sc
))
1139 /* Finished with type */
1140 top_stack
->cur_type
= 0;
1142 else if (sh
->sc
== scText
&&
1143 (top_stack
->blocktype
== stProc
||
1144 top_stack
->blocktype
== stStaticProc
))
1146 /* Finished with procedure */
1147 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1148 struct mdebug_extra_func_info
*e
;
1149 struct block
*b
= top_stack
->cur_block
;
1150 struct type
*ftype
= top_stack
->cur_type
;
1153 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1155 /* Make up special symbol to contain procedure specific info */
1156 s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
1157 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
1158 SYMBOL_CLASS (s
) = LOC_CONST
;
1159 SYMBOL_TYPE (s
) = mdebug_type_void
;
1160 e
= ((struct mdebug_extra_func_info
*)
1161 obstack_alloc (¤t_objfile
->objfile_obstack
,
1162 sizeof (struct mdebug_extra_func_info
)));
1163 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
1164 SYMBOL_VALUE (s
) = (long) e
;
1165 e
->numargs
= top_stack
->numargs
;
1166 e
->pdr
.framereg
= -1;
1167 add_symbol (s
, top_stack
->cur_block
);
1169 /* f77 emits proc-level with address bounds==[0,0],
1170 So look for such child blocks, and patch them. */
1171 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1173 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1174 if (BLOCK_SUPERBLOCK (b_bad
) == b
1175 && BLOCK_START (b_bad
) == top_stack
->procadr
1176 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1178 BLOCK_START (b_bad
) = BLOCK_START (b
);
1179 BLOCK_END (b_bad
) = BLOCK_END (b
);
1183 if (TYPE_NFIELDS (ftype
) <= 0)
1185 /* No parameter type information is recorded with the function's
1186 type. Set that from the type of the parameter symbols. */
1187 int nparams
= top_stack
->numargs
;
1193 struct dict_iterator iter
;
1194 TYPE_NFIELDS (ftype
) = nparams
;
1195 TYPE_FIELDS (ftype
) = (struct field
*)
1196 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1199 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1201 if (iparams
== nparams
)
1204 switch (SYMBOL_CLASS (sym
))
1209 case LOC_REGPARM_ADDR
:
1210 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1211 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
1221 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1223 /* End of (code) block. The value of the symbol is the
1224 displacement from the procedure`s start address of the
1225 end of this block. */
1226 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1228 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1230 /* End of outermost block. Pop parse stack and ignore. The
1231 following stEnd of stProc will take care of the block. */
1234 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1236 /* End of file. Pop parse stack and ignore. Higher
1237 level code deals with this. */
1241 complaint (&symfile_complaints
,
1242 _("stEnd with storage class %d not handled"), sh
->sc
);
1244 pop_parse_stack (); /* restore previous lexical context */
1247 case stMember
: /* member of struct or union */
1248 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1249 FIELD_NAME (*f
) = name
;
1250 FIELD_BITPOS (*f
) = sh
->value
;
1252 FIELD_TYPE (*f
) = parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1253 FIELD_BITSIZE (*f
) = bitsize
;
1254 FIELD_STATIC_KIND (*f
) = 0;
1257 case stIndirect
: /* forward declaration on Irix5 */
1258 /* Forward declarations from Irix5 cc are handled by cross_ref,
1262 case stTypedef
: /* type definition */
1263 found_ecoff_debugging_info
= 1;
1265 /* Typedefs for forward declarations and opaque structs from alpha cc
1266 are handled by cross_ref, skip them. */
1270 /* Parse the type or use the pending type. */
1271 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1272 if (pend
== (struct mdebug_pending
*) NULL
)
1274 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *) NULL
, bigend
, name
);
1275 add_pending (cur_fdr
, ext_sh
, t
);
1280 /* mips cc puts out a typedef with the name of the struct for forward
1281 declarations. These should not go into the symbol table and
1282 TYPE_NAME should not be set for them.
1283 They can't be distinguished from an intentional typedef to
1284 the same name however:
1286 struct x { int ix; int jx; };
1290 struct xx {int ixx; int jxx; };
1291 generates a cross referencing stTypedef for x and xx.
1292 The user visible effect of this is that the type of a pointer
1293 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1294 The problem is fixed with alpha cc and Irix5 cc. */
1296 /* However if the typedef cross references to an opaque aggregate, it
1297 is safe to omit it from the symbol table. */
1299 if (has_opaque_xref (cur_fdr
, sh
))
1301 s
= new_symbol (name
);
1302 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1303 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1304 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1305 SYMBOL_TYPE (s
) = t
;
1306 add_symbol (s
, top_stack
->cur_block
);
1308 /* Incomplete definitions of structs should not get a name. */
1309 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1310 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1311 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1312 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1314 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1315 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1317 /* If we are giving a name to a type such as "pointer to
1318 foo" or "function returning foo", we better not set
1319 the TYPE_NAME. If the program contains "typedef char
1320 *caddr_t;", we don't want all variables of type char
1321 * to print as caddr_t. This is not just a
1322 consequence of GDB's type management; CC and GCC (at
1323 least through version 2.4) both output variables of
1324 either type char * or caddr_t with the type
1325 refering to the stTypedef symbol for caddr_t. If a future
1326 compiler cleans this up it GDB is not ready for it
1327 yet, but if it becomes ready we somehow need to
1328 disable this check (without breaking the PCC/GCC2.4
1333 Fortunately, this check seems not to be necessary
1334 for anything except pointers or functions. */
1337 TYPE_NAME (SYMBOL_TYPE (s
)) = DEPRECATED_SYMBOL_NAME (s
);
1341 case stFile
: /* file name */
1342 push_parse_stack ();
1343 top_stack
->blocktype
= sh
->st
;
1346 /* I`ve never seen these for C */
1348 break; /* register relocation */
1350 break; /* forwarding address */
1352 break; /* constant */
1354 complaint (&symfile_complaints
, _("unknown symbol type 0x%x"), sh
->st
);
1361 /* Parse the type information provided in the raw AX entries for
1362 the symbol SH. Return the bitfield size in BS, in case.
1363 We must byte-swap the AX entries before we use them; BIGEND says whether
1364 they are big-endian or little-endian (from fh->fBigendian). */
1366 static struct type
*
1367 parse_type (int fd
, union aux_ext
*ax
, unsigned int aux_index
, int *bs
,
1368 int bigend
, char *sym_name
)
1370 /* Null entries in this map are treated specially */
1371 static struct type
**map_bt
[] =
1373 &mdebug_type_void
, /* btNil */
1374 &mdebug_type_adr_32
, /* btAdr */
1375 &mdebug_type_char
, /* btChar */
1376 &mdebug_type_unsigned_char
, /* btUChar */
1377 &mdebug_type_short
, /* btShort */
1378 &mdebug_type_unsigned_short
, /* btUShort */
1379 &mdebug_type_int_32
, /* btInt */
1380 &mdebug_type_unsigned_int_32
, /* btUInt */
1381 &mdebug_type_long_32
, /* btLong */
1382 &mdebug_type_unsigned_long_32
, /* btULong */
1383 &mdebug_type_float
, /* btFloat */
1384 &mdebug_type_double
, /* btDouble */
1391 &mdebug_type_complex
, /* btComplex */
1392 &mdebug_type_double_complex
, /* btDComplex */
1394 &mdebug_type_fixed_dec
, /* btFixedDec */
1395 &mdebug_type_float_dec
, /* btFloatDec */
1396 &mdebug_type_string
, /* btString */
1399 &mdebug_type_void
, /* btVoid */
1400 0, /* DEC C++: Pointer to member */
1401 0, /* DEC C++: Virtual function table */
1402 0, /* DEC C++: Class (Record) */
1403 &mdebug_type_long_64
, /* btLong64 */
1404 &mdebug_type_unsigned_long_64
, /* btULong64 */
1405 &mdebug_type_long_long_64
, /* btLongLong64 */
1406 &mdebug_type_unsigned_long_long_64
, /* btULongLong64 */
1407 &mdebug_type_adr_64
, /* btAdr64 */
1408 &mdebug_type_int_64
, /* btInt64 */
1409 &mdebug_type_unsigned_int_64
, /* btUInt64 */
1413 struct type
*tp
= 0;
1414 enum type_code type_code
= TYPE_CODE_UNDEF
;
1416 /* Handle undefined types, they have indexNil. */
1417 if (aux_index
== indexNil
)
1418 return mdebug_type_int
;
1420 /* Handle corrupt aux indices. */
1421 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1423 index_complaint (sym_name
);
1424 return mdebug_type_int
;
1428 /* Use aux as a type information record, map its basic type. */
1429 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1430 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1432 basic_type_complaint (t
->bt
, sym_name
);
1433 return mdebug_type_int
;
1437 tp
= *map_bt
[t
->bt
];
1442 /* Cannot use builtin types -- build our own */
1446 type_code
= TYPE_CODE_STRUCT
;
1449 type_code
= TYPE_CODE_UNION
;
1452 type_code
= TYPE_CODE_ENUM
;
1455 type_code
= TYPE_CODE_RANGE
;
1458 type_code
= TYPE_CODE_SET
;
1461 /* alpha cc -migrate uses this for typedefs. The true type will
1462 be obtained by crossreferencing below. */
1463 type_code
= TYPE_CODE_ERROR
;
1466 /* alpha cc uses this for typedefs. The true type will be
1467 obtained by crossreferencing below. */
1468 type_code
= TYPE_CODE_ERROR
;
1471 basic_type_complaint (t
->bt
, sym_name
);
1472 return mdebug_type_int
;
1476 /* Move on to next aux */
1481 int width
= AUX_GET_WIDTH (bigend
, ax
);
1482 /* Inhibit core dumps if TIR is corrupted. */
1483 if (bs
== (int *) NULL
)
1485 /* Alpha cc -migrate encodes char and unsigned char types
1486 as short and unsigned short types with a field width of 8.
1487 Enum types also have a field width which we ignore for now. */
1488 if (t
->bt
== btShort
&& width
== 8)
1489 tp
= mdebug_type_char
;
1490 else if (t
->bt
== btUShort
&& width
== 8)
1491 tp
= mdebug_type_unsigned_char
;
1492 else if (t
->bt
== btEnum
)
1495 complaint (&symfile_complaints
, _("can't handle TIR fBitfield for %s"),
1503 /* A btIndirect entry cross references to an aux entry containing
1505 if (t
->bt
== btIndirect
)
1512 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1514 if (rn
->rfd
== 0xfff)
1516 rf
= AUX_GET_ISYM (bigend
, ax
);
1524 complaint (&symfile_complaints
,
1525 _("unable to cross ref btIndirect for %s"), sym_name
);
1526 return mdebug_type_int
;
1528 xref_fh
= get_rfd (fd
, rf
);
1529 xref_fd
= xref_fh
- debug_info
->fdr
;
1530 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1531 rn
->index
, (int *) NULL
, xref_fh
->fBigendian
, sym_name
);
1534 /* All these types really point to some (common) MIPS type
1535 definition, and only the type-qualifiers fully identify
1536 them. We'll make the same effort at sharing. */
1537 if (t
->bt
== btStruct
||
1541 /* btSet (I think) implies that the name is a tag name, not a typedef
1542 name. This apparently is a MIPS extension for C sets. */
1547 /* Try to cross reference this type, build new type on failure. */
1548 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1549 if (tp
== (struct type
*) NULL
)
1550 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1552 /* DEC c89 produces cross references to qualified aggregate types,
1553 dereference them. */
1554 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1555 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1556 tp
= TYPE_TARGET_TYPE (tp
);
1558 /* Make sure that TYPE_CODE(tp) has an expected type code.
1559 Any type may be returned from cross_ref if file indirect entries
1561 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1562 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1563 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1565 unexpected_type_code_complaint (sym_name
);
1570 /* Usually, TYPE_CODE(tp) is already type_code. The main
1571 exception is if we guessed wrong re struct/union/enum.
1572 But for struct vs. union a wrong guess is harmless, so
1573 don't complain(). */
1574 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1575 && type_code
!= TYPE_CODE_ENUM
)
1576 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1577 && type_code
== TYPE_CODE_ENUM
))
1579 bad_tag_guess_complaint (sym_name
);
1582 if (TYPE_CODE (tp
) != type_code
)
1584 TYPE_CODE (tp
) = type_code
;
1587 /* Do not set the tag name if it is a compiler generated tag name
1588 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1589 if (name
[0] == '.' || name
[0] == '\0')
1590 TYPE_TAG_NAME (tp
) = NULL
;
1591 else if (TYPE_TAG_NAME (tp
) == NULL
1592 || strcmp (TYPE_TAG_NAME (tp
), name
) != 0)
1593 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1594 ¤t_objfile
->objfile_obstack
);
1598 /* All these types really point to some (common) MIPS type
1599 definition, and only the type-qualifiers fully identify
1600 them. We'll make the same effort at sharing.
1601 FIXME: We are not doing any guessing on range types. */
1602 if (t
->bt
== btRange
)
1606 /* Try to cross reference this type, build new type on failure. */
1607 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1608 if (tp
== (struct type
*) NULL
)
1609 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1611 /* Make sure that TYPE_CODE(tp) has an expected type code.
1612 Any type may be returned from cross_ref if file indirect entries
1614 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1616 unexpected_type_code_complaint (sym_name
);
1620 /* Usually, TYPE_CODE(tp) is already type_code. The main
1621 exception is if we guessed wrong re struct/union/enum. */
1622 if (TYPE_CODE (tp
) != type_code
)
1624 bad_tag_guess_complaint (sym_name
);
1625 TYPE_CODE (tp
) = type_code
;
1627 if (TYPE_NAME (tp
) == NULL
1628 || strcmp (TYPE_NAME (tp
), name
) != 0)
1629 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1630 ¤t_objfile
->objfile_obstack
);
1633 if (t
->bt
== btTypedef
)
1637 /* Try to cross reference this type, it should succeed. */
1638 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1639 if (tp
== (struct type
*) NULL
)
1641 complaint (&symfile_complaints
,
1642 _("unable to cross ref btTypedef for %s"), sym_name
);
1643 tp
= mdebug_type_int
;
1647 /* Deal with range types */
1648 if (t
->bt
== btRange
)
1650 TYPE_NFIELDS (tp
) = 2;
1651 TYPE_FIELDS (tp
) = ((struct field
*)
1652 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1653 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1654 ¤t_objfile
->objfile_obstack
);
1655 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1657 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1658 ¤t_objfile
->objfile_obstack
);
1659 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1663 /* Parse all the type qualifiers now. If there are more
1664 than 6 the game will continue in the next aux */
1668 #define PARSE_TQ(tq) \
1669 if (t->tq != tqNil) \
1670 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1682 /* mips cc 2.x and gcc never put out continued aux entries. */
1686 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1690 /* Complain for illegal continuations due to corrupt aux entries. */
1692 complaint (&symfile_complaints
, _("illegal TIR continued for %s"), sym_name
);
1697 /* Make up a complex type from a basic one. Type is passed by
1698 reference in TPP and side-effected as necessary. The type
1699 qualifier TQ says how to handle the aux symbols at AX for
1700 the symbol SX we are currently analyzing. BIGEND says whether
1701 aux symbols are big-endian or little-endian.
1702 Returns the number of aux symbols we parsed. */
1705 upgrade_type (int fd
, struct type
**tpp
, int tq
, union aux_ext
*ax
, int bigend
,
1711 /* Used in array processing */
1722 t
= lookup_pointer_type (*tpp
);
1727 t
= lookup_function_type (*tpp
);
1734 /* Determine and record the domain type (type of index) */
1735 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1741 rf
= AUX_GET_ISYM (bigend
, ax
);
1744 fh
= get_rfd (fd
, rf
);
1746 indx
= parse_type (fh
- debug_info
->fdr
,
1747 debug_info
->external_aux
+ fh
->iauxBase
,
1748 id
, (int *) NULL
, bigend
, sym_name
);
1750 /* The bounds type should be an integer type, but might be anything
1751 else due to corrupt aux entries. */
1752 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1754 complaint (&symfile_complaints
,
1755 _("illegal array index type for %s, assuming int"), sym_name
);
1756 indx
= mdebug_type_int
;
1759 /* Get the bounds, and create the array type. */
1761 lower
= AUX_GET_DNLOW (bigend
, ax
);
1763 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1765 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1767 range
= create_range_type ((struct type
*) NULL
, indx
,
1770 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1772 /* We used to fill in the supplied array element bitsize
1773 here if the TYPE_LENGTH of the target type was zero.
1774 This happens for a `pointer to an array of anonymous structs',
1775 but in this case the array element bitsize is also zero,
1776 so nothing is gained.
1777 And we used to check the TYPE_LENGTH of the target type against
1778 the supplied array element bitsize.
1779 gcc causes a mismatch for `pointer to array of object',
1780 since the sdb directives it uses do not have a way of
1781 specifying the bitsize, but it does no harm (the
1782 TYPE_LENGTH should be correct) and we should be able to
1783 ignore the erroneous bitsize from the auxiliary entry safely.
1784 dbx seems to ignore it too. */
1786 /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
1788 if (TYPE_LENGTH (*tpp
) == 0)
1790 TYPE_FLAGS (t
) |= TYPE_FLAG_TARGET_STUB
;
1797 /* Volatile -- currently ignored */
1801 /* Const -- currently ignored */
1805 complaint (&symfile_complaints
, _("unknown type qualifier 0x%x"), tq
);
1811 /* Parse a procedure descriptor record PR. Note that the procedure is
1812 parsed _after_ the local symbols, now we just insert the extra
1813 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1814 already been placed in the procedure's main block. Note also that
1815 images that have been partially stripped (ld -x) have been deprived
1816 of local symbols, and we have to cope with them here. FIRST_OFF is
1817 the offset of the first procedure for this FDR; we adjust the
1818 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1819 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1820 in question, or NULL to use top_stack->cur_block. */
1822 static void parse_procedure (PDR
*, struct symtab
*, struct partial_symtab
*);
1825 parse_procedure (PDR
*pr
, struct symtab
*search_symtab
,
1826 struct partial_symtab
*pst
)
1828 struct symbol
*s
, *i
;
1830 struct mdebug_extra_func_info
*e
;
1833 /* Simple rule to find files linked "-x" */
1834 if (cur_fdr
->rss
== -1)
1838 /* Static procedure at address pr->adr. Sigh. */
1839 /* FIXME-32x64. assuming pr->adr fits in long. */
1840 complaint (&symfile_complaints
,
1841 _("can't handle PDR for static proc at 0x%lx"),
1842 (unsigned long) pr
->adr
);
1850 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1851 ((char *) debug_info
->external_ext
1853 * debug_swap
->external_ext_size
)),
1855 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1863 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1864 ((char *) debug_info
->external_sym
1865 + ((cur_fdr
->isymBase
+ pr
->isym
)
1866 * debug_swap
->external_sym_size
)),
1868 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1871 if (search_symtab
!= NULL
)
1874 /* This loses both in the case mentioned (want a static, find a global),
1875 but also if we are looking up a non-mangled name which happens to
1876 match the name of a mangled function. */
1877 /* We have to save the cur_fdr across the call to lookup_symbol.
1878 If the pdr is for a static function and if a global function with
1879 the same name exists, lookup_symbol will eventually read in the symtab
1880 for the global function and clobber cur_fdr. */
1881 FDR
*save_cur_fdr
= cur_fdr
;
1882 s
= lookup_symbol (sh_name
, NULL
, VAR_DOMAIN
, 0, NULL
);
1883 cur_fdr
= save_cur_fdr
;
1887 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1893 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1894 VAR_DOMAIN
, LOC_BLOCK
);
1898 b
= SYMBOL_BLOCK_VALUE (s
);
1902 complaint (&symfile_complaints
, _("PDR for %s, but no symbol"), sh_name
);
1906 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1907 s
= new_symbol (sh_name
);
1908 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1909 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1910 /* Donno its type, hope int is ok */
1911 SYMBOL_TYPE (s
) = lookup_function_type (mdebug_type_int
);
1912 add_symbol (s
, top_stack
->cur_block
);
1913 /* Wont have symbols for this one */
1915 SYMBOL_BLOCK_VALUE (s
) = b
;
1916 BLOCK_FUNCTION (b
) = s
;
1917 BLOCK_START (b
) = pr
->adr
;
1918 /* BOUND used to be the end of procedure's text, but the
1919 argument is no longer passed in. */
1920 BLOCK_END (b
) = bound
;
1921 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1922 add_block (b
, top_stack
->cur_st
);
1926 i
= mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME
, b
, LABEL_DOMAIN
, LOC_CONST
);
1930 e
= (struct mdebug_extra_func_info
*) SYMBOL_VALUE (i
);
1932 e
->pdr
.isym
= (long) s
;
1934 /* GDB expects the absolute function start address for the
1935 procedure descriptor in e->pdr.adr.
1936 As the address in the procedure descriptor is usually relative,
1937 we would have to relocate e->pdr.adr with cur_fdr->adr and
1938 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
1939 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
1940 in shared libraries on some systems, and on other systems
1941 e->pdr.adr is sometimes offset by a bogus value.
1942 To work around these problems, we replace e->pdr.adr with
1943 the start address of the function. */
1944 e
->pdr
.adr
= BLOCK_START (b
);
1947 /* It would be reasonable that functions that have been compiled
1948 without debugging info have a btNil type for their return value,
1949 and functions that are void and are compiled with debugging info
1951 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
1952 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
1954 The glevel field in cur_fdr could be used to determine the presence
1955 of debugging info, but GCC doesn't always pass the -g switch settings
1956 to the assembler and GAS doesn't set the glevel field from the -g switch
1958 To work around these problems, the return value type of a TYPE_CODE_VOID
1959 function is adjusted accordingly if no debugging info was found in the
1960 compilation unit. */
1962 if (processing_gcc_compilation
== 0
1963 && found_ecoff_debugging_info
== 0
1964 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
1965 SYMBOL_TYPE (s
) = builtin_type (current_gdbarch
)->nodebug_text_symbol
;
1968 /* Parse the external symbol ES. Just call parse_symbol() after
1969 making sure we know where the aux are for it.
1970 BIGEND says whether aux entries are big-endian or little-endian.
1972 This routine clobbers top_stack->cur_block and ->cur_st. */
1974 static void parse_external (EXTR
*, int, struct section_offsets
*,
1978 parse_external (EXTR
*es
, int bigend
, struct section_offsets
*section_offsets
,
1979 struct objfile
*objfile
)
1983 if (es
->ifd
!= ifdNil
)
1986 cur_fdr
= debug_info
->fdr
+ cur_fd
;
1987 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
1991 cur_fdr
= debug_info
->fdr
;
1995 /* Reading .o files */
1996 if (SC_IS_UNDEF (es
->asym
.sc
) || es
->asym
.sc
== scNil
)
1999 switch (es
->asym
.st
)
2002 /* These are generated for static symbols in .o files,
2023 /* FIXME: Turn this into a complaint? */
2025 printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
2026 what
, debug_info
->ssext
+ es
->asym
.iss
,
2027 fdr_name (cur_fdr
));
2031 switch (es
->asym
.st
)
2035 /* There is no need to parse the external procedure symbols.
2036 If they are from objects compiled without -g, their index will
2037 be indexNil, and the symbol definition from the minimal symbol
2038 is preferrable (yielding a function returning int instead of int).
2039 If the index points to a local procedure symbol, the local
2040 symbol already provides the correct type.
2041 Note that the index of the external procedure symbol points
2042 to the local procedure symbol in the local symbol table, and
2043 _not_ to the auxiliary symbol info. */
2047 /* Global common symbols are resolved by the runtime loader,
2049 if (SC_IS_COMMON (es
->asym
.sc
))
2052 /* Note that the case of a symbol with indexNil must be handled
2053 anyways by parse_symbol(). */
2054 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
, objfile
);
2061 /* Parse the line number info for file descriptor FH into
2062 GDB's linetable LT. MIPS' encoding requires a little bit
2063 of magic to get things out. Note also that MIPS' line
2064 numbers can go back and forth, apparently we can live
2065 with that and do not need to reorder our linetables */
2067 static void parse_lines (FDR
*, PDR
*, struct linetable
*, int,
2068 struct partial_symtab
*, CORE_ADDR
);
2071 parse_lines (FDR
*fh
, PDR
*pr
, struct linetable
*lt
, int maxlines
,
2072 struct partial_symtab
*pst
, CORE_ADDR lowest_pdr_addr
)
2074 unsigned char *base
;
2076 int delta
, count
, lineno
= 0;
2078 if (fh
->cbLine
== 0)
2081 /* Scan by procedure descriptors */
2083 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2087 unsigned char *halt
;
2089 /* No code for this one */
2090 if (pr
->iline
== ilineNil
||
2091 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2094 /* Determine start and end address of compressed line bytes for
2096 base
= debug_info
->line
+ fh
->cbLineOffset
;
2097 if (j
!= (fh
->cpd
- 1))
2098 halt
= base
+ pr
[1].cbLineOffset
;
2100 halt
= base
+ fh
->cbLine
;
2101 base
+= pr
->cbLineOffset
;
2103 adr
= pst
->textlow
+ pr
->adr
- lowest_pdr_addr
;
2105 l
= adr
>> 2; /* in words */
2106 for (lineno
= pr
->lnLow
; base
< halt
;)
2108 count
= *base
& 0x0f;
2109 delta
= *base
++ >> 4;
2114 delta
= (base
[0] << 8) | base
[1];
2115 if (delta
>= 0x8000)
2119 lineno
+= delta
; /* first delta is 0 */
2121 /* Complain if the line table overflows. Could happen
2122 with corrupt binaries. */
2123 if (lt
->nitems
>= maxlines
)
2125 complaint (&symfile_complaints
,
2126 _("guessed size of linetable for %s incorrectly"),
2130 k
= add_line (lt
, lineno
, l
, k
);
2137 function_outside_compilation_unit_complaint (const char *arg1
)
2139 complaint (&symfile_complaints
,
2140 _("function `%s' appears to be defined outside of all compilation units"),
2144 /* Use the STORAGE_CLASS to compute which section the given symbol
2145 belongs to, and then records this new minimal symbol. */
2148 record_minimal_symbol (const char *name
, const CORE_ADDR address
,
2149 enum minimal_symbol_type ms_type
, int storage_class
,
2150 struct objfile
*objfile
)
2153 asection
*bfd_section
;
2155 switch (storage_class
)
2158 section
= SECT_OFF_TEXT (objfile
);
2159 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".text");
2162 section
= SECT_OFF_DATA (objfile
);
2163 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".data");
2166 section
= SECT_OFF_BSS (objfile
);
2167 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".bss");
2170 section
= get_section_index (objfile
, ".sdata");
2171 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".sdata");
2174 section
= get_section_index (objfile
, ".sbss");
2175 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".sbss");
2178 section
= get_section_index (objfile
, ".rdata");
2179 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".rdata");
2182 section
= get_section_index (objfile
, ".init");
2183 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".init");
2186 section
= get_section_index (objfile
, ".xdata");
2187 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".xdata");
2190 section
= get_section_index (objfile
, ".pdata");
2191 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".pdata");
2194 section
= get_section_index (objfile
, ".fini");
2195 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".fini");
2198 section
= get_section_index (objfile
, ".rconst");
2199 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".rconst");
2203 section
= get_section_index (objfile
, ".tlsdata");
2204 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".tlsdata");
2209 section
= get_section_index (objfile
, ".tlsbss");
2210 bfd_section
= bfd_get_section_by_name (cur_bfd
, ".tlsbss");
2214 /* This kind of symbol is not associated to a section. */
2219 prim_record_minimal_symbol_and_info (name
, address
, ms_type
, NULL
,
2220 section
, bfd_section
, objfile
);
2223 /* Master parsing procedure for first-pass reading of file symbols
2224 into a partial_symtab. */
2227 parse_partial_symbols (struct objfile
*objfile
)
2229 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2230 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2231 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2232 void (*const swap_ext_in
) (bfd
*, void *, EXTR
*) = debug_swap
->swap_ext_in
;
2233 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
2234 void (*const swap_rfd_in
) (bfd
*, void *, RFDT
*) = debug_swap
->swap_rfd_in
;
2236 HDRR
*hdr
= &debug_info
->symbolic_header
;
2237 /* Running pointers */
2245 struct partial_symtab
*pst
;
2246 int textlow_not_set
= 1;
2247 int past_first_source_file
= 0;
2249 /* List of current psymtab's include files */
2250 char **psymtab_include_list
;
2251 int includes_allocated
;
2254 struct pst_map
*fdr_to_pst
;
2255 /* Index within current psymtab dependency list */
2256 struct partial_symtab
**dependency_list
;
2257 int dependencies_used
, dependencies_allocated
;
2258 struct cleanup
*old_chain
;
2260 enum language prev_language
;
2261 asection
*text_sect
;
2262 int relocatable
= 0;
2264 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2265 the shared libraries are prelinked at a high memory address.
2266 We have to adjust the start address of the object file for this case,
2267 by setting it to the start address of the first procedure in the file.
2268 But we should do no adjustments if we are debugging a .o file, where
2269 the text section (and fh->adr) really starts at zero. */
2270 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2271 if (text_sect
!= NULL
2272 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2275 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->objfile_obstack
,
2276 sizeof (EXTR
) * hdr
->iextMax
);
2278 includes_allocated
= 30;
2280 psymtab_include_list
= (char **) alloca (includes_allocated
*
2282 next_symbol_text_func
= mdebug_next_symbol_text
;
2284 dependencies_allocated
= 30;
2285 dependencies_used
= 0;
2287 (struct partial_symtab
**) alloca (dependencies_allocated
*
2288 sizeof (struct partial_symtab
*));
2290 last_source_file
= NULL
;
2295 * Only parse the Local and External symbols, and the Relative FDR.
2296 * Fixup enough of the loader symtab to be able to use it.
2297 * Allocate space only for the file's portions we need to
2302 max_glevel
= MIN_GLEVEL
;
2304 /* Allocate the map FDR -> PST.
2305 Minor hack: -O3 images might claim some global data belongs
2306 to FDR -1. We`ll go along with that */
2307 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2308 old_chain
= make_cleanup (xfree
, fdr_to_pst
);
2311 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2312 fdr_to_pst
[-1].pst
= pst
;
2316 /* Allocate the global pending list. */
2318 ((struct mdebug_pending
**)
2319 obstack_alloc (&objfile
->objfile_obstack
,
2320 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2321 memset (pending_list
, 0,
2322 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2324 /* Pass 0 over external syms: swap them in. */
2325 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2326 make_cleanup (xfree
, ext_block
);
2328 ext_out
= (char *) debug_info
->external_ext
;
2329 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2331 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2332 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2334 /* Pass 1 over external syms: Presize and partition the list */
2336 ext_in_end
= ext_in
+ hdr
->iextMax
;
2337 for (; ext_in
< ext_in_end
; ext_in
++)
2339 /* See calls to complain below. */
2340 if (ext_in
->ifd
>= -1
2341 && ext_in
->ifd
< hdr
->ifdMax
2342 && ext_in
->asym
.iss
>= 0
2343 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2344 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2347 /* Pass 1.5 over files: partition out global symbol space */
2349 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2351 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2352 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2353 fdr_to_pst
[f_idx
].n_globals
= 0;
2358 For ECOFF in ELF, we skip the creation of the minimal symbols.
2359 The ECOFF symbols should be a subset of the Elf symbols, and the
2360 section information of the elf symbols will be more accurate.
2361 FIXME! What about Irix 5's native linker?
2363 By default, Elf sections which don't exist in ECOFF
2364 get put in ECOFF's absolute section by the gnu linker.
2365 Since absolute sections don't get relocated, we
2366 end up calculating an address different from that of
2367 the symbol's minimal symbol (created earlier from the
2370 To fix this, either :
2371 1) don't create the duplicate symbol
2372 (assumes ECOFF symtab is a subset of the ELF symtab;
2373 assumes no side-effects result from ignoring ECOFF symbol)
2374 2) create it, only if lookup for existing symbol in ELF's minimal
2377 assumes no side-effects result from ignoring ECOFF symbol)
2378 3) create it, but lookup ELF's minimal symbol and use it's section
2379 during relocation, then modify "uniqify" phase to merge and
2380 eliminate the duplicate symbol
2381 (highly inefficient)
2383 I've implemented #1 here...
2384 Skip the creation of the minimal symbols based on the ECOFF
2387 /* Pass 2 over external syms: fill in external symbols */
2389 ext_in_end
= ext_in
+ hdr
->iextMax
;
2390 for (; ext_in
< ext_in_end
; ext_in
++)
2392 enum minimal_symbol_type ms_type
= mst_text
;
2393 CORE_ADDR svalue
= ext_in
->asym
.value
;
2395 /* The Irix 5 native tools seem to sometimes generate bogus
2396 external symbols. */
2397 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2399 complaint (&symfile_complaints
,
2400 _("bad ifd for external symbol: %d (max %ld)"), ext_in
->ifd
,
2404 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2406 complaint (&symfile_complaints
,
2407 _("bad iss for external symbol: %ld (max %ld)"),
2408 ext_in
->asym
.iss
, hdr
->issExtMax
);
2412 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2413 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2416 if (SC_IS_UNDEF (ext_in
->asym
.sc
) || ext_in
->asym
.sc
== scNil
)
2420 /* Pass 3 over files, over local syms: fill in static symbols */
2421 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2423 /* Process ECOFF Symbol Types and Storage Classes */
2424 switch (ext_in
->asym
.st
)
2427 /* Beginnning of Procedure */
2428 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2431 /* Load time only static procs */
2432 ms_type
= mst_file_text
;
2433 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2436 /* External symbol */
2437 if (SC_IS_COMMON (ext_in
->asym
.sc
))
2439 /* The value of a common symbol is its size, not its address.
2443 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2446 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2448 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2451 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2453 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2456 svalue
+= ANOFFSET (objfile
->section_offsets
,
2457 get_section_index (objfile
, ".sbss"));
2465 /* On certain platforms, some extra label symbols can be
2466 generated by the linker. One possible usage for this kind
2467 of symbols is to represent the address of the begining of a
2468 given section. For instance, on Tru64 5.1, the address of
2469 the _ftext label is the start address of the .text section.
2471 The storage class of these symbols is usually directly
2472 related to the section to which the symbol refers. For
2473 instance, on Tru64 5.1, the storage class for the _fdata
2474 label is scData, refering to the .data section.
2476 It is actually possible that the section associated to the
2477 storage class of the label does not exist. On True64 5.1
2478 for instance, the libm.so shared library does not contain
2479 any .data section, although it contains a _fpdata label
2480 which storage class is scData... Since these symbols are
2481 usually useless for the debugger user anyway, we just
2482 discard these symbols.
2485 if (SC_IS_TEXT (ext_in
->asym
.sc
))
2487 if (objfile
->sect_index_text
== -1)
2490 ms_type
= mst_file_text
;
2491 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2493 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2495 if (objfile
->sect_index_data
== -1)
2498 ms_type
= mst_file_data
;
2499 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2501 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2503 if (objfile
->sect_index_bss
== -1)
2506 ms_type
= mst_file_bss
;
2507 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2509 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2511 const int sbss_sect_index
= get_section_index (objfile
, ".sbss");
2513 if (sbss_sect_index
== -1)
2516 ms_type
= mst_file_bss
;
2517 svalue
+= ANOFFSET (objfile
->section_offsets
, sbss_sect_index
);
2524 /* The alpha has the section start addresses in stLocal symbols
2525 whose name starts with a `.'. Skip those but complain for all
2526 other stLocal symbols.
2527 Irix6 puts the section start addresses in stNil symbols, skip
2533 ms_type
= mst_unknown
;
2534 unknown_ext_complaint (name
);
2536 if (!ECOFF_IN_ELF (cur_bfd
))
2537 record_minimal_symbol (name
, svalue
, ms_type
, ext_in
->asym
.sc
,
2541 /* Pass 3 over files, over local syms: fill in static symbols */
2542 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2544 struct partial_symtab
*save_pst
;
2548 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2552 fdr_to_pst
[f_idx
].pst
= NULL
;
2556 /* Determine the start address for this object file from the
2557 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2561 if (relocatable
|| textlow
!= 0)
2562 textlow
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2566 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
2569 objfile
->global_psymbols
.next
,
2570 objfile
->static_psymbols
.next
);
2571 pst
->read_symtab_private
= ((char *)
2572 obstack_alloc (&objfile
->objfile_obstack
,
2573 sizeof (struct symloc
)));
2574 memset (pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2577 FDR_IDX (pst
) = f_idx
;
2578 CUR_BFD (pst
) = cur_bfd
;
2579 DEBUG_SWAP (pst
) = debug_swap
;
2580 DEBUG_INFO (pst
) = debug_info
;
2581 PENDING_LIST (pst
) = pending_list
;
2583 /* The way to turn this into a symtab is to call... */
2584 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2586 /* Set up language for the pst.
2587 The language from the FDR is used if it is unambigious (e.g. cfront
2588 with native cc and g++ will set the language to C).
2589 Otherwise we have to deduce the language from the filename.
2590 Native ecoff has every header file in a separate FDR, so
2591 deduce_language_from_filename will return language_unknown for
2592 a header file, which is not what we want.
2593 But the FDRs for the header files are after the FDR for the source
2594 file, so we can assign the language of the source file to the
2595 following header files. Then we save the language in the private
2596 pst data so that we can reuse it when building symtabs. */
2597 prev_language
= psymtab_language
;
2601 case langCplusplusV2
:
2602 psymtab_language
= language_cplus
;
2605 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2608 if (psymtab_language
== language_unknown
)
2609 psymtab_language
= prev_language
;
2610 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2612 pst
->texthigh
= pst
->textlow
;
2614 /* For stabs-in-ecoff files, the second symbol must be @stab.
2615 This symbol is emitted by mips-tfile to signal that the
2616 current object file uses encapsulated stabs instead of mips
2617 ecoff for local symbols. (It is the second symbol because
2618 the first symbol is the stFile used to signal the start of a
2620 processing_gcc_compilation
= 0;
2623 (*swap_sym_in
) (cur_bfd
,
2624 ((char *) debug_info
->external_sym
2625 + (fh
->isymBase
+ 1) * external_sym_size
),
2627 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2629 processing_gcc_compilation
= 2;
2632 if (processing_gcc_compilation
!= 0)
2634 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2639 (*swap_sym_in
) (cur_bfd
,
2640 (((char *) debug_info
->external_sym
)
2641 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2643 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2644 if (!ECOFF_IS_STAB (&sh
))
2646 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2651 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2652 if (sh
.st
== stStaticProc
)
2654 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2655 record_minimal_symbol (namestring
, sh
.value
,
2656 mst_file_text
, sh
.sc
,
2659 procaddr
= sh
.value
;
2661 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2662 (debug_info
->external_aux
2665 (*swap_sym_in
) (cur_bfd
,
2666 ((char *) debug_info
->external_sym
2667 + ((fh
->isymBase
+ isym
- 1)
2668 * external_sym_size
)),
2672 CORE_ADDR high
= procaddr
+ sh
.value
;
2674 /* Kludge for Irix 5.2 zero fh->adr. */
2676 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2677 pst
->textlow
= procaddr
;
2678 if (high
> pst
->texthigh
)
2679 pst
->texthigh
= high
;
2682 else if (sh
.st
== stStatic
)
2697 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2698 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2699 record_minimal_symbol (namestring
, sh
.value
,
2700 mst_file_data
, sh
.sc
,
2705 /* FIXME! Shouldn't this use cases for bss,
2706 then have the default be abs? */
2707 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2708 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2709 record_minimal_symbol (namestring
, sh
.value
,
2710 mst_file_bss
, sh
.sc
,
2717 /* Handle stabs continuation */
2719 char *stabstring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2720 int len
= strlen (stabstring
);
2721 while (stabstring
[len
- 1] == '\\')
2724 char *stabstring1
= stabstring
;
2728 /* Ignore continuation char from 1st string */
2731 /* Read next stabstring */
2733 (*swap_sym_in
) (cur_bfd
,
2734 (((char *) debug_info
->external_sym
)
2735 + (fh
->isymBase
+ cur_sdx
)
2736 * external_sym_size
),
2738 stabstring2
= debug_info
->ss
+ fh
->issBase
+ sh2
.iss
;
2739 len2
= strlen (stabstring2
);
2741 /* Concatinate stabstring2 with stabstring1 */
2743 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
2744 stabstring
= xrealloc (stabstring
, len
+ len2
+ 1);
2747 stabstring
= xmalloc (len
+ len2
+ 1);
2748 strcpy (stabstring
, stabstring1
);
2750 strcpy (stabstring
+ len
, stabstring2
);
2758 * Standard, external, non-debugger, symbols
2761 case N_TEXT
| N_EXT
:
2762 case N_NBTEXT
| N_EXT
:
2763 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2766 case N_DATA
| N_EXT
:
2767 case N_NBDATA
| N_EXT
:
2768 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2773 case N_NBBSS
| N_EXT
:
2774 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
2775 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2782 /* Standard, local, non-debugger, symbols */
2786 /* We need to be able to deal with both N_FN or N_TEXT,
2787 because we have no way of knowing whether the sys-supplied ld
2788 or GNU ld was used to make the executable. Sequents throw
2789 in another wrinkle -- they renumbered N_FN. */
2797 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2800 case N_UNDF
| N_EXT
:
2801 continue; /* Just undefined, not COMMON */
2806 /* Lots of symbol types we can just ignore. */
2813 /* Keep going . . . */
2816 * Special symbol types for GNU
2819 case N_INDR
| N_EXT
:
2821 case N_SETA
| N_EXT
:
2823 case N_SETT
| N_EXT
:
2825 case N_SETD
| N_EXT
:
2827 case N_SETB
| N_EXT
:
2838 static int prev_so_symnum
= -10;
2839 static int first_so_symnum
;
2841 int prev_textlow_not_set
;
2843 valu
= sh
.value
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2845 prev_textlow_not_set
= textlow_not_set
;
2847 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2848 /* A zero value is probably an indication for the SunPRO 3.0
2849 compiler. end_psymtab explicitly tests for zero, so
2850 don't relocate it. */
2854 textlow_not_set
= 1;
2858 textlow_not_set
= 0;
2860 textlow_not_set
= 0;
2862 past_first_source_file
= 1;
2864 if (prev_so_symnum
!= symnum
- 1)
2865 { /* Here if prev stab wasn't N_SO */
2866 first_so_symnum
= symnum
;
2870 pst
= (struct partial_symtab
*) 0;
2872 dependencies_used
= 0;
2876 prev_so_symnum
= symnum
;
2878 /* End the current partial symtab and start a new one */
2880 /* SET_NAMESTRING ();*/
2881 namestring
= stabstring
;
2883 /* Null name means end of .o file. Don't start a new one. */
2884 if (*namestring
== '\000')
2887 /* Some compilers (including gcc) emit a pair of initial N_SOs.
2888 The first one is a directory name; the second the file name.
2889 If pst exists, is empty, and has a filename ending in '/',
2890 we assume the previous N_SO was a directory name. */
2892 p
= strrchr (namestring
, '/');
2893 if (p
&& *(p
+ 1) == '\000')
2894 continue; /* Simply ignore directory name SOs */
2896 /* Some other compilers (C++ ones in particular) emit useless
2897 SOs for non-existant .c files. We ignore all subsequent SOs that
2898 immediately follow the first. */
2910 enum language tmp_language
;
2911 /* Mark down an include file in the current psymtab */
2913 /* SET_NAMESTRING ();*/
2914 namestring
= stabstring
;
2916 tmp_language
= deduce_language_from_filename (namestring
);
2918 /* Only change the psymtab's language if we've learned
2919 something useful (eg. tmp_language is not language_unknown).
2920 In addition, to match what start_subfile does, never change
2922 if (tmp_language
!= language_unknown
2923 && (tmp_language
!= language_c
2924 || psymtab_language
!= language_cplus
))
2925 psymtab_language
= tmp_language
;
2927 /* In C++, one may expect the same filename to come round many
2928 times, when code is coming alternately from the main file
2929 and from inline functions in other files. So I check to see
2930 if this is a file we've seen before -- either the main
2931 source file, or a previously included file.
2933 This seems to be a lot of time to be spending on N_SOL, but
2934 things like "break c-exp.y:435" need to work (I
2935 suppose the psymtab_include_list could be hashed or put
2936 in a binary tree, if profiling shows this is a major hog). */
2937 if (pst
&& strcmp (namestring
, pst
->filename
) == 0)
2941 for (i
= 0; i
< includes_used
; i
++)
2942 if (strcmp (namestring
,
2943 psymtab_include_list
[i
]) == 0)
2952 psymtab_include_list
[includes_used
++] = namestring
;
2953 if (includes_used
>= includes_allocated
)
2955 char **orig
= psymtab_include_list
;
2957 psymtab_include_list
= (char **)
2958 alloca ((includes_allocated
*= 2) *
2960 memcpy (psymtab_include_list
, orig
,
2961 includes_used
* sizeof (char *));
2965 case N_LSYM
: /* Typedef or automatic variable. */
2966 case N_STSYM
: /* Data seg var -- static */
2967 case N_LCSYM
: /* BSS " */
2968 case N_ROSYM
: /* Read-only data seg var -- static. */
2969 case N_NBSTS
: /* Gould nobase. */
2970 case N_NBLCS
: /* symbols. */
2972 case N_GSYM
: /* Global (extern) variable; can be
2973 data or bss (sigh FIXME). */
2975 /* Following may probably be ignored; I'll leave them here
2976 for now (until I do Pascal and Modula 2 extensions). */
2978 case N_PC
: /* I may or may not need this; I
2980 case N_M2C
: /* I suspect that I can ignore this here. */
2981 case N_SCOPE
: /* Same. */
2983 /* SET_NAMESTRING ();*/
2984 namestring
= stabstring
;
2985 p
= (char *) strchr (namestring
, ':');
2987 continue; /* Not a debugging symbol. */
2991 /* Main processing section for debugging symbols which
2992 the initial read through the symbol tables needs to worry
2993 about. If we reach this point, the symbol which we are
2994 considering is definitely one we are interested in.
2995 p must also contain the (valid) index into the namestring
2996 which indicates the debugging type symbol. */
3001 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3003 if (gdbarch_static_transform_name_p (current_gdbarch
))
3004 namestring
= gdbarch_static_transform_name
3005 (current_gdbarch
, namestring
);
3007 add_psymbol_to_list (namestring
, p
- namestring
,
3008 VAR_DOMAIN
, LOC_STATIC
,
3009 &objfile
->static_psymbols
,
3011 psymtab_language
, objfile
);
3014 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3015 /* The addresses in these entries are reported to be
3016 wrong. See the code that reads 'G's for symtabs. */
3017 add_psymbol_to_list (namestring
, p
- namestring
,
3018 VAR_DOMAIN
, LOC_STATIC
,
3019 &objfile
->global_psymbols
,
3021 psymtab_language
, objfile
);
3025 /* When a 'T' entry is defining an anonymous enum, it
3026 may have a name which is the empty string, or a
3027 single space. Since they're not really defining a
3028 symbol, those shouldn't go in the partial symbol
3029 table. We do pick up the elements of such enums at
3030 'check_enum:', below. */
3031 if (p
>= namestring
+ 2
3032 || (p
== namestring
+ 1
3033 && namestring
[0] != ' '))
3035 add_psymbol_to_list (namestring
, p
- namestring
,
3036 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3037 &objfile
->static_psymbols
,
3039 psymtab_language
, objfile
);
3042 /* Also a typedef with the same name. */
3043 add_psymbol_to_list (namestring
, p
- namestring
,
3044 VAR_DOMAIN
, LOC_TYPEDEF
,
3045 &objfile
->static_psymbols
,
3047 psymtab_language
, objfile
);
3053 if (p
!= namestring
) /* a name is there, not just :T... */
3055 add_psymbol_to_list (namestring
, p
- namestring
,
3056 VAR_DOMAIN
, LOC_TYPEDEF
,
3057 &objfile
->static_psymbols
,
3059 psymtab_language
, objfile
);
3062 /* If this is an enumerated type, we need to
3063 add all the enum constants to the partial symbol
3064 table. This does not cover enums without names, e.g.
3065 "enum {a, b} c;" in C, but fortunately those are
3066 rare. There is no way for GDB to find those from the
3067 enum type without spending too much time on it. Thus
3068 to solve this problem, the compiler needs to put out the
3069 enum in a nameless type. GCC2 does this. */
3071 /* We are looking for something of the form
3072 <name> ":" ("t" | "T") [<number> "="] "e"
3073 {<constant> ":" <value> ","} ";". */
3075 /* Skip over the colon and the 't' or 'T'. */
3077 /* This type may be given a number. Also, numbers can come
3078 in pairs like (0,26). Skip over it. */
3079 while ((*p
>= '0' && *p
<= '9')
3080 || *p
== '(' || *p
== ',' || *p
== ')'
3086 /* The aix4 compiler emits extra crud before the members. */
3089 /* Skip over the type (?). */
3093 /* Skip over the colon. */
3097 /* We have found an enumerated type. */
3098 /* According to comments in read_enum_type
3099 a comma could end it instead of a semicolon.
3100 I don't know where that happens.
3102 while (*p
&& *p
!= ';' && *p
!= ',')
3106 /* Check for and handle cretinous dbx symbol name
3108 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
3109 p
= next_symbol_text (objfile
);
3111 /* Point to the character after the name
3112 of the enum constant. */
3113 for (q
= p
; *q
&& *q
!= ':'; q
++)
3115 /* Note that the value doesn't matter for
3116 enum constants in psymtabs, just in symtabs. */
3117 add_psymbol_to_list (p
, q
- p
,
3118 VAR_DOMAIN
, LOC_CONST
,
3119 &objfile
->static_psymbols
, 0,
3120 0, psymtab_language
, objfile
);
3121 /* Point past the name. */
3123 /* Skip over the value. */
3124 while (*p
&& *p
!= ',')
3126 /* Advance past the comma. */
3133 /* Constant, e.g. from "const" in Pascal. */
3134 add_psymbol_to_list (namestring
, p
- namestring
,
3135 VAR_DOMAIN
, LOC_CONST
,
3136 &objfile
->static_psymbols
, sh
.value
,
3137 0, psymtab_language
, objfile
);
3143 int name_len
= p
- namestring
;
3144 char *name
= xmalloc (name_len
+ 1);
3145 memcpy (name
, namestring
, name_len
);
3146 name
[name_len
] = '\0';
3147 function_outside_compilation_unit_complaint (name
);
3150 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3151 add_psymbol_to_list (namestring
, p
- namestring
,
3152 VAR_DOMAIN
, LOC_BLOCK
,
3153 &objfile
->static_psymbols
,
3155 psymtab_language
, objfile
);
3158 /* Global functions were ignored here, but now they
3159 are put into the global psymtab like one would expect.
3160 They're also in the minimal symbol table. */
3164 int name_len
= p
- namestring
;
3165 char *name
= xmalloc (name_len
+ 1);
3166 memcpy (name
, namestring
, name_len
);
3167 name
[name_len
] = '\0';
3168 function_outside_compilation_unit_complaint (name
);
3171 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3172 add_psymbol_to_list (namestring
, p
- namestring
,
3173 VAR_DOMAIN
, LOC_BLOCK
,
3174 &objfile
->global_psymbols
,
3176 psymtab_language
, objfile
);
3179 /* Two things show up here (hopefully); static symbols of
3180 local scope (static used inside braces) or extensions
3181 of structure symbols. We can ignore both. */
3195 case '#': /* for symbol identification (used in live ranges) */
3199 /* It is a C++ nested symbol. We don't need to record it
3200 (I don't think); if we try to look up foo::bar::baz,
3201 then symbols for the symtab containing foo should get
3202 read in, I think. */
3203 /* Someone says sun cc puts out symbols like
3204 /foo/baz/maclib::/usr/local/bin/maclib,
3205 which would get here with a symbol type of ':'. */
3209 /* Unexpected symbol descriptor. The second and subsequent stabs
3210 of a continued stab can show up here. The question is
3211 whether they ever can mimic a normal stab--it would be
3212 nice if not, since we certainly don't want to spend the
3213 time searching to the end of every string looking for
3216 complaint (&symfile_complaints
,
3217 _("unknown symbol descriptor `%c'"), p
[1]);
3219 /* Ignore it; perhaps it is an extension that we don't
3228 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
3229 /* Solaris 2 end of module, finish current partial
3230 symbol table. END_PSYMTAB will set
3231 pst->texthigh to the proper value, which is
3232 necessary if a module compiled without
3233 debugging info follows this module. */
3236 pst
= (struct partial_symtab
*) 0;
3238 dependencies_used
= 0;
3244 if (sh
.value
> save_pst
->texthigh
)
3245 save_pst
->texthigh
= sh
.value
;
3250 case N_SSYM
: /* Claim: Structure or union element.
3251 Hopefully, I can ignore this. */
3252 case N_ENTRY
: /* Alternate entry point; can ignore. */
3253 case N_MAIN
: /* Can definitely ignore this. */
3254 case N_CATCH
: /* These are GNU C++ extensions */
3255 case N_EHDECL
: /* that can safely be ignored here. */
3265 case N_NSYMS
: /* Ultrix 4.0: symbol count */
3266 case N_DEFD
: /* GNU Modula-2 */
3267 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
3269 case N_OBJ
: /* useless types from Solaris */
3271 /* These symbols aren't interesting; don't worry about them */
3276 /* If we haven't found it yet, ignore it. It's probably some
3277 new type we don't know about yet. */
3278 complaint (&symfile_complaints
, _("unknown symbol type %s"),
3279 hex_string (type_code
)); /*CUR_SYMBOL_TYPE*/
3283 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
3286 /* end - Handle continuation */
3291 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
3294 enum address_class
class;
3296 (*swap_sym_in
) (cur_bfd
,
3297 ((char *) debug_info
->external_sym
3298 + ((fh
->isymBase
+ cur_sdx
)
3299 * external_sym_size
)),
3302 if (ECOFF_IS_STAB (&sh
))
3308 /* Non absolute static symbols go into the minimal table. */
3309 if (SC_IS_UNDEF (sh
.sc
) || sh
.sc
== scNil
3310 || (sh
.index
== indexNil
3311 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
3313 /* FIXME, premature? */
3318 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3324 /* The value of a stEnd symbol is the displacement from the
3325 corresponding start symbol value, do not relocate it. */
3327 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3334 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3338 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3349 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3350 mst_file_text
, NULL
,
3351 SECT_OFF_TEXT (objfile
), NULL
,
3357 /* Ignore all parameter symbol records. */
3358 if (sh
.index
>= hdr
->iauxMax
)
3360 /* Should not happen, but does when cross-compiling
3361 with the MIPS compiler. FIXME -- pull later. */
3362 index_complaint (name
);
3363 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
3366 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
3367 (debug_info
->external_aux
3371 if (new_sdx
<= cur_sdx
)
3373 /* This should not happen either... FIXME. */
3374 complaint (&symfile_complaints
,
3375 _("bad proc end in aux found from symbol %s"),
3377 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3380 /* For stProc symbol records, we need to check the
3381 storage class as well, as only (stProc, scText)
3382 entries represent "real" procedures - See the
3383 Compaq document titled "Object File / Symbol Table
3384 Format Specification" for more information. If the
3385 storage class is not scText, we discard the whole
3386 block of symbol records for this stProc. */
3387 if (sh
.st
== stProc
&& sh
.sc
!= scText
)
3390 /* Usually there is a local and a global stProc symbol
3391 for a function. This means that the function name
3392 has already been entered into the mimimal symbol table
3393 while processing the global symbols in pass 2 above.
3394 One notable exception is the PROGRAM name from
3395 f77 compiled executables, it is only put out as
3396 local stProc symbol, and a global MAIN__ stProc symbol
3397 points to it. It doesn't matter though, as gdb is
3398 still able to find the PROGRAM name via the partial
3399 symbol table, and the MAIN__ symbol via the minimal
3401 if (sh
.st
== stProc
)
3402 add_psymbol_to_list (name
, strlen (name
),
3403 VAR_DOMAIN
, LOC_BLOCK
,
3404 &objfile
->global_psymbols
,
3405 0, sh
.value
, psymtab_language
, objfile
);
3407 add_psymbol_to_list (name
, strlen (name
),
3408 VAR_DOMAIN
, LOC_BLOCK
,
3409 &objfile
->static_psymbols
,
3410 0, sh
.value
, psymtab_language
, objfile
);
3412 procaddr
= sh
.value
;
3415 (*swap_sym_in
) (cur_bfd
,
3416 ((char *) debug_info
->external_sym
3417 + ((fh
->isymBase
+ cur_sdx
- 1)
3418 * external_sym_size
)),
3423 /* Kludge for Irix 5.2 zero fh->adr. */
3425 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
3426 pst
->textlow
= procaddr
;
3428 high
= procaddr
+ sh
.value
;
3429 if (high
> pst
->texthigh
)
3430 pst
->texthigh
= high
;
3433 case stStatic
: /* Variable */
3434 if (SC_IS_DATA (sh
.sc
))
3435 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3436 mst_file_data
, NULL
,
3437 SECT_OFF_DATA (objfile
),
3441 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3443 SECT_OFF_BSS (objfile
),
3449 case stIndirect
: /* Irix5 forward declaration */
3450 /* Skip forward declarations from Irix5 cc */
3453 case stTypedef
: /* Typedef */
3454 /* Skip typedefs for forward declarations and opaque
3455 structs from alpha and mips cc. */
3456 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
3458 class = LOC_TYPEDEF
;
3461 case stConstant
: /* Constant decl */
3468 case stBlock
: /* { }, str, un, enum */
3469 /* Do not create a partial symbol for cc unnamed aggregates
3470 and gcc empty aggregates. */
3471 if ((sh
.sc
== scInfo
3472 || SC_IS_COMMON (sh
.sc
))
3474 && sh
.index
!= cur_sdx
+ 2)
3476 add_psymbol_to_list (name
, strlen (name
),
3477 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3478 &objfile
->static_psymbols
,
3480 psymtab_language
, objfile
);
3482 handle_psymbol_enumerators (objfile
, fh
, sh
.st
, sh
.value
);
3484 /* Skip over the block */
3486 if (new_sdx
<= cur_sdx
)
3488 /* This happens with the Ultrix kernel. */
3489 complaint (&symfile_complaints
,
3490 _("bad aux index at block symbol %s"), name
);
3491 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3496 case stFile
: /* File headers */
3497 case stLabel
: /* Labels */
3498 case stEnd
: /* Ends of files */
3501 case stLocal
: /* Local variables */
3502 /* Normally these are skipped because we skip over
3503 all blocks we see. However, these can occur
3504 as visible symbols in a .h file that contains code. */
3508 /* Both complaints are valid: one gives symbol name,
3509 the other the offending symbol type. */
3510 complaint (&symfile_complaints
, _("unknown local symbol %s"),
3512 complaint (&symfile_complaints
, _("with type %d"), sh
.st
);
3516 /* Use this gdb symbol */
3517 add_psymbol_to_list (name
, strlen (name
),
3519 &objfile
->static_psymbols
,
3520 0, sh
.value
, psymtab_language
, objfile
);
3522 cur_sdx
++; /* Go to next file symbol */
3525 /* Now do enter the external symbols. */
3526 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
3527 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
3528 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
3529 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
3530 for (; --cur_sdx
>= 0; ext_ptr
++)
3532 enum address_class
class;
3537 if (ext_ptr
->ifd
!= f_idx
)
3538 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
3539 psh
= &ext_ptr
->asym
;
3541 /* Do not add undefined symbols to the partial symbol table. */
3542 if (SC_IS_UNDEF (psh
->sc
) || psh
->sc
== scNil
)
3545 svalue
= psh
->value
;
3550 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3557 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3561 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3568 /* These are generated for static symbols in .o files,
3573 /* External procedure symbols have been entered
3574 into the minimal symbol table in pass 2 above.
3575 Ignore them, as parse_external will ignore them too. */
3581 unknown_ext_complaint (debug_info
->ssext
+ psh
->iss
);
3582 /* Fall through, pretend it's global. */
3584 /* Global common symbols are resolved by the runtime loader,
3586 if (SC_IS_COMMON (psh
->sc
))
3592 name
= debug_info
->ssext
+ psh
->iss
;
3593 add_psymbol_to_list (name
, strlen (name
),
3595 &objfile
->global_psymbols
,
3597 psymtab_language
, objfile
);
3601 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3602 empty and put on the free list. */
3603 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
3604 psymtab_include_list
, includes_used
,
3605 -1, save_pst
->texthigh
,
3606 dependency_list
, dependencies_used
, textlow_not_set
);
3608 dependencies_used
= 0;
3610 /* The objfile has its functions reordered if this partial symbol
3611 table overlaps any other partial symbol table.
3612 We cannot assume a reordered objfile if a partial symbol table
3613 is contained within another partial symbol table, as partial symbol
3614 tables for include files with executable code are contained
3615 within the partial symbol table for the including source file,
3616 and we do not want to flag the objfile reordered for these cases.
3618 This strategy works well for Irix-5.2 shared libraries, but we
3619 might have to use a more elaborate (and slower) algorithm for
3621 save_pst
= fdr_to_pst
[f_idx
].pst
;
3622 if (save_pst
!= NULL
3623 && save_pst
->textlow
!= 0
3624 && !(objfile
->flags
& OBJF_REORDERED
))
3626 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
3629 && save_pst
->textlow
>= pst
->textlow
3630 && save_pst
->textlow
< pst
->texthigh
3631 && save_pst
->texthigh
> pst
->texthigh
)
3633 objfile
->flags
|= OBJF_REORDERED
;
3640 /* Now scan the FDRs for dependencies */
3641 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3643 fh
= f_idx
+ debug_info
->fdr
;
3644 pst
= fdr_to_pst
[f_idx
].pst
;
3646 if (pst
== (struct partial_symtab
*) NULL
)
3649 /* This should catch stabs-in-ecoff. */
3653 /* Skip the first file indirect entry as it is a self dependency
3654 for source files or a reverse .h -> .c dependency for header files. */
3655 pst
->number_of_dependencies
= 0;
3657 ((struct partial_symtab
**)
3658 obstack_alloc (&objfile
->objfile_obstack
,
3660 * sizeof (struct partial_symtab
*))));
3661 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3665 (*swap_rfd_in
) (cur_bfd
,
3666 ((char *) debug_info
->external_rfd
3667 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3669 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3671 complaint (&symfile_complaints
, _("bad file number %ld"), rh
);
3675 /* Skip self dependencies of header files. */
3679 /* Do not add to dependeny list if psymtab was empty. */
3680 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*) NULL
)
3682 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
3686 /* Remove the dummy psymtab created for -O3 images above, if it is
3687 still empty, to enable the detection of stripped executables. */
3688 if (objfile
->psymtabs
->next
== NULL
3689 && objfile
->psymtabs
->number_of_dependencies
== 0
3690 && objfile
->psymtabs
->n_global_syms
== 0
3691 && objfile
->psymtabs
->n_static_syms
== 0)
3692 objfile
->psymtabs
= NULL
;
3693 do_cleanups (old_chain
);
3696 /* If the current psymbol has an enumerated type, we need to add
3697 all the the enum constants to the partial symbol table. */
3700 handle_psymbol_enumerators (struct objfile
*objfile
, FDR
*fh
, int stype
,
3703 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3704 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
3705 char *ext_sym
= ((char *) debug_info
->external_sym
3706 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3716 /* It is an enumerated type if the next symbol entry is a stMember
3717 and its auxiliary index is indexNil or its auxiliary entry
3718 is a plain btNil or btVoid.
3719 Alpha cc -migrate enums are recognized by a zero index and
3720 a zero symbol value.
3721 DU 4.0 cc enums are recognized by a member type of btEnum without
3722 qualifiers and a zero symbol value. */
3723 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3724 if (sh
.st
!= stMember
)
3727 if (sh
.index
== indexNil
3728 || (sh
.index
== 0 && svalue
== 0))
3730 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3731 &(debug_info
->external_aux
3732 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3734 if ((tir
.bt
!= btNil
3736 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3737 || tir
.tq0
!= tqNil
)
3749 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3750 if (sh
.st
!= stMember
)
3752 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3754 /* Note that the value doesn't matter for enum constants
3755 in psymtabs, just in symtabs. */
3756 add_psymbol_to_list (name
, strlen (name
),
3757 VAR_DOMAIN
, LOC_CONST
,
3758 &objfile
->static_psymbols
, 0,
3759 (CORE_ADDR
) 0, psymtab_language
, objfile
);
3760 ext_sym
+= external_sym_size
;
3764 /* Get the next symbol. OBJFILE is unused. */
3767 mdebug_next_symbol_text (struct objfile
*objfile
)
3772 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3773 ((char *) debug_info
->external_sym
3774 + ((cur_fdr
->isymBase
+ cur_sdx
)
3775 * debug_swap
->external_sym_size
)),
3777 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3780 /* Ancillary function to psymtab_to_symtab(). Does all the work
3781 for turning the partial symtab PST into a symtab, recurring
3782 first on all dependent psymtabs. The argument FILENAME is
3783 only passed so we can see in debug stack traces what file
3786 This function has a split personality, based on whether the
3787 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3788 The flow of control and even the memory allocation differs. FIXME. */
3791 psymtab_to_symtab_1 (struct partial_symtab
*pst
, char *filename
)
3793 bfd_size_type external_sym_size
;
3794 bfd_size_type external_pdr_size
;
3795 void (*swap_sym_in
) (bfd
*, void *, SYMR
*);
3796 void (*swap_pdr_in
) (bfd
*, void *, PDR
*);
3798 struct symtab
*st
= NULL
;
3800 struct linetable
*lines
;
3801 CORE_ADDR lowest_pdr_addr
= 0;
3802 int last_symtab_ended
= 0;
3808 /* Read in all partial symbtabs on which this one is dependent.
3809 NOTE that we do have circular dependencies, sigh. We solved
3810 that by setting pst->readin before this point. */
3812 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3813 if (!pst
->dependencies
[i
]->readin
)
3815 /* Inform about additional files to be read in. */
3818 fputs_filtered (" ", gdb_stdout
);
3820 fputs_filtered ("and ", gdb_stdout
);
3822 printf_filtered ("%s...",
3823 pst
->dependencies
[i
]->filename
);
3824 wrap_here (""); /* Flush output */
3825 gdb_flush (gdb_stdout
);
3827 /* We only pass the filename for debug purposes */
3828 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3829 pst
->dependencies
[i
]->filename
);
3832 /* Do nothing if this is a dummy psymtab. */
3834 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3835 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3838 /* Now read the symbols for this symtab */
3840 cur_bfd
= CUR_BFD (pst
);
3841 debug_swap
= DEBUG_SWAP (pst
);
3842 debug_info
= DEBUG_INFO (pst
);
3843 pending_list
= PENDING_LIST (pst
);
3844 external_sym_size
= debug_swap
->external_sym_size
;
3845 external_pdr_size
= debug_swap
->external_pdr_size
;
3846 swap_sym_in
= debug_swap
->swap_sym_in
;
3847 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3848 current_objfile
= pst
->objfile
;
3849 cur_fd
= FDR_IDX (pst
);
3850 fh
= ((cur_fd
== -1)
3852 : debug_info
->fdr
+ cur_fd
);
3855 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3856 processing_gcc_compilation
= 0;
3857 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3861 (*swap_sym_in
) (cur_bfd
,
3862 ((char *) debug_info
->external_sym
3863 + (fh
->isymBase
+ 1) * external_sym_size
),
3865 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3868 /* We indicate that this is a GCC compilation so that certain
3869 features will be enabled in stabsread/dbxread. */
3870 processing_gcc_compilation
= 2;
3874 if (processing_gcc_compilation
!= 0)
3877 /* This symbol table contains stabs-in-ecoff entries. */
3879 /* Parse local symbols first */
3881 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3883 current_objfile
= NULL
;
3886 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3892 (*swap_sym_in
) (cur_bfd
,
3893 (((char *) debug_info
->external_sym
)
3894 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3896 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3898 /* XXX This is a hack. It will go away! */
3899 if (ECOFF_IS_STAB (&sh
) || (name
[0] == '#'))
3901 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3903 /* We should never get non N_STAB symbols here, but they
3904 should be harmless, so keep process_one_symbol from
3905 complaining about them. */
3906 if (type_code
& N_STAB
)
3908 /* If we found a trailing N_SO with no name, process
3909 it here instead of in process_one_symbol, so we
3910 can keep a handle to its symtab. The symtab
3911 would otherwise be ended twice, once in
3912 process_one_symbol, and once after this loop. */
3913 if (type_code
== N_SO
3915 && previous_stab_code
!= (unsigned char) N_SO
3918 valu
+= ANOFFSET (pst
->section_offsets
,
3919 SECT_OFF_TEXT (pst
->objfile
));
3920 previous_stab_code
= N_SO
;
3921 st
= end_symtab (valu
, pst
->objfile
,
3922 SECT_OFF_TEXT (pst
->objfile
));
3924 last_symtab_ended
= 1;
3928 last_symtab_ended
= 0;
3929 process_one_symbol (type_code
, 0, valu
, name
,
3930 pst
->section_offsets
, pst
->objfile
);
3933 /* Similarly a hack. */
3934 else if (name
[0] == '#')
3936 process_one_symbol (N_SLINE
, 0, valu
, name
,
3937 pst
->section_offsets
, pst
->objfile
);
3939 if (type_code
== N_FUN
)
3941 /* Make up special symbol to contain
3942 procedure specific info */
3943 struct mdebug_extra_func_info
*e
=
3944 ((struct mdebug_extra_func_info
*)
3945 obstack_alloc (¤t_objfile
->objfile_obstack
,
3946 sizeof (struct mdebug_extra_func_info
)));
3947 struct symbol
*s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
3949 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
3950 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
3951 SYMBOL_CLASS (s
) = LOC_CONST
;
3952 SYMBOL_TYPE (s
) = mdebug_type_void
;
3953 SYMBOL_VALUE (s
) = (long) e
;
3954 e
->pdr
.framereg
= -1;
3955 add_symbol_to_list (s
, &local_symbols
);
3958 else if (sh
.st
== stLabel
)
3960 if (sh
.index
== indexNil
)
3962 /* This is what the gcc2_compiled and __gnu_compiled_*
3963 show up as. So don't complain. */
3968 /* Handle encoded stab line number. */
3969 valu
+= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (pst
->objfile
));
3970 record_line (current_subfile
, sh
.index
, valu
);
3973 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3974 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3975 /* These are generated by gcc-2.x, do not complain */
3978 complaint (&symfile_complaints
, _("unknown stabs symbol %s"), name
);
3981 if (! last_symtab_ended
)
3983 st
= end_symtab (pst
->texthigh
, pst
->objfile
, SECT_OFF_TEXT (pst
->objfile
));
3987 /* There used to be a call to sort_blocks here, but this should not
3988 be necessary for stabs symtabs. And as sort_blocks modifies the
3989 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3990 it did the wrong thing if the first procedure in a file was
3991 generated via asm statements. */
3993 /* Fill in procedure info next. */
3997 struct cleanup
*old_chain
;
4003 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4004 old_chain
= make_cleanup (xfree
, pr_block
);
4006 pdr_ptr
= ((char *) debug_info
->external_pdr
4007 + fh
->ipdFirst
* external_pdr_size
);
4008 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4012 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4014 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4016 /* Determine lowest PDR address, the PDRs are not always
4018 if (pdr_in
== pr_block
)
4019 lowest_pdr_addr
= pdr_in
->adr
;
4020 else if (pdr_in
->adr
< lowest_pdr_addr
)
4021 lowest_pdr_addr
= pdr_in
->adr
;
4025 pdr_in_end
= pdr_in
+ fh
->cpd
;
4026 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4027 parse_procedure (pdr_in
, st
, pst
);
4029 do_cleanups (old_chain
);
4034 /* This symbol table contains ordinary ecoff entries. */
4043 st
= new_symtab ("unknown", 0, pst
->objfile
);
4047 maxlines
= 2 * fh
->cline
;
4048 st
= new_symtab (pst
->filename
, maxlines
, pst
->objfile
);
4050 /* The proper language was already determined when building
4051 the psymtab, use it. */
4052 st
->language
= PST_PRIVATE (pst
)->pst_language
;
4055 psymtab_language
= st
->language
;
4057 lines
= LINETABLE (st
);
4059 /* Get a new lexical context */
4061 push_parse_stack ();
4062 top_stack
->cur_st
= st
;
4063 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
4065 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
4066 BLOCK_END (top_stack
->cur_block
) = 0;
4067 top_stack
->blocktype
= stFile
;
4068 top_stack
->cur_type
= 0;
4069 top_stack
->procadr
= 0;
4070 top_stack
->numargs
= 0;
4071 found_ecoff_debugging_info
= 0;
4078 /* Parse local symbols first */
4079 sym_ptr
= ((char *) debug_info
->external_sym
4080 + fh
->isymBase
* external_sym_size
);
4081 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
4082 while (sym_ptr
< sym_end
)
4087 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
4088 c
= parse_symbol (&sh
,
4089 debug_info
->external_aux
+ fh
->iauxBase
,
4090 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4091 sym_ptr
+= c
* external_sym_size
;
4094 /* Linenumbers. At the end, check if we can save memory.
4095 parse_lines has to look ahead an arbitrary number of PDR
4096 structures, so we swap them all first. */
4100 struct cleanup
*old_chain
;
4106 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4108 old_chain
= make_cleanup (xfree
, pr_block
);
4110 pdr_ptr
= ((char *) debug_info
->external_pdr
4111 + fh
->ipdFirst
* external_pdr_size
);
4112 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4116 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4118 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4120 /* Determine lowest PDR address, the PDRs are not always
4122 if (pdr_in
== pr_block
)
4123 lowest_pdr_addr
= pdr_in
->adr
;
4124 else if (pdr_in
->adr
< lowest_pdr_addr
)
4125 lowest_pdr_addr
= pdr_in
->adr
;
4128 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
, lowest_pdr_addr
);
4129 if (lines
->nitems
< fh
->cline
)
4130 lines
= shrink_linetable (lines
);
4132 /* Fill in procedure info next. */
4134 pdr_in_end
= pdr_in
+ fh
->cpd
;
4135 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4136 parse_procedure (pdr_in
, 0, pst
);
4138 do_cleanups (old_chain
);
4142 LINETABLE (st
) = lines
;
4144 /* .. and our share of externals.
4145 XXX use the global list to speed up things here. how?
4146 FIXME, Maybe quit once we have found the right number of ext's? */
4147 top_stack
->cur_st
= st
;
4148 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
4150 top_stack
->blocktype
= stFile
;
4152 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
4153 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
4154 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4156 /* If there are undefined symbols, tell the user.
4157 The alpha has an undefined symbol for every symbol that is
4158 from a shared library, so tell the user only if verbose is on. */
4159 if (info_verbose
&& n_undef_symbols
)
4161 printf_filtered (_("File %s contains %d unresolved references:"),
4162 st
->filename
, n_undef_symbols
);
4163 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
4164 n_undef_vars
, n_undef_procs
, n_undef_labels
);
4165 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
4175 /* Now link the psymtab and the symtab. */
4178 current_objfile
= NULL
;
4181 /* Ancillary parsing procedures. */
4183 /* Return 1 if the symbol pointed to by SH has a cross reference
4184 to an opaque aggregate type, else 0. */
4187 has_opaque_xref (FDR
*fh
, SYMR
*sh
)
4194 if (sh
->index
== indexNil
)
4197 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
4198 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
4199 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
4203 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
4204 if (rn
->rfd
== 0xfff)
4205 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
4213 /* Lookup the type at relative index RN. Return it in TPP
4214 if found and in any event come up with its name PNAME.
4215 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4216 Return value says how many aux symbols we ate. */
4219 cross_ref (int fd
, union aux_ext
*ax
, struct type
**tpp
, enum type_code type_code
, /* Use to alloc new type if none is found. */
4220 char **pname
, int bigend
, char *sym_name
)
4229 struct mdebug_pending
*pend
;
4231 *tpp
= (struct type
*) NULL
;
4233 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
4235 /* Escape index means 'the next one' */
4236 if (rn
->rfd
== 0xfff)
4239 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
4246 /* mips cc uses a rf of -1 for opaque struct definitions.
4247 Set TYPE_FLAG_STUB for these types so that check_typedef will
4248 resolve them if the struct gets defined in another compilation unit. */
4251 *pname
= "<undefined>";
4252 *tpp
= init_type (type_code
, 0, TYPE_FLAG_STUB
, (char *) NULL
, current_objfile
);
4256 /* mips cc uses an escaped rn->index of 0 for struct return types
4257 of procedures that were compiled without -g. These will always remain
4259 if (rn
->rfd
== 0xfff && rn
->index
== 0)
4261 *pname
= "<undefined>";
4265 /* Find the relative file descriptor and the symbol in it. */
4266 fh
= get_rfd (fd
, rf
);
4267 xref_fd
= fh
- debug_info
->fdr
;
4269 if (rn
->index
>= fh
->csym
)
4271 /* File indirect entry is corrupt. */
4272 *pname
= "<illegal>";
4273 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4277 /* If we have processed this symbol then we left a forwarding
4278 pointer to the type in the pending list. If not, we`ll put
4279 it in a list of pending types, to be processed later when
4280 the file will be. In any event, we collect the name for the
4283 esh
= ((char *) debug_info
->external_sym
4284 + ((fh
->isymBase
+ rn
->index
)
4285 * debug_swap
->external_sym_size
));
4286 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
4288 /* Make sure that this type of cross reference can be handled. */
4289 if ((sh
.sc
!= scInfo
4290 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
4291 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
4292 && sh
.st
!= stEnum
))
4293 && (sh
.st
!= stBlock
|| !SC_IS_COMMON (sh
.sc
)))
4295 /* File indirect entry is corrupt. */
4296 *pname
= "<illegal>";
4297 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4301 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4303 pend
= is_pending_symbol (fh
, esh
);
4308 /* We have not yet seen this type. */
4310 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
4314 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4316 a) forward declarations of structs/unions/enums which are not
4317 defined in this compilation unit.
4318 For these the type will be void. This is a bad design decision
4319 as cross referencing across compilation units is impossible
4320 due to the missing name.
4321 b) forward declarations of structs/unions/enums/typedefs which
4322 are defined later in this file or in another file in the same
4323 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4324 Simply cross reference those again to get the true type.
4325 The forward references are not entered in the pending list and
4326 in the symbol table. */
4328 (*debug_swap
->swap_tir_in
) (bigend
,
4329 &(debug_info
->external_aux
4330 + fh
->iauxBase
+ sh
.index
)->a_ti
,
4332 if (tir
.tq0
!= tqNil
)
4333 complaint (&symfile_complaints
,
4334 _("illegal tq0 in forward typedef for %s"), sym_name
);
4338 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4340 *pname
= "<undefined>";
4347 (debug_info
->external_aux
4348 + fh
->iauxBase
+ sh
.index
+ 1),
4349 tpp
, type_code
, pname
,
4350 fh
->fBigendian
, sym_name
);
4354 /* Follow a forward typedef. This might recursively
4355 call cross_ref till we get a non typedef'ed type.
4356 FIXME: This is not correct behaviour, but gdb currently
4357 cannot handle typedefs without type copying. Type
4358 copying is impossible as we might have mutual forward
4359 references between two files and the copied type would not
4360 get filled in when we later parse its definition. */
4361 *tpp
= parse_type (xref_fd
,
4362 debug_info
->external_aux
+ fh
->iauxBase
,
4366 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4367 add_pending (fh
, esh
, *tpp
);
4371 complaint (&symfile_complaints
,
4372 _("illegal bt %d in forward typedef for %s"), tir
.bt
,
4374 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4380 else if (sh
.st
== stTypedef
)
4382 /* Parse the type for a normal typedef. This might recursively call
4383 cross_ref till we get a non typedef'ed type.
4384 FIXME: This is not correct behaviour, but gdb currently
4385 cannot handle typedefs without type copying. But type copying is
4386 impossible as we might have mutual forward references between
4387 two files and the copied type would not get filled in when
4388 we later parse its definition. */
4389 *tpp
= parse_type (xref_fd
,
4390 debug_info
->external_aux
+ fh
->iauxBase
,
4394 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4398 /* Cross reference to a struct/union/enum which is defined
4399 in another file in the same compilation unit but that file
4400 has not been parsed yet.
4401 Initialize the type only, it will be filled in when
4402 it's definition is parsed. */
4403 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
4405 add_pending (fh
, esh
, *tpp
);
4408 /* We used one auxent normally, two if we got a "next one" rf. */
4413 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4414 keeping the symtab sorted */
4416 static struct symbol
*
4417 mylookup_symbol (char *name
, struct block
*block
,
4418 domain_enum domain
, enum address_class
class)
4420 struct dict_iterator iter
;
4425 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
4427 if (DEPRECATED_SYMBOL_NAME (sym
)[0] == inc
4428 && SYMBOL_DOMAIN (sym
) == domain
4429 && SYMBOL_CLASS (sym
) == class
4430 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), name
) == 0)
4434 block
= BLOCK_SUPERBLOCK (block
);
4436 return mylookup_symbol (name
, block
, domain
, class);
4441 /* Add a new symbol S to a block B. */
4444 add_symbol (struct symbol
*s
, struct block
*b
)
4446 dict_add_symbol (BLOCK_DICT (b
), s
);
4449 /* Add a new block B to a symtab S */
4452 add_block (struct block
*b
, struct symtab
*s
)
4454 struct blockvector
*bv
= BLOCKVECTOR (s
);
4456 bv
= (struct blockvector
*) xrealloc ((void *) bv
,
4457 (sizeof (struct blockvector
)
4458 + BLOCKVECTOR_NBLOCKS (bv
)
4459 * sizeof (bv
->block
)));
4460 if (bv
!= BLOCKVECTOR (s
))
4461 BLOCKVECTOR (s
) = bv
;
4463 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
4466 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4467 MIPS' linenumber encoding might need more than one byte
4468 to describe it, LAST is used to detect these continuation lines.
4470 Combining lines with the same line number seems like a bad idea.
4471 E.g: There could be a line number entry with the same line number after the
4472 prologue and GDB should not ignore it (this is a better way to find
4473 a prologue than mips_skip_prologue).
4474 But due to the compressed line table format there are line number entries
4475 for the same line which are needed to bridge the gap to the next
4476 line number entry. These entries have a bogus address info with them
4477 and we are unable to tell them from intended duplicate line number
4479 This is another reason why -ggdb debugging format is preferable. */
4482 add_line (struct linetable
*lt
, int lineno
, CORE_ADDR adr
, int last
)
4484 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4485 Change them to something sensible. */
4489 last
= -2; /* make sure we record first line */
4491 if (last
== lineno
) /* skip continuation lines */
4494 lt
->item
[lt
->nitems
].line
= lineno
;
4495 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
4499 /* Sorting and reordering procedures */
4501 /* Blocks with a smaller low bound should come first */
4504 compare_blocks (const void *arg1
, const void *arg2
)
4507 struct block
**b1
= (struct block
**) arg1
;
4508 struct block
**b2
= (struct block
**) arg2
;
4510 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
4512 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
4516 /* Sort the blocks of a symtab S.
4517 Reorder the blocks in the blockvector by code-address,
4518 as required by some MI search routines */
4521 sort_blocks (struct symtab
*s
)
4523 struct blockvector
*bv
= BLOCKVECTOR (s
);
4525 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
4528 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
4529 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
4530 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
4531 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
4535 * This is very unfortunate: normally all functions are compiled in
4536 * the order they are found, but if the file is compiled -O3 things
4537 * are very different. It would be nice to find a reliable test
4538 * to detect -O3 images in advance.
4540 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
4541 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
4542 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
4543 sizeof (struct block
*),
4548 int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
4550 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
4551 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
4552 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
4553 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
4556 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
4557 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
4559 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4560 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4561 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4562 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4566 /* Constructor/restructor/destructor procedures */
4568 /* Allocate a new symtab for NAME. Needs an estimate of how many
4569 linenumbers MAXLINES we'll put in it */
4571 static struct symtab
*
4572 new_symtab (char *name
, int maxlines
, struct objfile
*objfile
)
4574 struct symtab
*s
= allocate_symtab (name
, objfile
);
4576 LINETABLE (s
) = new_linetable (maxlines
);
4578 /* All symtabs must have at least two blocks */
4579 BLOCKVECTOR (s
) = new_bvect (2);
4580 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
)
4581 = new_block (NON_FUNCTION_BLOCK
);
4582 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
4583 = new_block (NON_FUNCTION_BLOCK
);
4584 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
4585 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4587 s
->free_code
= free_linetable
;
4588 s
->debugformat
= obsavestring ("ECOFF", 5,
4589 &objfile
->objfile_obstack
);
4593 /* Allocate a new partial_symtab NAME */
4595 static struct partial_symtab
*
4596 new_psymtab (char *name
, struct objfile
*objfile
)
4598 struct partial_symtab
*psymtab
;
4600 psymtab
= allocate_psymtab (name
, objfile
);
4601 psymtab
->section_offsets
= objfile
->section_offsets
;
4603 /* Keep a backpointer to the file's symbols */
4605 psymtab
->read_symtab_private
= ((char *)
4606 obstack_alloc (&objfile
->objfile_obstack
,
4607 sizeof (struct symloc
)));
4608 memset (psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
4609 CUR_BFD (psymtab
) = cur_bfd
;
4610 DEBUG_SWAP (psymtab
) = debug_swap
;
4611 DEBUG_INFO (psymtab
) = debug_info
;
4612 PENDING_LIST (psymtab
) = pending_list
;
4614 /* The way to turn this into a symtab is to call... */
4615 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
4620 /* Allocate a linetable array of the given SIZE. Since the struct
4621 already includes one item, we subtract one when calculating the
4622 proper size to allocate. */
4624 static struct linetable
*
4625 new_linetable (int size
)
4627 struct linetable
*l
;
4629 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
4630 l
= (struct linetable
*) xmalloc (size
);
4635 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4636 I am not so sure about the 3.4 ones.
4638 Since the struct linetable already includes one item, we subtract one when
4639 calculating the proper size to allocate. */
4641 static struct linetable
*
4642 shrink_linetable (struct linetable
*lt
)
4645 return (struct linetable
*) xrealloc ((void *) lt
,
4646 (sizeof (struct linetable
)
4648 * sizeof (lt
->item
))));
4651 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4653 static struct blockvector
*
4654 new_bvect (int nblocks
)
4656 struct blockvector
*bv
;
4659 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4660 bv
= (struct blockvector
*) xzalloc (size
);
4662 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4667 /* Allocate and zero a new block, and set its BLOCK_DICT. If function
4668 is non-zero, assume the block is associated to a function, and make
4669 sure that the symbols are stored linearly; otherwise, store them
4672 static struct block
*
4673 new_block (enum block_type type
)
4675 /* FIXME: carlton/2003-09-11: This should use allocate_block to
4676 allocate the block. Which, in turn, suggests that the block
4677 should be allocated on an obstack. */
4678 struct block
*retval
= xzalloc (sizeof (struct block
));
4680 if (type
== FUNCTION_BLOCK
)
4681 BLOCK_DICT (retval
) = dict_create_linear_expandable ();
4683 BLOCK_DICT (retval
) = dict_create_hashed_expandable ();
4688 /* Create a new symbol with printname NAME */
4690 static struct symbol
*
4691 new_symbol (char *name
)
4693 struct symbol
*s
= ((struct symbol
*)
4694 obstack_alloc (¤t_objfile
->objfile_obstack
,
4695 sizeof (struct symbol
)));
4697 memset (s
, 0, sizeof (*s
));
4698 SYMBOL_LANGUAGE (s
) = psymtab_language
;
4699 SYMBOL_SET_NAMES (s
, name
, strlen (name
), current_objfile
);
4703 /* Create a new type with printname NAME */
4705 static struct type
*
4706 new_type (char *name
)
4710 t
= alloc_type (current_objfile
);
4711 TYPE_NAME (t
) = name
;
4712 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
4716 /* Read ECOFF debugging information from a BFD section. This is
4717 called from elfread.c. It parses the section into a
4718 ecoff_debug_info struct, and then lets the rest of the file handle
4722 elfmdebug_build_psymtabs (struct objfile
*objfile
,
4723 const struct ecoff_debug_swap
*swap
, asection
*sec
)
4725 bfd
*abfd
= objfile
->obfd
;
4726 struct ecoff_debug_info
*info
;
4727 struct cleanup
*back_to
;
4729 /* FIXME: It's not clear whether we should be getting minimal symbol
4730 information from .mdebug in an ELF file, or whether we will.
4731 Re-initialize the minimal symbol reader in case we do. */
4733 init_minimal_symbol_collection ();
4734 back_to
= make_cleanup_discard_minimal_symbols ();
4736 info
= ((struct ecoff_debug_info
*)
4737 obstack_alloc (&objfile
->objfile_obstack
,
4738 sizeof (struct ecoff_debug_info
)));
4740 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4741 error (_("Error reading ECOFF debugging information: %s"),
4742 bfd_errmsg (bfd_get_error ()));
4744 mdebug_build_psymtabs (objfile
, swap
, info
);
4746 install_minimal_symbols (objfile
);
4747 do_cleanups (back_to
);
4751 _initialize_mdebugread (void)
4754 init_type (TYPE_CODE_VOID
, 1,
4756 "void", (struct objfile
*) NULL
);
4758 init_type (TYPE_CODE_INT
, 1,
4760 "char", (struct objfile
*) NULL
);
4761 mdebug_type_unsigned_char
=
4762 init_type (TYPE_CODE_INT
, 1,
4764 "unsigned char", (struct objfile
*) NULL
);
4766 init_type (TYPE_CODE_INT
, 2,
4768 "short", (struct objfile
*) NULL
);
4769 mdebug_type_unsigned_short
=
4770 init_type (TYPE_CODE_INT
, 2,
4772 "unsigned short", (struct objfile
*) NULL
);
4773 mdebug_type_int_32
=
4774 init_type (TYPE_CODE_INT
, 4,
4776 "int", (struct objfile
*) NULL
);
4777 mdebug_type_unsigned_int_32
=
4778 init_type (TYPE_CODE_INT
, 4,
4780 "unsigned int", (struct objfile
*) NULL
);
4781 mdebug_type_int_64
=
4782 init_type (TYPE_CODE_INT
, 8,
4784 "int", (struct objfile
*) NULL
);
4785 mdebug_type_unsigned_int_64
=
4786 init_type (TYPE_CODE_INT
, 8,
4788 "unsigned int", (struct objfile
*) NULL
);
4789 mdebug_type_long_32
=
4790 init_type (TYPE_CODE_INT
, 4,
4792 "long", (struct objfile
*) NULL
);
4793 mdebug_type_unsigned_long_32
=
4794 init_type (TYPE_CODE_INT
, 4,
4796 "unsigned long", (struct objfile
*) NULL
);
4797 mdebug_type_long_64
=
4798 init_type (TYPE_CODE_INT
, 8,
4800 "long", (struct objfile
*) NULL
);
4801 mdebug_type_unsigned_long_64
=
4802 init_type (TYPE_CODE_INT
, 8,
4804 "unsigned long", (struct objfile
*) NULL
);
4805 mdebug_type_long_long_64
=
4806 init_type (TYPE_CODE_INT
, 8,
4808 "long long", (struct objfile
*) NULL
);
4809 mdebug_type_unsigned_long_long_64
=
4810 init_type (TYPE_CODE_INT
, 8,
4812 "unsigned long long", (struct objfile
*) NULL
);
4813 mdebug_type_adr_32
=
4814 init_type (TYPE_CODE_PTR
, 4,
4816 "adr_32", (struct objfile
*) NULL
);
4817 TYPE_TARGET_TYPE (mdebug_type_adr_32
) = mdebug_type_void
;
4818 mdebug_type_adr_64
=
4819 init_type (TYPE_CODE_PTR
, 8,
4821 "adr_64", (struct objfile
*) NULL
);
4822 TYPE_TARGET_TYPE (mdebug_type_adr_64
) = mdebug_type_void
;
4824 init_type (TYPE_CODE_FLT
,
4825 gdbarch_float_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
4826 0, "float", (struct objfile
*) NULL
);
4827 mdebug_type_double
=
4828 init_type (TYPE_CODE_FLT
,
4829 gdbarch_double_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
4830 0, "double", (struct objfile
*) NULL
);
4831 mdebug_type_complex
=
4832 init_type (TYPE_CODE_COMPLEX
,
4833 2 * gdbarch_float_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
4834 0, "complex", (struct objfile
*) NULL
);
4835 TYPE_TARGET_TYPE (mdebug_type_complex
) = mdebug_type_float
;
4836 mdebug_type_double_complex
=
4837 init_type (TYPE_CODE_COMPLEX
,
4838 2 * gdbarch_double_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
4839 0, "double complex", (struct objfile
*) NULL
);
4840 TYPE_TARGET_TYPE (mdebug_type_double_complex
) = mdebug_type_double
;
4842 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4844 mdebug_type_string
=
4845 init_type (TYPE_CODE_STRING
,
4846 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4848 (struct objfile
*) NULL
);
4850 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4851 good? Would we be better off with TYPE_CODE_ERROR? Should
4852 TYPE_CODE_ERROR print things in hex if it knows the size? */
4853 mdebug_type_fixed_dec
=
4854 init_type (TYPE_CODE_INT
,
4855 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
4857 (struct objfile
*) NULL
);
4859 mdebug_type_float_dec
=
4860 init_type (TYPE_CODE_ERROR
,
4861 gdbarch_double_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
4862 0, "floating decimal",
4863 (struct objfile
*) NULL
);