1 /* Read a symbol table in ECOFF format (Third-Eye).
3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
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 2 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, write to the Free Software
25 Foundation, Inc., 59 Temple Place - Suite 330,
26 Boston, MA 02111-1307, USA. */
28 /* This module provides the function mdebug_build_psymtabs. It reads
29 ECOFF debugging information into partial symbol tables. The
30 debugging information is read from two structures. A struct
31 ecoff_debug_swap includes the sizes of each ECOFF structure and
32 swapping routines; these are fixed for a particular target. A
33 struct ecoff_debug_info points to the debugging information for a
34 particular object file.
36 ECOFF symbol tables are mostly written in the byte order of the
37 target machine. However, one section of the table (the auxiliary
38 symbol information) is written in the host byte order. There is a
39 bit in the other symbol info which describes which host byte order
40 was used. ECOFF thereby takes the trophy from Intel `b.out' for
41 the most brain-dead adaptation of a file format to byte order.
43 This module can read all four of the known byte-order combinations,
44 on any type of host. */
51 #include "gdb_obstack.h"
53 #include "stabsread.h"
54 #include "complaints.h"
56 #include "gdb_assert.h"
58 #include "dictionary.h"
59 #include "mdebugread.h"
61 /* These are needed if the tm.h file does not contain the necessary
62 mips specific definitions. */
64 #ifndef MDEBUG_EFI_SYMBOL_NAME
65 #define MDEBUG_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
67 #include "coff/symconst.h"
68 struct mdebug_extra_func_info
79 #include "gdb_string.h"
83 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
85 #include "libaout.h" /* Private BFD a.out information. */
86 #include "aout/aout64.h"
87 #include "aout/stab_gnu.h" /* STABS information */
89 #include "expression.h"
91 extern void _initialize_mdebugread (void);
93 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
94 We use this define in order to know whether we should override a
95 symbol's ECOFF section with its ELF section. This is necessary in
96 case the symbol's ELF section could not be represented in ECOFF. */
97 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
98 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
101 /* We put a pointer to this structure in the read_symtab_private field
106 /* Index of the FDR that this psymtab represents. */
108 /* The BFD that the psymtab was created from. */
110 const struct ecoff_debug_swap
*debug_swap
;
111 struct ecoff_debug_info
*debug_info
;
112 struct mdebug_pending
**pending_list
;
113 /* Pointer to external symbols for this file. */
115 /* Size of extern_tab. */
117 enum language pst_language
;
120 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
121 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
122 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
123 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
124 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
125 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
127 #define SC_IS_TEXT(sc) ((sc) == scText \
128 || (sc) == scRConst \
131 #define SC_IS_DATA(sc) ((sc) == scData \
136 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
137 #define SC_IS_BSS(sc) ((sc) == scBss)
138 #define SC_IS_SBSS(sc) ((sc) == scSBss)
139 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
141 /* Various complaints about symbol reading that don't abort the process */
143 index_complaint (const char *arg1
)
145 complaint (&symfile_complaints
, "bad aux index at symbol %s", arg1
);
149 unknown_ext_complaint (const char *arg1
)
151 complaint (&symfile_complaints
, "unknown external symbol %s", arg1
);
155 basic_type_complaint (int arg1
, const char *arg2
)
157 complaint (&symfile_complaints
, "cannot map ECOFF basic type 0x%x for %s",
162 bad_tag_guess_complaint (const char *arg1
)
164 complaint (&symfile_complaints
, "guessed tag type of %s incorrectly", arg1
);
168 bad_rfd_entry_complaint (const char *arg1
, int arg2
, int arg3
)
170 complaint (&symfile_complaints
, "bad rfd entry for %s: file %d, index %d",
175 unexpected_type_code_complaint (const char *arg1
)
177 complaint (&symfile_complaints
, "unexpected type code for %s", arg1
);
180 /* Macros and extra defs */
182 /* Puns: hard to find whether -g was used and how */
184 #define MIN_GLEVEL GLEVEL_0
185 #define compare_glevel(a,b) \
186 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
187 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
189 /* Things that really are local to this module */
191 /* Remember what we deduced to be the source language of this psymtab. */
193 static enum language psymtab_language
= language_unknown
;
199 /* How to parse debugging information for CUR_BFD. */
201 static const struct ecoff_debug_swap
*debug_swap
;
203 /* Pointers to debugging information for CUR_BFD. */
205 static struct ecoff_debug_info
*debug_info
;
207 /* Pointer to current file decriptor record, and its index */
212 /* Index of current symbol */
216 /* Note how much "debuggable" this image is. We would like
217 to see at least one FDR with full symbols */
219 static int max_gdbinfo
;
220 static int max_glevel
;
222 /* When examining .o files, report on undefined symbols */
224 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
226 /* Pseudo symbol to use when putting stabs into the symbol table. */
228 static char stabs_symbol
[] = STABS_SYMBOL
;
230 /* Types corresponding to mdebug format bt* basic types. */
232 static struct type
*mdebug_type_void
;
233 static struct type
*mdebug_type_char
;
234 static struct type
*mdebug_type_short
;
235 static struct type
*mdebug_type_int_32
;
236 #define mdebug_type_int mdebug_type_int_32
237 static struct type
*mdebug_type_int_64
;
238 static struct type
*mdebug_type_long_32
;
239 static struct type
*mdebug_type_long_64
;
240 static struct type
*mdebug_type_long_long_64
;
241 static struct type
*mdebug_type_unsigned_char
;
242 static struct type
*mdebug_type_unsigned_short
;
243 static struct type
*mdebug_type_unsigned_int_32
;
244 static struct type
*mdebug_type_unsigned_int_64
;
245 static struct type
*mdebug_type_unsigned_long_32
;
246 static struct type
*mdebug_type_unsigned_long_64
;
247 static struct type
*mdebug_type_unsigned_long_long_64
;
248 static struct type
*mdebug_type_adr_32
;
249 static struct type
*mdebug_type_adr_64
;
250 static struct type
*mdebug_type_float
;
251 static struct type
*mdebug_type_double
;
252 static struct type
*mdebug_type_complex
;
253 static struct type
*mdebug_type_double_complex
;
254 static struct type
*mdebug_type_fixed_dec
;
255 static struct type
*mdebug_type_float_dec
;
256 static struct type
*mdebug_type_string
;
258 /* Types for symbols from files compiled without debugging info. */
260 static struct type
*nodebug_func_symbol_type
;
261 static struct type
*nodebug_var_symbol_type
;
263 /* Nonzero if we have seen ecoff debugging info for a file. */
265 static int found_ecoff_debugging_info
;
267 /* Forward declarations */
269 static int upgrade_type (int, struct type
**, int, union aux_ext
*,
272 static void parse_partial_symbols (struct objfile
*);
274 static int has_opaque_xref (FDR
*, SYMR
*);
276 static int cross_ref (int, union aux_ext
*, struct type
**, enum type_code
,
277 char **, int, char *);
279 static struct symbol
*new_symbol (char *);
281 static struct type
*new_type (char *);
283 enum block_type
{ FUNCTION_BLOCK
, NON_FUNCTION_BLOCK
};
285 static struct block
*new_block (enum block_type
);
287 static struct symtab
*new_symtab (char *, int, struct objfile
*);
289 static struct linetable
*new_linetable (int);
291 static struct blockvector
*new_bvect (int);
293 static struct type
*parse_type (int, union aux_ext
*, unsigned int, int *,
296 static struct symbol
*mylookup_symbol (char *, struct block
*, domain_enum
,
299 static void sort_blocks (struct symtab
*);
301 static struct partial_symtab
*new_psymtab (char *, struct objfile
*);
303 static void psymtab_to_symtab_1 (struct partial_symtab
*, char *);
305 static void add_block (struct block
*, struct symtab
*);
307 static void add_symbol (struct symbol
*, struct block
*);
309 static int add_line (struct linetable
*, int, CORE_ADDR
, int);
311 static struct linetable
*shrink_linetable (struct linetable
*);
313 static void handle_psymbol_enumerators (struct objfile
*, FDR
*, int,
316 static char *mdebug_next_symbol_text (struct objfile
*);
318 /* Allocate zeroed memory */
321 xzalloc (unsigned int size
)
323 void *p
= xmalloc (size
);
329 /* Exported procedure: Builds a symtab from the PST partial one.
330 Restores the environment in effect when PST was created, delegates
331 most of the work to an ancillary procedure, and sorts
332 and reorders the symtab list at the end */
335 mdebug_psymtab_to_symtab (struct partial_symtab
*pst
)
343 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
344 gdb_flush (gdb_stdout
);
347 next_symbol_text_func
= mdebug_next_symbol_text
;
349 psymtab_to_symtab_1 (pst
, pst
->filename
);
351 /* Match with global symbols. This only needs to be done once,
352 after all of the symtabs and dependencies have been read in. */
353 scan_file_globals (pst
->objfile
);
356 printf_filtered ("done.\n");
359 /* File-level interface functions */
361 /* Find a file descriptor given its index RF relative to a file CF */
364 get_rfd (int cf
, int rf
)
370 fdrs
= debug_info
->fdr
;
372 /* Object files do not have the RFD table, all refs are absolute */
375 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
376 ((char *) debug_info
->external_rfd
378 * debug_swap
->external_rfd_size
)),
383 /* Return a safer print NAME for a file descriptor */
389 return "<stripped file>";
392 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
396 /* Read in and parse the symtab of the file OBJFILE. Symbols from
397 different sections are relocated via the SECTION_OFFSETS. */
400 mdebug_build_psymtabs (struct objfile
*objfile
,
401 const struct ecoff_debug_swap
*swap
,
402 struct ecoff_debug_info
*info
)
404 cur_bfd
= objfile
->obfd
;
408 stabsread_new_init ();
409 buildsym_new_init ();
410 free_header_files ();
411 init_header_files ();
413 /* Make sure all the FDR information is swapped in. */
414 if (info
->fdr
== (FDR
*) NULL
)
420 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->objfile_obstack
,
421 (info
->symbolic_header
.ifdMax
423 fdr_src
= info
->external_fdr
;
425 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
427 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
428 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
431 parse_partial_symbols (objfile
);
434 /* Check to make sure file was compiled with -g. If not, warn the
435 user of this limitation. */
436 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
438 if (max_gdbinfo
== 0)
439 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
441 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
442 gdb_flush (gdb_stdout
);
447 /* Local utilities */
449 /* Map of FDR indexes to partial symtabs */
453 struct partial_symtab
*pst
; /* the psymtab proper */
454 long n_globals
; /* exported globals (external symbols) */
455 long globals_offset
; /* cumulative */
459 /* Utility stack, used to nest procedures and blocks properly.
460 It is a doubly linked list, to avoid too many alloc/free.
461 Since we might need it quite a few times it is NOT deallocated
464 static struct parse_stack
466 struct parse_stack
*next
, *prev
;
467 struct symtab
*cur_st
; /* Current symtab. */
468 struct block
*cur_block
; /* Block in it. */
470 /* What are we parsing. stFile, or stBlock are for files and
471 blocks. stProc or stStaticProc means we have seen the start of a
472 procedure, but not the start of the block within in. When we see
473 the start of that block, we change it to stNil, without pushing a
474 new block, i.e. stNil means both a procedure and a block. */
478 struct type
*cur_type
; /* Type we parse fields for. */
479 int cur_field
; /* Field number in cur_type. */
480 CORE_ADDR procadr
; /* Start addres of this procedure */
481 int numargs
; /* Its argument count */
484 *top_stack
; /* Top stack ptr */
487 /* Enter a new lexical context */
490 push_parse_stack (void)
492 struct parse_stack
*new;
494 /* Reuse frames if possible */
495 if (top_stack
&& top_stack
->prev
)
496 new = top_stack
->prev
;
498 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
499 /* Initialize new frame with previous content */
502 struct parse_stack
*prev
= new->prev
;
505 top_stack
->prev
= new;
507 new->next
= top_stack
;
512 /* Exit a lexical context */
515 pop_parse_stack (void)
520 top_stack
= top_stack
->next
;
524 /* Cross-references might be to things we haven't looked at
525 yet, e.g. type references. To avoid too many type
526 duplications we keep a quick fixup table, an array
527 of lists of references indexed by file descriptor */
529 struct mdebug_pending
531 struct mdebug_pending
*next
; /* link */
532 char *s
; /* the unswapped symbol */
533 struct type
*t
; /* its partial type descriptor */
537 /* The pending information is kept for an entire object file, and used
538 to be in the deprecated_sym_private field. I took it out when I
539 split mdebugread from mipsread, because this might not be the only
540 type of symbols read from an object file. Instead, we allocate the
541 pending information table when we create the partial symbols, and
542 we store a pointer to the single table in each psymtab. */
544 static struct mdebug_pending
**pending_list
;
546 /* Check whether we already saw symbol SH in file FH */
548 static struct mdebug_pending
*
549 is_pending_symbol (FDR
*fh
, char *sh
)
551 int f_idx
= fh
- debug_info
->fdr
;
552 struct mdebug_pending
*p
;
554 /* Linear search is ok, list is typically no more than 10 deep */
555 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
561 /* Add a new symbol SH of type T */
564 add_pending (FDR
*fh
, char *sh
, struct type
*t
)
566 int f_idx
= fh
- debug_info
->fdr
;
567 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
569 /* Make sure we do not make duplicates */
572 p
= ((struct mdebug_pending
*)
573 obstack_alloc (¤t_objfile
->objfile_obstack
,
574 sizeof (struct mdebug_pending
)));
577 p
->next
= pending_list
[f_idx
];
578 pending_list
[f_idx
] = p
;
583 /* Parsing Routines proper. */
585 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
586 For blocks, procedures and types we open a new lexical context.
587 This is basically just a big switch on the symbol's type. Argument
588 AX is the base pointer of aux symbols for this file (fh->iauxBase).
589 EXT_SH points to the unswapped symbol, which is needed for struct,
590 union, etc., types; it is NULL for an EXTR. BIGEND says whether
591 aux symbols are big-endian or little-endian. Return count of
592 SYMR's handled (normally one). */
595 parse_symbol (SYMR
*sh
, union aux_ext
*ax
, char *ext_sh
, int bigend
,
596 struct section_offsets
*section_offsets
, struct objfile
*objfile
)
598 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
599 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
603 struct mdebug_pending
*pend
;
607 enum address_class
class;
609 long svalue
= sh
->value
;
612 if (ext_sh
== (char *) NULL
)
613 name
= debug_info
->ssext
+ sh
->iss
;
615 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
621 /* Do not relocate relative values.
622 The value of a stEnd symbol is the displacement from the
623 corresponding start symbol value.
624 The value of a stBlock symbol is the displacement from the
625 procedure address. */
626 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
627 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
634 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
638 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS (objfile
));
647 case stGlobal
: /* external symbol, goes into global block */
649 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
651 s
= new_symbol (name
);
652 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
655 case stStatic
: /* static data, goes into current block. */
657 b
= top_stack
->cur_block
;
658 s
= new_symbol (name
);
659 if (SC_IS_COMMON (sh
->sc
))
661 /* It is a FORTRAN common block. At least for SGI Fortran the
662 address is not in the symbol; we need to fix it later in
663 scan_file_globals. */
664 int bucket
= hashname (DEPRECATED_SYMBOL_NAME (s
));
665 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
666 global_sym_chain
[bucket
] = s
;
669 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
672 case stLocal
: /* local variable, goes into current block */
673 if (sh
->sc
== scRegister
)
675 class = LOC_REGISTER
;
676 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
680 b
= top_stack
->cur_block
;
681 s
= new_symbol (name
);
682 SYMBOL_VALUE (s
) = svalue
;
684 data
: /* Common code for symbols describing data */
685 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
686 SYMBOL_CLASS (s
) = class;
689 /* Type could be missing if file is compiled without debugging info. */
690 if (SC_IS_UNDEF (sh
->sc
)
691 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
692 SYMBOL_TYPE (s
) = nodebug_var_symbol_type
;
694 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
695 /* Value of a data symbol is its memory address */
698 case stParam
: /* arg to procedure, goes into current block */
700 found_ecoff_debugging_info
= 1;
701 top_stack
->numargs
++;
703 /* Special GNU C++ name. */
704 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
705 name
= "this"; /* FIXME, not alloc'd in obstack */
706 s
= new_symbol (name
);
708 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
712 /* Pass by value in register. */
713 SYMBOL_CLASS (s
) = LOC_REGPARM
;
714 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
717 /* Pass by reference on stack. */
718 SYMBOL_CLASS (s
) = LOC_REF_ARG
;
721 /* Pass by reference in register. */
722 SYMBOL_CLASS (s
) = LOC_REGPARM_ADDR
;
723 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
726 /* Pass by value on stack. */
727 SYMBOL_CLASS (s
) = LOC_ARG
;
730 SYMBOL_VALUE (s
) = svalue
;
731 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
732 add_symbol (s
, top_stack
->cur_block
);
735 case stLabel
: /* label, goes into current block */
736 s
= new_symbol (name
);
737 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
; /* so that it can be used */
738 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
739 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
740 SYMBOL_TYPE (s
) = mdebug_type_int
;
741 add_symbol (s
, top_stack
->cur_block
);
744 case stProc
: /* Procedure, usually goes into global block */
745 case stStaticProc
: /* Static procedure, goes into current block */
746 /* For stProc symbol records, we need to check the storage class
747 as well, as only (stProc, scText) entries represent "real"
748 procedures - See the Compaq document titled "Object File /
749 Symbol Table Format Specification" for more information.
750 If the storage class is not scText, we discard the whole block
751 of symbol records for this stProc. */
752 if (sh
->st
== stProc
&& sh
->sc
!= scText
)
754 char *ext_tsym
= ext_sh
;
755 int keep_counting
= 1;
758 while (keep_counting
)
760 ext_tsym
+= external_sym_size
;
761 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
771 complaint (&symfile_complaints
,
772 "unknown symbol type 0x%x", sh
->st
);
778 s
= new_symbol (name
);
779 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
780 SYMBOL_CLASS (s
) = LOC_BLOCK
;
781 /* Type of the return value */
782 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
786 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
787 if (strcmp (name
, "malloc") == 0
788 && TYPE_CODE (t
) == TYPE_CODE_VOID
)
790 /* I don't know why, but, at least under Alpha GNU/Linux,
791 when linking against a malloc without debugging
792 symbols, its read as a function returning void---this
793 is bad because it means we cannot call functions with
794 string arguments interactively; i.e., "call
795 printf("howdy\n")" would fail with the error message
796 "program has no memory available". To avoid this, we
797 patch up the type and make it void*
798 instead. (davidm@azstarnet.com)
800 t
= make_pointer_type (t
, NULL
);
803 b
= top_stack
->cur_block
;
804 if (sh
->st
== stProc
)
806 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
807 /* The next test should normally be true, but provides a
808 hook for nested functions (which we don't want to make
810 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
811 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
812 /* Irix 5 sometimes has duplicate names for the same
813 function. We want to add such names up at the global
814 level, not as a nested function. */
815 else if (sh
->value
== top_stack
->procadr
)
816 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
820 /* Make a type for the procedure itself */
821 SYMBOL_TYPE (s
) = lookup_function_type (t
);
823 /* All functions in C++ have prototypes. For C we don't have enough
824 information in the debug info. */
825 if (SYMBOL_LANGUAGE (s
) == language_cplus
)
826 TYPE_FLAGS (SYMBOL_TYPE (s
)) |= TYPE_FLAG_PROTOTYPED
;
828 /* Create and enter a new lexical context */
829 b
= new_block (FUNCTION_BLOCK
);
830 SYMBOL_BLOCK_VALUE (s
) = b
;
831 BLOCK_FUNCTION (b
) = s
;
832 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
833 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
834 add_block (b
, top_stack
->cur_st
);
836 /* Not if we only have partial info */
837 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
841 top_stack
->cur_block
= b
;
842 top_stack
->blocktype
= sh
->st
;
843 top_stack
->cur_type
= SYMBOL_TYPE (s
);
844 top_stack
->cur_field
= -1;
845 top_stack
->procadr
= sh
->value
;
846 top_stack
->numargs
= 0;
849 /* Beginning of code for structure, union, and enum definitions.
850 They all share a common set of local variables, defined here. */
852 enum type_code type_code
;
858 case stStruct
: /* Start a block defining a struct type */
859 type_code
= TYPE_CODE_STRUCT
;
860 goto structured_common
;
862 case stUnion
: /* Start a block defining a union type */
863 type_code
= TYPE_CODE_UNION
;
864 goto structured_common
;
866 case stEnum
: /* Start a block defining an enum type */
867 type_code
= TYPE_CODE_ENUM
;
868 goto structured_common
;
870 case stBlock
: /* Either a lexical block, or some type */
871 if (sh
->sc
!= scInfo
&& !SC_IS_COMMON (sh
->sc
))
872 goto case_stBlock_code
; /* Lexical block */
874 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
876 /* Common code for handling struct, union, enum, and/or as-yet-
877 unknown-type blocks of info about structured data. `type_code'
878 has been set to the proper TYPE_CODE, if we know it. */
880 found_ecoff_debugging_info
= 1;
882 top_stack
->blocktype
= stBlock
;
884 /* First count the number of fields and the highest value. */
887 for (ext_tsym
= ext_sh
+ external_sym_size
;
889 ext_tsym
+= external_sym_size
)
893 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
898 /* C++ encodes class types as structures where there the
899 methods are encoded as stProc. The scope of stProc
900 symbols also ends with stEnd, thus creating a risk of
901 taking the wrong stEnd symbol record as the end of
902 the current struct, which would cause GDB to undercount
903 the real number of fields in this struct. To make sure
904 we really reached the right stEnd symbol record, we
905 check the associated name, and match it against the
906 struct name. Since method names are mangled while
907 the class name is not, there is no risk of having a
908 method whose name is identical to the class name
909 (in particular constructor method names are different
910 from the class name). There is therefore no risk that
911 this check stops the count on the StEnd of a method.
913 Also, assume that we're really at the end when tsym.iss
915 if (tsym
.iss
== issNull
916 || strcmp (debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
,
922 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
924 /* If the type of the member is Nil (or Void),
925 without qualifiers, assume the tag is an
927 Alpha cc -migrate enums are recognized by a zero
928 index and a zero symbol value.
929 DU 4.0 cc enums are recognized by a member type of
930 btEnum without qualifiers and a zero symbol value. */
931 if (tsym
.index
== indexNil
932 || (tsym
.index
== 0 && sh
->value
== 0))
933 type_code
= TYPE_CODE_ENUM
;
936 (*debug_swap
->swap_tir_in
) (bigend
,
937 &ax
[tsym
.index
].a_ti
,
939 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
940 || (tir
.bt
== btEnum
&& sh
->value
== 0))
942 type_code
= TYPE_CODE_ENUM
;
946 if (tsym
.value
> max_value
)
947 max_value
= tsym
.value
;
956 /* This is a no-op; is it trying to tell us something
957 we should be checking? */
958 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED */
962 /* This is something like a struct within a
963 struct. Skip over the fields of the inner
964 struct. The -1 is because the for loop will
965 increment ext_tsym. */
966 ext_tsym
= ((char *) debug_info
->external_sym
967 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
968 * external_sym_size
));
974 /* mips cc puts out a typedef for struct x if it is not yet
975 defined when it encounters
976 struct y { struct x *xp; };
981 /* Irix5 cc puts out a stIndirect for struct x if it is not
982 yet defined when it encounters
983 struct y { struct x *xp; };
988 complaint (&symfile_complaints
,
989 "declaration block contains unhandled symbol type %d",
995 /* In an stBlock, there is no way to distinguish structs,
996 unions, and enums at this point. This is a bug in the
997 original design (that has been fixed with the recent
998 addition of the stStruct, stUnion, and stEnum symbol
999 types.) The way you can tell is if/when you see a variable
1000 or field of that type. In that case the variable's type
1001 (in the AUX table) says if the type is struct, union, or
1002 enum, and points back to the stBlock here. So you can
1003 patch the tag kind up later - but only if there actually is
1004 a variable or field of that type.
1006 So until we know for sure, we will guess at this point.
1008 If the first member has index==indexNil or a void type,
1009 assume we have an enumeration.
1010 Otherwise, if there is more than one member, and all
1011 the members have offset 0, assume we have a union.
1012 Otherwise, assume we have a struct.
1014 The heuristic could guess wrong in the case of of an
1015 enumeration with no members or a union with one (or zero)
1016 members, or when all except the last field of a struct have
1017 width zero. These are uncommon and/or illegal situations,
1018 and in any case guessing wrong probably doesn't matter
1021 But if we later do find out we were wrong, we fixup the tag
1022 kind. Members of an enumeration must be handled
1023 differently from struct/union fields, and that is harder to
1024 patch up, but luckily we shouldn't need to. (If there are
1025 any enumeration members, we can tell for sure it's an enum
1028 if (type_code
== TYPE_CODE_UNDEF
)
1030 if (nfields
> 1 && max_value
== 0)
1031 type_code
= TYPE_CODE_UNION
;
1033 type_code
= TYPE_CODE_STRUCT
;
1036 /* Create a new type or use the pending type. */
1037 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1038 if (pend
== (struct mdebug_pending
*) NULL
)
1040 t
= new_type (NULL
);
1041 add_pending (cur_fdr
, ext_sh
, t
);
1046 /* Do not set the tag name if it is a compiler generated tag name
1047 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1048 Alpha cc puts out an sh->iss of zero for those. */
1049 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1050 TYPE_TAG_NAME (t
) = NULL
;
1052 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->objfile_obstack
,
1055 TYPE_CODE (t
) = type_code
;
1056 TYPE_LENGTH (t
) = sh
->value
;
1057 TYPE_NFIELDS (t
) = nfields
;
1058 TYPE_FIELDS (t
) = f
= ((struct field
*)
1060 nfields
* sizeof (struct field
)));
1062 if (type_code
== TYPE_CODE_ENUM
)
1064 int unsigned_enum
= 1;
1066 /* This is a non-empty enum. */
1068 /* DEC c89 has the number of enumerators in the sh.value field,
1069 not the type length, so we have to compensate for that
1070 incompatibility quirk.
1071 This might do the wrong thing for an enum with one or two
1072 enumerators and gcc -gcoff -fshort-enums, but these cases
1073 are hopefully rare enough.
1074 Alpha cc -migrate has a sh.value field of zero, we adjust
1076 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
)
1077 || TYPE_LENGTH (t
) == 0)
1078 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1079 for (ext_tsym
= ext_sh
+ external_sym_size
;
1081 ext_tsym
+= external_sym_size
)
1084 struct symbol
*enum_sym
;
1086 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1088 if (tsym
.st
!= stMember
)
1091 FIELD_BITPOS (*f
) = tsym
.value
;
1092 FIELD_TYPE (*f
) = t
;
1093 FIELD_NAME (*f
) = debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1094 FIELD_BITSIZE (*f
) = 0;
1095 FIELD_STATIC_KIND (*f
) = 0;
1097 enum_sym
= ((struct symbol
*)
1098 obstack_alloc (¤t_objfile
->objfile_obstack
,
1099 sizeof (struct symbol
)));
1100 memset (enum_sym
, 0, sizeof (struct symbol
));
1101 DEPRECATED_SYMBOL_NAME (enum_sym
) =
1102 obsavestring (f
->name
, strlen (f
->name
),
1103 ¤t_objfile
->objfile_obstack
);
1104 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1105 SYMBOL_TYPE (enum_sym
) = t
;
1106 SYMBOL_DOMAIN (enum_sym
) = VAR_DOMAIN
;
1107 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1108 if (SYMBOL_VALUE (enum_sym
) < 0)
1110 add_symbol (enum_sym
, top_stack
->cur_block
);
1112 /* Skip the stMembers that we've handled. */
1117 TYPE_FLAGS (t
) |= TYPE_FLAG_UNSIGNED
;
1119 /* make this the current type */
1120 top_stack
->cur_type
= t
;
1121 top_stack
->cur_field
= 0;
1123 /* Do not create a symbol for alpha cc unnamed structs. */
1127 /* gcc puts out an empty struct for an opaque struct definitions,
1128 do not create a symbol for it either. */
1129 if (TYPE_NFIELDS (t
) == 0)
1131 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1135 s
= new_symbol (name
);
1136 SYMBOL_DOMAIN (s
) = STRUCT_DOMAIN
;
1137 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1138 SYMBOL_VALUE (s
) = 0;
1139 SYMBOL_TYPE (s
) = t
;
1140 add_symbol (s
, top_stack
->cur_block
);
1143 /* End of local variables shared by struct, union, enum, and
1144 block (as yet unknown struct/union/enum) processing. */
1148 found_ecoff_debugging_info
= 1;
1149 /* beginnning of (code) block. Value of symbol
1150 is the displacement from procedure start */
1151 push_parse_stack ();
1153 /* Do not start a new block if this is the outermost block of a
1154 procedure. This allows the LOC_BLOCK symbol to point to the
1155 block with the local variables, so funcname::var works. */
1156 if (top_stack
->blocktype
== stProc
1157 || top_stack
->blocktype
== stStaticProc
)
1159 top_stack
->blocktype
= stNil
;
1163 top_stack
->blocktype
= stBlock
;
1164 b
= new_block (NON_FUNCTION_BLOCK
);
1165 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1166 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1167 top_stack
->cur_block
= b
;
1168 add_block (b
, top_stack
->cur_st
);
1171 case stEnd
: /* end (of anything) */
1172 if (sh
->sc
== scInfo
|| SC_IS_COMMON (sh
->sc
))
1174 /* Finished with type */
1175 top_stack
->cur_type
= 0;
1177 else if (sh
->sc
== scText
&&
1178 (top_stack
->blocktype
== stProc
||
1179 top_stack
->blocktype
== stStaticProc
))
1181 /* Finished with procedure */
1182 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1183 struct mdebug_extra_func_info
*e
;
1184 struct block
*b
= top_stack
->cur_block
;
1185 struct type
*ftype
= top_stack
->cur_type
;
1188 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1190 /* Make up special symbol to contain procedure specific info */
1191 s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
1192 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
1193 SYMBOL_CLASS (s
) = LOC_CONST
;
1194 SYMBOL_TYPE (s
) = mdebug_type_void
;
1195 e
= ((struct mdebug_extra_func_info
*)
1196 obstack_alloc (¤t_objfile
->objfile_obstack
,
1197 sizeof (struct mdebug_extra_func_info
)));
1198 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
1199 SYMBOL_VALUE (s
) = (long) e
;
1200 e
->numargs
= top_stack
->numargs
;
1201 e
->pdr
.framereg
= -1;
1202 add_symbol (s
, top_stack
->cur_block
);
1204 /* f77 emits proc-level with address bounds==[0,0],
1205 So look for such child blocks, and patch them. */
1206 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1208 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1209 if (BLOCK_SUPERBLOCK (b_bad
) == b
1210 && BLOCK_START (b_bad
) == top_stack
->procadr
1211 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1213 BLOCK_START (b_bad
) = BLOCK_START (b
);
1214 BLOCK_END (b_bad
) = BLOCK_END (b
);
1218 if (TYPE_NFIELDS (ftype
) <= 0)
1220 /* No parameter type information is recorded with the function's
1221 type. Set that from the type of the parameter symbols. */
1222 int nparams
= top_stack
->numargs
;
1228 struct dict_iterator iter
;
1229 TYPE_NFIELDS (ftype
) = nparams
;
1230 TYPE_FIELDS (ftype
) = (struct field
*)
1231 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1234 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1236 if (iparams
== nparams
)
1239 switch (SYMBOL_CLASS (sym
))
1244 case LOC_REGPARM_ADDR
:
1245 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1246 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
1256 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1258 /* End of (code) block. The value of the symbol is the
1259 displacement from the procedure`s start address of the
1260 end of this block. */
1261 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1263 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1265 /* End of outermost block. Pop parse stack and ignore. The
1266 following stEnd of stProc will take care of the block. */
1269 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1271 /* End of file. Pop parse stack and ignore. Higher
1272 level code deals with this. */
1276 complaint (&symfile_complaints
,
1277 "stEnd with storage class %d not handled", sh
->sc
);
1279 pop_parse_stack (); /* restore previous lexical context */
1282 case stMember
: /* member of struct or union */
1283 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1284 FIELD_NAME (*f
) = name
;
1285 FIELD_BITPOS (*f
) = sh
->value
;
1287 FIELD_TYPE (*f
) = parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1288 FIELD_BITSIZE (*f
) = bitsize
;
1289 FIELD_STATIC_KIND (*f
) = 0;
1292 case stIndirect
: /* forward declaration on Irix5 */
1293 /* Forward declarations from Irix5 cc are handled by cross_ref,
1297 case stTypedef
: /* type definition */
1298 found_ecoff_debugging_info
= 1;
1300 /* Typedefs for forward declarations and opaque structs from alpha cc
1301 are handled by cross_ref, skip them. */
1305 /* Parse the type or use the pending type. */
1306 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1307 if (pend
== (struct mdebug_pending
*) NULL
)
1309 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *) NULL
, bigend
, name
);
1310 add_pending (cur_fdr
, ext_sh
, t
);
1315 /* mips cc puts out a typedef with the name of the struct for forward
1316 declarations. These should not go into the symbol table and
1317 TYPE_NAME should not be set for them.
1318 They can't be distinguished from an intentional typedef to
1319 the same name however:
1321 struct x { int ix; int jx; };
1325 struct xx {int ixx; int jxx; };
1326 generates a cross referencing stTypedef for x and xx.
1327 The user visible effect of this is that the type of a pointer
1328 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1329 The problem is fixed with alpha cc and Irix5 cc. */
1331 /* However if the typedef cross references to an opaque aggregate, it
1332 is safe to omit it from the symbol table. */
1334 if (has_opaque_xref (cur_fdr
, sh
))
1336 s
= new_symbol (name
);
1337 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1338 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1339 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1340 SYMBOL_TYPE (s
) = t
;
1341 add_symbol (s
, top_stack
->cur_block
);
1343 /* Incomplete definitions of structs should not get a name. */
1344 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1345 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1346 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1347 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1349 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1350 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1352 /* If we are giving a name to a type such as "pointer to
1353 foo" or "function returning foo", we better not set
1354 the TYPE_NAME. If the program contains "typedef char
1355 *caddr_t;", we don't want all variables of type char
1356 * to print as caddr_t. This is not just a
1357 consequence of GDB's type management; CC and GCC (at
1358 least through version 2.4) both output variables of
1359 either type char * or caddr_t with the type
1360 refering to the stTypedef symbol for caddr_t. If a future
1361 compiler cleans this up it GDB is not ready for it
1362 yet, but if it becomes ready we somehow need to
1363 disable this check (without breaking the PCC/GCC2.4
1368 Fortunately, this check seems not to be necessary
1369 for anything except pointers or functions. */
1372 TYPE_NAME (SYMBOL_TYPE (s
)) = DEPRECATED_SYMBOL_NAME (s
);
1376 case stFile
: /* file name */
1377 push_parse_stack ();
1378 top_stack
->blocktype
= sh
->st
;
1381 /* I`ve never seen these for C */
1383 break; /* register relocation */
1385 break; /* forwarding address */
1387 break; /* constant */
1389 complaint (&symfile_complaints
, "unknown symbol type 0x%x", sh
->st
);
1396 /* Parse the type information provided in the raw AX entries for
1397 the symbol SH. Return the bitfield size in BS, in case.
1398 We must byte-swap the AX entries before we use them; BIGEND says whether
1399 they are big-endian or little-endian (from fh->fBigendian). */
1401 static struct type
*
1402 parse_type (int fd
, union aux_ext
*ax
, unsigned int aux_index
, int *bs
,
1403 int bigend
, char *sym_name
)
1405 /* Null entries in this map are treated specially */
1406 static struct type
**map_bt
[] =
1408 &mdebug_type_void
, /* btNil */
1409 &mdebug_type_adr_32
, /* btAdr */
1410 &mdebug_type_char
, /* btChar */
1411 &mdebug_type_unsigned_char
, /* btUChar */
1412 &mdebug_type_short
, /* btShort */
1413 &mdebug_type_unsigned_short
, /* btUShort */
1414 &mdebug_type_int_32
, /* btInt */
1415 &mdebug_type_unsigned_int_32
, /* btUInt */
1416 &mdebug_type_long_32
, /* btLong */
1417 &mdebug_type_unsigned_long_32
, /* btULong */
1418 &mdebug_type_float
, /* btFloat */
1419 &mdebug_type_double
, /* btDouble */
1426 &mdebug_type_complex
, /* btComplex */
1427 &mdebug_type_double_complex
, /* btDComplex */
1429 &mdebug_type_fixed_dec
, /* btFixedDec */
1430 &mdebug_type_float_dec
, /* btFloatDec */
1431 &mdebug_type_string
, /* btString */
1434 &mdebug_type_void
, /* btVoid */
1435 0, /* DEC C++: Pointer to member */
1436 0, /* DEC C++: Virtual function table */
1437 0, /* DEC C++: Class (Record) */
1438 &mdebug_type_long_64
, /* btLong64 */
1439 &mdebug_type_unsigned_long_64
, /* btULong64 */
1440 &mdebug_type_long_long_64
, /* btLongLong64 */
1441 &mdebug_type_unsigned_long_long_64
, /* btULongLong64 */
1442 &mdebug_type_adr_64
, /* btAdr64 */
1443 &mdebug_type_int_64
, /* btInt64 */
1444 &mdebug_type_unsigned_int_64
, /* btUInt64 */
1448 struct type
*tp
= 0;
1449 enum type_code type_code
= TYPE_CODE_UNDEF
;
1451 /* Handle undefined types, they have indexNil. */
1452 if (aux_index
== indexNil
)
1453 return mdebug_type_int
;
1455 /* Handle corrupt aux indices. */
1456 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1458 index_complaint (sym_name
);
1459 return mdebug_type_int
;
1463 /* Use aux as a type information record, map its basic type. */
1464 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1465 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1467 basic_type_complaint (t
->bt
, sym_name
);
1468 return mdebug_type_int
;
1472 tp
= *map_bt
[t
->bt
];
1477 /* Cannot use builtin types -- build our own */
1481 type_code
= TYPE_CODE_STRUCT
;
1484 type_code
= TYPE_CODE_UNION
;
1487 type_code
= TYPE_CODE_ENUM
;
1490 type_code
= TYPE_CODE_RANGE
;
1493 type_code
= TYPE_CODE_SET
;
1496 /* alpha cc -migrate uses this for typedefs. The true type will
1497 be obtained by crossreferencing below. */
1498 type_code
= TYPE_CODE_ERROR
;
1501 /* alpha cc uses this for typedefs. The true type will be
1502 obtained by crossreferencing below. */
1503 type_code
= TYPE_CODE_ERROR
;
1506 basic_type_complaint (t
->bt
, sym_name
);
1507 return mdebug_type_int
;
1511 /* Move on to next aux */
1516 int width
= AUX_GET_WIDTH (bigend
, ax
);
1517 /* Inhibit core dumps if TIR is corrupted. */
1518 if (bs
== (int *) NULL
)
1520 /* Alpha cc -migrate encodes char and unsigned char types
1521 as short and unsigned short types with a field width of 8.
1522 Enum types also have a field width which we ignore for now. */
1523 if (t
->bt
== btShort
&& width
== 8)
1524 tp
= mdebug_type_char
;
1525 else if (t
->bt
== btUShort
&& width
== 8)
1526 tp
= mdebug_type_unsigned_char
;
1527 else if (t
->bt
== btEnum
)
1530 complaint (&symfile_complaints
, "can't handle TIR fBitfield for %s",
1538 /* A btIndirect entry cross references to an aux entry containing
1540 if (t
->bt
== btIndirect
)
1547 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1549 if (rn
->rfd
== 0xfff)
1551 rf
= AUX_GET_ISYM (bigend
, ax
);
1559 complaint (&symfile_complaints
,
1560 "unable to cross ref btIndirect for %s", sym_name
);
1561 return mdebug_type_int
;
1563 xref_fh
= get_rfd (fd
, rf
);
1564 xref_fd
= xref_fh
- debug_info
->fdr
;
1565 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1566 rn
->index
, (int *) NULL
, xref_fh
->fBigendian
, sym_name
);
1569 /* All these types really point to some (common) MIPS type
1570 definition, and only the type-qualifiers fully identify
1571 them. We'll make the same effort at sharing. */
1572 if (t
->bt
== btStruct
||
1576 /* btSet (I think) implies that the name is a tag name, not a typedef
1577 name. This apparently is a MIPS extension for C sets. */
1582 /* Try to cross reference this type, build new type on failure. */
1583 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1584 if (tp
== (struct type
*) NULL
)
1585 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1587 /* DEC c89 produces cross references to qualified aggregate types,
1588 dereference them. */
1589 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1590 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1591 tp
= TYPE_TARGET_TYPE (tp
);
1593 /* Make sure that TYPE_CODE(tp) has an expected type code.
1594 Any type may be returned from cross_ref if file indirect entries
1596 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1597 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1598 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1600 unexpected_type_code_complaint (sym_name
);
1605 /* Usually, TYPE_CODE(tp) is already type_code. The main
1606 exception is if we guessed wrong re struct/union/enum.
1607 But for struct vs. union a wrong guess is harmless, so
1608 don't complain(). */
1609 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1610 && type_code
!= TYPE_CODE_ENUM
)
1611 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1612 && type_code
== TYPE_CODE_ENUM
))
1614 bad_tag_guess_complaint (sym_name
);
1617 if (TYPE_CODE (tp
) != type_code
)
1619 TYPE_CODE (tp
) = type_code
;
1622 /* Do not set the tag name if it is a compiler generated tag name
1623 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1624 if (name
[0] == '.' || name
[0] == '\0')
1625 TYPE_TAG_NAME (tp
) = NULL
;
1626 else if (TYPE_TAG_NAME (tp
) == NULL
1627 || strcmp (TYPE_TAG_NAME (tp
), name
) != 0)
1628 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1629 ¤t_objfile
->objfile_obstack
);
1633 /* All these types really point to some (common) MIPS type
1634 definition, and only the type-qualifiers fully identify
1635 them. We'll make the same effort at sharing.
1636 FIXME: We are not doing any guessing on range types. */
1637 if (t
->bt
== btRange
)
1641 /* Try to cross reference this type, build new type on failure. */
1642 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1643 if (tp
== (struct type
*) NULL
)
1644 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1646 /* Make sure that TYPE_CODE(tp) has an expected type code.
1647 Any type may be returned from cross_ref if file indirect entries
1649 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1651 unexpected_type_code_complaint (sym_name
);
1655 /* Usually, TYPE_CODE(tp) is already type_code. The main
1656 exception is if we guessed wrong re struct/union/enum. */
1657 if (TYPE_CODE (tp
) != type_code
)
1659 bad_tag_guess_complaint (sym_name
);
1660 TYPE_CODE (tp
) = type_code
;
1662 if (TYPE_NAME (tp
) == NULL
1663 || strcmp (TYPE_NAME (tp
), name
) != 0)
1664 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1665 ¤t_objfile
->objfile_obstack
);
1668 if (t
->bt
== btTypedef
)
1672 /* Try to cross reference this type, it should succeed. */
1673 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1674 if (tp
== (struct type
*) NULL
)
1676 complaint (&symfile_complaints
,
1677 "unable to cross ref btTypedef for %s", sym_name
);
1678 tp
= mdebug_type_int
;
1682 /* Deal with range types */
1683 if (t
->bt
== btRange
)
1685 TYPE_NFIELDS (tp
) = 2;
1686 TYPE_FIELDS (tp
) = ((struct field
*)
1687 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1688 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1689 ¤t_objfile
->objfile_obstack
);
1690 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1692 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1693 ¤t_objfile
->objfile_obstack
);
1694 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1698 /* Parse all the type qualifiers now. If there are more
1699 than 6 the game will continue in the next aux */
1703 #define PARSE_TQ(tq) \
1704 if (t->tq != tqNil) \
1705 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1717 /* mips cc 2.x and gcc never put out continued aux entries. */
1721 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1725 /* Complain for illegal continuations due to corrupt aux entries. */
1727 complaint (&symfile_complaints
, "illegal TIR continued for %s", sym_name
);
1732 /* Make up a complex type from a basic one. Type is passed by
1733 reference in TPP and side-effected as necessary. The type
1734 qualifier TQ says how to handle the aux symbols at AX for
1735 the symbol SX we are currently analyzing. BIGEND says whether
1736 aux symbols are big-endian or little-endian.
1737 Returns the number of aux symbols we parsed. */
1740 upgrade_type (int fd
, struct type
**tpp
, int tq
, union aux_ext
*ax
, int bigend
,
1746 /* Used in array processing */
1757 t
= lookup_pointer_type (*tpp
);
1762 t
= lookup_function_type (*tpp
);
1769 /* Determine and record the domain type (type of index) */
1770 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1776 rf
= AUX_GET_ISYM (bigend
, ax
);
1779 fh
= get_rfd (fd
, rf
);
1781 indx
= parse_type (fh
- debug_info
->fdr
,
1782 debug_info
->external_aux
+ fh
->iauxBase
,
1783 id
, (int *) NULL
, bigend
, sym_name
);
1785 /* The bounds type should be an integer type, but might be anything
1786 else due to corrupt aux entries. */
1787 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1789 complaint (&symfile_complaints
,
1790 "illegal array index type for %s, assuming int", sym_name
);
1791 indx
= mdebug_type_int
;
1794 /* Get the bounds, and create the array type. */
1796 lower
= AUX_GET_DNLOW (bigend
, ax
);
1798 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1800 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1802 range
= create_range_type ((struct type
*) NULL
, indx
,
1805 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1807 /* We used to fill in the supplied array element bitsize
1808 here if the TYPE_LENGTH of the target type was zero.
1809 This happens for a `pointer to an array of anonymous structs',
1810 but in this case the array element bitsize is also zero,
1811 so nothing is gained.
1812 And we used to check the TYPE_LENGTH of the target type against
1813 the supplied array element bitsize.
1814 gcc causes a mismatch for `pointer to array of object',
1815 since the sdb directives it uses do not have a way of
1816 specifying the bitsize, but it does no harm (the
1817 TYPE_LENGTH should be correct) and we should be able to
1818 ignore the erroneous bitsize from the auxiliary entry safely.
1819 dbx seems to ignore it too. */
1821 /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
1823 if (TYPE_LENGTH (*tpp
) == 0)
1825 TYPE_FLAGS (t
) |= TYPE_FLAG_TARGET_STUB
;
1832 /* Volatile -- currently ignored */
1836 /* Const -- currently ignored */
1840 complaint (&symfile_complaints
, "unknown type qualifier 0x%x", tq
);
1846 /* Parse a procedure descriptor record PR. Note that the procedure is
1847 parsed _after_ the local symbols, now we just insert the extra
1848 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1849 already been placed in the procedure's main block. Note also that
1850 images that have been partially stripped (ld -x) have been deprived
1851 of local symbols, and we have to cope with them here. FIRST_OFF is
1852 the offset of the first procedure for this FDR; we adjust the
1853 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1854 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1855 in question, or NULL to use top_stack->cur_block. */
1857 static void parse_procedure (PDR
*, struct symtab
*, struct partial_symtab
*);
1860 parse_procedure (PDR
*pr
, struct symtab
*search_symtab
,
1861 struct partial_symtab
*pst
)
1863 struct symbol
*s
, *i
;
1865 struct mdebug_extra_func_info
*e
;
1868 /* Simple rule to find files linked "-x" */
1869 if (cur_fdr
->rss
== -1)
1873 /* Static procedure at address pr->adr. Sigh. */
1874 /* FIXME-32x64. assuming pr->adr fits in long. */
1875 complaint (&symfile_complaints
,
1876 "can't handle PDR for static proc at 0x%lx",
1877 (unsigned long) pr
->adr
);
1885 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1886 ((char *) debug_info
->external_ext
1888 * debug_swap
->external_ext_size
)),
1890 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1898 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1899 ((char *) debug_info
->external_sym
1900 + ((cur_fdr
->isymBase
+ pr
->isym
)
1901 * debug_swap
->external_sym_size
)),
1903 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1906 if (search_symtab
!= NULL
)
1909 /* This loses both in the case mentioned (want a static, find a global),
1910 but also if we are looking up a non-mangled name which happens to
1911 match the name of a mangled function. */
1912 /* We have to save the cur_fdr across the call to lookup_symbol.
1913 If the pdr is for a static function and if a global function with
1914 the same name exists, lookup_symbol will eventually read in the symtab
1915 for the global function and clobber cur_fdr. */
1916 FDR
*save_cur_fdr
= cur_fdr
;
1917 s
= lookup_symbol (sh_name
, NULL
, VAR_DOMAIN
, 0, NULL
);
1918 cur_fdr
= save_cur_fdr
;
1922 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1928 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1929 VAR_DOMAIN
, LOC_BLOCK
);
1933 b
= SYMBOL_BLOCK_VALUE (s
);
1937 complaint (&symfile_complaints
, "PDR for %s, but no symbol", sh_name
);
1941 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1942 s
= new_symbol (sh_name
);
1943 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1944 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1945 /* Donno its type, hope int is ok */
1946 SYMBOL_TYPE (s
) = lookup_function_type (mdebug_type_int
);
1947 add_symbol (s
, top_stack
->cur_block
);
1948 /* Wont have symbols for this one */
1950 SYMBOL_BLOCK_VALUE (s
) = b
;
1951 BLOCK_FUNCTION (b
) = s
;
1952 BLOCK_START (b
) = pr
->adr
;
1953 /* BOUND used to be the end of procedure's text, but the
1954 argument is no longer passed in. */
1955 BLOCK_END (b
) = bound
;
1956 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1957 add_block (b
, top_stack
->cur_st
);
1961 i
= mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME
, b
, LABEL_DOMAIN
, LOC_CONST
);
1965 e
= (struct mdebug_extra_func_info
*) SYMBOL_VALUE (i
);
1967 e
->pdr
.isym
= (long) s
;
1969 /* GDB expects the absolute function start address for the
1970 procedure descriptor in e->pdr.adr.
1971 As the address in the procedure descriptor is usually relative,
1972 we would have to relocate e->pdr.adr with cur_fdr->adr and
1973 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
1974 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
1975 in shared libraries on some systems, and on other systems
1976 e->pdr.adr is sometimes offset by a bogus value.
1977 To work around these problems, we replace e->pdr.adr with
1978 the start address of the function. */
1979 e
->pdr
.adr
= BLOCK_START (b
);
1981 /* Correct incorrect setjmp procedure descriptor from the library
1982 to make backtrace through setjmp work. */
1983 if (e
->pdr
.pcreg
== 0
1984 && strcmp (sh_name
, "setjmp") == 0)
1986 complaint (&symfile_complaints
, "fixing bad setjmp PDR from libc");
1987 e
->pdr
.pcreg
= RA_REGNUM
;
1988 e
->pdr
.regmask
= 0x80000000;
1989 e
->pdr
.regoffset
= -4;
1993 /* It would be reasonable that functions that have been compiled
1994 without debugging info have a btNil type for their return value,
1995 and functions that are void and are compiled with debugging info
1997 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
1998 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2000 The glevel field in cur_fdr could be used to determine the presence
2001 of debugging info, but GCC doesn't always pass the -g switch settings
2002 to the assembler and GAS doesn't set the glevel field from the -g switch
2004 To work around these problems, the return value type of a TYPE_CODE_VOID
2005 function is adjusted accordingly if no debugging info was found in the
2006 compilation unit. */
2008 if (processing_gcc_compilation
== 0
2009 && found_ecoff_debugging_info
== 0
2010 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
2011 SYMBOL_TYPE (s
) = nodebug_func_symbol_type
;
2014 /* Relocate the extra function info pointed to by the symbol table. */
2017 ecoff_relocate_efi (struct symbol
*sym
, CORE_ADDR delta
)
2019 struct mdebug_extra_func_info
*e
;
2021 e
= (struct mdebug_extra_func_info
*) SYMBOL_VALUE (sym
);
2023 e
->pdr
.adr
+= delta
;
2026 /* Parse the external symbol ES. Just call parse_symbol() after
2027 making sure we know where the aux are for it.
2028 BIGEND says whether aux entries are big-endian or little-endian.
2030 This routine clobbers top_stack->cur_block and ->cur_st. */
2032 static void parse_external (EXTR
*, int, struct section_offsets
*,
2036 parse_external (EXTR
*es
, int bigend
, struct section_offsets
*section_offsets
,
2037 struct objfile
*objfile
)
2041 if (es
->ifd
!= ifdNil
)
2044 cur_fdr
= debug_info
->fdr
+ cur_fd
;
2045 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
2049 cur_fdr
= debug_info
->fdr
;
2053 /* Reading .o files */
2054 if (SC_IS_UNDEF (es
->asym
.sc
) || es
->asym
.sc
== scNil
)
2057 switch (es
->asym
.st
)
2060 /* These are generated for static symbols in .o files,
2081 /* FIXME: Turn this into a complaint? */
2083 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
2084 what
, debug_info
->ssext
+ es
->asym
.iss
,
2085 fdr_name (cur_fdr
));
2089 switch (es
->asym
.st
)
2093 /* There is no need to parse the external procedure symbols.
2094 If they are from objects compiled without -g, their index will
2095 be indexNil, and the symbol definition from the minimal symbol
2096 is preferrable (yielding a function returning int instead of int).
2097 If the index points to a local procedure symbol, the local
2098 symbol already provides the correct type.
2099 Note that the index of the external procedure symbol points
2100 to the local procedure symbol in the local symbol table, and
2101 _not_ to the auxiliary symbol info. */
2105 /* Global common symbols are resolved by the runtime loader,
2107 if (SC_IS_COMMON (es
->asym
.sc
))
2110 /* Note that the case of a symbol with indexNil must be handled
2111 anyways by parse_symbol(). */
2112 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
, objfile
);
2119 /* Parse the line number info for file descriptor FH into
2120 GDB's linetable LT. MIPS' encoding requires a little bit
2121 of magic to get things out. Note also that MIPS' line
2122 numbers can go back and forth, apparently we can live
2123 with that and do not need to reorder our linetables */
2125 static void parse_lines (FDR
*, PDR
*, struct linetable
*, int,
2126 struct partial_symtab
*, CORE_ADDR
);
2129 parse_lines (FDR
*fh
, PDR
*pr
, struct linetable
*lt
, int maxlines
,
2130 struct partial_symtab
*pst
, CORE_ADDR lowest_pdr_addr
)
2132 unsigned char *base
;
2134 int delta
, count
, lineno
= 0;
2136 if (fh
->cbLine
== 0)
2139 /* Scan by procedure descriptors */
2141 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2145 unsigned char *halt
;
2147 /* No code for this one */
2148 if (pr
->iline
== ilineNil
||
2149 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2152 /* Determine start and end address of compressed line bytes for
2154 base
= debug_info
->line
+ fh
->cbLineOffset
;
2155 if (j
!= (fh
->cpd
- 1))
2156 halt
= base
+ pr
[1].cbLineOffset
;
2158 halt
= base
+ fh
->cbLine
;
2159 base
+= pr
->cbLineOffset
;
2161 adr
= pst
->textlow
+ pr
->adr
- lowest_pdr_addr
;
2163 l
= adr
>> 2; /* in words */
2164 for (lineno
= pr
->lnLow
; base
< halt
;)
2166 count
= *base
& 0x0f;
2167 delta
= *base
++ >> 4;
2172 delta
= (base
[0] << 8) | base
[1];
2173 if (delta
>= 0x8000)
2177 lineno
+= delta
; /* first delta is 0 */
2179 /* Complain if the line table overflows. Could happen
2180 with corrupt binaries. */
2181 if (lt
->nitems
>= maxlines
)
2183 complaint (&symfile_complaints
,
2184 "guessed size of linetable for %s incorrectly",
2188 k
= add_line (lt
, lineno
, l
, k
);
2195 function_outside_compilation_unit_complaint (const char *arg1
)
2197 complaint (&symfile_complaints
,
2198 "function `%s' appears to be defined outside of all compilation units",
2202 /* Master parsing procedure for first-pass reading of file symbols
2203 into a partial_symtab. */
2206 parse_partial_symbols (struct objfile
*objfile
)
2208 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2209 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2210 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2211 void (*const swap_ext_in
) (bfd
*, void *, EXTR
*) = debug_swap
->swap_ext_in
;
2212 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
2213 void (*const swap_rfd_in
) (bfd
*, void *, RFDT
*) = debug_swap
->swap_rfd_in
;
2215 HDRR
*hdr
= &debug_info
->symbolic_header
;
2216 /* Running pointers */
2224 struct partial_symtab
*pst
;
2225 int textlow_not_set
= 1;
2226 int past_first_source_file
= 0;
2228 /* List of current psymtab's include files */
2229 char **psymtab_include_list
;
2230 int includes_allocated
;
2233 struct pst_map
*fdr_to_pst
;
2234 /* Index within current psymtab dependency list */
2235 struct partial_symtab
**dependency_list
;
2236 int dependencies_used
, dependencies_allocated
;
2237 struct cleanup
*old_chain
;
2239 enum language prev_language
;
2240 asection
*text_sect
;
2241 int relocatable
= 0;
2243 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2244 the shared libraries are prelinked at a high memory address.
2245 We have to adjust the start address of the object file for this case,
2246 by setting it to the start address of the first procedure in the file.
2247 But we should do no adjustments if we are debugging a .o file, where
2248 the text section (and fh->adr) really starts at zero. */
2249 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2250 if (text_sect
!= NULL
2251 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2254 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->objfile_obstack
,
2255 sizeof (EXTR
) * hdr
->iextMax
);
2257 includes_allocated
= 30;
2259 psymtab_include_list
= (char **) alloca (includes_allocated
*
2261 next_symbol_text_func
= mdebug_next_symbol_text
;
2263 dependencies_allocated
= 30;
2264 dependencies_used
= 0;
2266 (struct partial_symtab
**) alloca (dependencies_allocated
*
2267 sizeof (struct partial_symtab
*));
2269 last_source_file
= NULL
;
2274 * Only parse the Local and External symbols, and the Relative FDR.
2275 * Fixup enough of the loader symtab to be able to use it.
2276 * Allocate space only for the file's portions we need to
2281 max_glevel
= MIN_GLEVEL
;
2283 /* Allocate the map FDR -> PST.
2284 Minor hack: -O3 images might claim some global data belongs
2285 to FDR -1. We`ll go along with that */
2286 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2287 old_chain
= make_cleanup (xfree
, fdr_to_pst
);
2290 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2291 fdr_to_pst
[-1].pst
= pst
;
2295 /* Allocate the global pending list. */
2297 ((struct mdebug_pending
**)
2298 obstack_alloc (&objfile
->objfile_obstack
,
2299 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2300 memset (pending_list
, 0,
2301 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2303 /* Pass 0 over external syms: swap them in. */
2304 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2305 make_cleanup (xfree
, ext_block
);
2307 ext_out
= (char *) debug_info
->external_ext
;
2308 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2310 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2311 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2313 /* Pass 1 over external syms: Presize and partition the list */
2315 ext_in_end
= ext_in
+ hdr
->iextMax
;
2316 for (; ext_in
< ext_in_end
; ext_in
++)
2318 /* See calls to complain below. */
2319 if (ext_in
->ifd
>= -1
2320 && ext_in
->ifd
< hdr
->ifdMax
2321 && ext_in
->asym
.iss
>= 0
2322 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2323 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2326 /* Pass 1.5 over files: partition out global symbol space */
2328 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2330 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2331 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2332 fdr_to_pst
[f_idx
].n_globals
= 0;
2337 For ECOFF in ELF, we skip the creation of the minimal symbols.
2338 The ECOFF symbols should be a subset of the Elf symbols, and the
2339 section information of the elf symbols will be more accurate.
2340 FIXME! What about Irix 5's native linker?
2342 By default, Elf sections which don't exist in ECOFF
2343 get put in ECOFF's absolute section by the gnu linker.
2344 Since absolute sections don't get relocated, we
2345 end up calculating an address different from that of
2346 the symbol's minimal symbol (created earlier from the
2349 To fix this, either :
2350 1) don't create the duplicate symbol
2351 (assumes ECOFF symtab is a subset of the ELF symtab;
2352 assumes no side-effects result from ignoring ECOFF symbol)
2353 2) create it, only if lookup for existing symbol in ELF's minimal
2356 assumes no side-effects result from ignoring ECOFF symbol)
2357 3) create it, but lookup ELF's minimal symbol and use it's section
2358 during relocation, then modify "uniqify" phase to merge and
2359 eliminate the duplicate symbol
2360 (highly inefficient)
2362 I've implemented #1 here...
2363 Skip the creation of the minimal symbols based on the ECOFF
2366 /* Pass 2 over external syms: fill in external symbols */
2368 ext_in_end
= ext_in
+ hdr
->iextMax
;
2369 for (; ext_in
< ext_in_end
; ext_in
++)
2371 enum minimal_symbol_type ms_type
= mst_text
;
2372 CORE_ADDR svalue
= ext_in
->asym
.value
;
2374 /* The Irix 5 native tools seem to sometimes generate bogus
2375 external symbols. */
2376 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2378 complaint (&symfile_complaints
,
2379 "bad ifd for external symbol: %d (max %ld)", ext_in
->ifd
,
2383 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2385 complaint (&symfile_complaints
,
2386 "bad iss for external symbol: %ld (max %ld)",
2387 ext_in
->asym
.iss
, hdr
->issExtMax
);
2391 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2392 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2395 if (SC_IS_UNDEF (ext_in
->asym
.sc
) || ext_in
->asym
.sc
== scNil
)
2399 /* Pass 3 over files, over local syms: fill in static symbols */
2400 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2402 /* Process ECOFF Symbol Types and Storage Classes */
2403 switch (ext_in
->asym
.st
)
2406 /* Beginnning of Procedure */
2407 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2410 /* Load time only static procs */
2411 ms_type
= mst_file_text
;
2412 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2415 /* External symbol */
2416 if (SC_IS_COMMON (ext_in
->asym
.sc
))
2418 /* The value of a common symbol is its size, not its address.
2422 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2425 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2427 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2430 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2432 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2435 svalue
+= ANOFFSET (objfile
->section_offsets
,
2436 get_section_index (objfile
, ".sbss"));
2444 /* On certain platforms, some extra label symbols can be
2445 generated by the linker. One possible usage for this kind
2446 of symbols is to represent the address of the begining of a
2447 given section. For instance, on Tru64 5.1, the address of
2448 the _ftext label is the start address of the .text section.
2450 The storage class of these symbols is usually directly
2451 related to the section to which the symbol refers. For
2452 instance, on Tru64 5.1, the storage class for the _fdata
2453 label is scData, refering to the .data section.
2455 It is actually possible that the section associated to the
2456 storage class of the label does not exist. On True64 5.1
2457 for instance, the libm.so shared library does not contain
2458 any .data section, although it contains a _fpdata label
2459 which storage class is scData... Since these symbols are
2460 usually useless for the debugger user anyway, we just
2461 discard these symbols.
2464 if (SC_IS_TEXT (ext_in
->asym
.sc
))
2466 if (objfile
->sect_index_text
== -1)
2469 ms_type
= mst_file_text
;
2470 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2472 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2474 if (objfile
->sect_index_data
== -1)
2477 ms_type
= mst_file_data
;
2478 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2480 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2482 if (objfile
->sect_index_bss
== -1)
2485 ms_type
= mst_file_bss
;
2486 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2488 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2490 const int sbss_sect_index
= get_section_index (objfile
, ".sbss");
2492 if (sbss_sect_index
== -1)
2495 ms_type
= mst_file_bss
;
2496 svalue
+= ANOFFSET (objfile
->section_offsets
, sbss_sect_index
);
2503 /* The alpha has the section start addresses in stLocal symbols
2504 whose name starts with a `.'. Skip those but complain for all
2505 other stLocal symbols.
2506 Irix6 puts the section start addresses in stNil symbols, skip
2512 ms_type
= mst_unknown
;
2513 unknown_ext_complaint (name
);
2515 if (!ECOFF_IN_ELF (cur_bfd
))
2516 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2519 /* Pass 3 over files, over local syms: fill in static symbols */
2520 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2522 struct partial_symtab
*save_pst
;
2526 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2530 fdr_to_pst
[f_idx
].pst
= NULL
;
2534 /* Determine the start address for this object file from the
2535 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2539 if (relocatable
|| textlow
!= 0)
2540 textlow
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2544 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
2547 objfile
->global_psymbols
.next
,
2548 objfile
->static_psymbols
.next
);
2549 pst
->read_symtab_private
= ((char *)
2550 obstack_alloc (&objfile
->objfile_obstack
,
2551 sizeof (struct symloc
)));
2552 memset (pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2555 FDR_IDX (pst
) = f_idx
;
2556 CUR_BFD (pst
) = cur_bfd
;
2557 DEBUG_SWAP (pst
) = debug_swap
;
2558 DEBUG_INFO (pst
) = debug_info
;
2559 PENDING_LIST (pst
) = pending_list
;
2561 /* The way to turn this into a symtab is to call... */
2562 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2564 /* Set up language for the pst.
2565 The language from the FDR is used if it is unambigious (e.g. cfront
2566 with native cc and g++ will set the language to C).
2567 Otherwise we have to deduce the language from the filename.
2568 Native ecoff has every header file in a separate FDR, so
2569 deduce_language_from_filename will return language_unknown for
2570 a header file, which is not what we want.
2571 But the FDRs for the header files are after the FDR for the source
2572 file, so we can assign the language of the source file to the
2573 following header files. Then we save the language in the private
2574 pst data so that we can reuse it when building symtabs. */
2575 prev_language
= psymtab_language
;
2579 case langCplusplusV2
:
2580 psymtab_language
= language_cplus
;
2583 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2586 if (psymtab_language
== language_unknown
)
2587 psymtab_language
= prev_language
;
2588 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2590 pst
->texthigh
= pst
->textlow
;
2592 /* For stabs-in-ecoff files, the second symbol must be @stab.
2593 This symbol is emitted by mips-tfile to signal that the
2594 current object file uses encapsulated stabs instead of mips
2595 ecoff for local symbols. (It is the second symbol because
2596 the first symbol is the stFile used to signal the start of a
2598 processing_gcc_compilation
= 0;
2601 (*swap_sym_in
) (cur_bfd
,
2602 ((char *) debug_info
->external_sym
2603 + (fh
->isymBase
+ 1) * external_sym_size
),
2605 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2607 processing_gcc_compilation
= 2;
2610 if (processing_gcc_compilation
!= 0)
2612 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2617 (*swap_sym_in
) (cur_bfd
,
2618 (((char *) debug_info
->external_sym
)
2619 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2621 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2622 if (!ECOFF_IS_STAB (&sh
))
2624 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2629 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2630 if (sh
.st
== stStaticProc
)
2632 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2633 prim_record_minimal_symbol_and_info (namestring
,
2637 SECT_OFF_TEXT (objfile
),
2641 procaddr
= sh
.value
;
2643 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2644 (debug_info
->external_aux
2647 (*swap_sym_in
) (cur_bfd
,
2648 ((char *) debug_info
->external_sym
2649 + ((fh
->isymBase
+ isym
- 1)
2650 * external_sym_size
)),
2654 CORE_ADDR high
= procaddr
+ sh
.value
;
2656 /* Kludge for Irix 5.2 zero fh->adr. */
2658 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2659 pst
->textlow
= procaddr
;
2660 if (high
> pst
->texthigh
)
2661 pst
->texthigh
= high
;
2664 else if (sh
.st
== stStatic
)
2679 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2680 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2681 prim_record_minimal_symbol_and_info (namestring
,
2685 SECT_OFF_DATA (objfile
),
2691 /* FIXME! Shouldn't this use cases for bss,
2692 then have the default be abs? */
2693 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2694 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2695 prim_record_minimal_symbol_and_info (namestring
,
2699 SECT_OFF_BSS (objfile
),
2707 /* Handle stabs continuation */
2709 char *stabstring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2710 int len
= strlen (stabstring
);
2711 while (stabstring
[len
- 1] == '\\')
2714 char *stabstring1
= stabstring
;
2718 /* Ignore continuation char from 1st string */
2721 /* Read next stabstring */
2723 (*swap_sym_in
) (cur_bfd
,
2724 (((char *) debug_info
->external_sym
)
2725 + (fh
->isymBase
+ cur_sdx
)
2726 * external_sym_size
),
2728 stabstring2
= debug_info
->ss
+ fh
->issBase
+ sh2
.iss
;
2729 len2
= strlen (stabstring2
);
2731 /* Concatinate stabstring2 with stabstring1 */
2733 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
2734 stabstring
= xrealloc (stabstring
, len
+ len2
+ 1);
2737 stabstring
= xmalloc (len
+ len2
+ 1);
2738 strcpy (stabstring
, stabstring1
);
2740 strcpy (stabstring
+ len
, stabstring2
);
2748 * Standard, external, non-debugger, symbols
2751 case N_TEXT
| N_EXT
:
2752 case N_NBTEXT
| N_EXT
:
2753 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2756 case N_DATA
| N_EXT
:
2757 case N_NBDATA
| N_EXT
:
2758 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2763 case N_NBBSS
| N_EXT
:
2764 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
2765 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2772 /* Standard, local, non-debugger, symbols */
2776 /* We need to be able to deal with both N_FN or N_TEXT,
2777 because we have no way of knowing whether the sys-supplied ld
2778 or GNU ld was used to make the executable. Sequents throw
2779 in another wrinkle -- they renumbered N_FN. */
2787 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2790 case N_UNDF
| N_EXT
:
2791 continue; /* Just undefined, not COMMON */
2796 /* Lots of symbol types we can just ignore. */
2803 /* Keep going . . . */
2806 * Special symbol types for GNU
2809 case N_INDR
| N_EXT
:
2811 case N_SETA
| N_EXT
:
2813 case N_SETT
| N_EXT
:
2815 case N_SETD
| N_EXT
:
2817 case N_SETB
| N_EXT
:
2828 static int prev_so_symnum
= -10;
2829 static int first_so_symnum
;
2831 int prev_textlow_not_set
;
2833 valu
= sh
.value
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2835 prev_textlow_not_set
= textlow_not_set
;
2837 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2838 /* A zero value is probably an indication for the SunPRO 3.0
2839 compiler. end_psymtab explicitly tests for zero, so
2840 don't relocate it. */
2844 textlow_not_set
= 1;
2848 textlow_not_set
= 0;
2850 textlow_not_set
= 0;
2852 past_first_source_file
= 1;
2854 if (prev_so_symnum
!= symnum
- 1)
2855 { /* Here if prev stab wasn't N_SO */
2856 first_so_symnum
= symnum
;
2860 pst
= (struct partial_symtab
*) 0;
2862 dependencies_used
= 0;
2866 prev_so_symnum
= symnum
;
2868 /* End the current partial symtab and start a new one */
2870 /* SET_NAMESTRING ();*/
2871 namestring
= stabstring
;
2873 /* Null name means end of .o file. Don't start a new one. */
2874 if (*namestring
== '\000')
2877 /* Some compilers (including gcc) emit a pair of initial N_SOs.
2878 The first one is a directory name; the second the file name.
2879 If pst exists, is empty, and has a filename ending in '/',
2880 we assume the previous N_SO was a directory name. */
2882 p
= strrchr (namestring
, '/');
2883 if (p
&& *(p
+ 1) == '\000')
2884 continue; /* Simply ignore directory name SOs */
2886 /* Some other compilers (C++ ones in particular) emit useless
2887 SOs for non-existant .c files. We ignore all subsequent SOs that
2888 immediately follow the first. */
2900 enum language tmp_language
;
2901 /* Mark down an include file in the current psymtab */
2903 /* SET_NAMESTRING ();*/
2904 namestring
= stabstring
;
2906 tmp_language
= deduce_language_from_filename (namestring
);
2908 /* Only change the psymtab's language if we've learned
2909 something useful (eg. tmp_language is not language_unknown).
2910 In addition, to match what start_subfile does, never change
2912 if (tmp_language
!= language_unknown
2913 && (tmp_language
!= language_c
2914 || psymtab_language
!= language_cplus
))
2915 psymtab_language
= tmp_language
;
2917 /* In C++, one may expect the same filename to come round many
2918 times, when code is coming alternately from the main file
2919 and from inline functions in other files. So I check to see
2920 if this is a file we've seen before -- either the main
2921 source file, or a previously included file.
2923 This seems to be a lot of time to be spending on N_SOL, but
2924 things like "break c-exp.y:435" need to work (I
2925 suppose the psymtab_include_list could be hashed or put
2926 in a binary tree, if profiling shows this is a major hog). */
2927 if (pst
&& strcmp (namestring
, pst
->filename
) == 0)
2931 for (i
= 0; i
< includes_used
; i
++)
2932 if (strcmp (namestring
,
2933 psymtab_include_list
[i
]) == 0)
2942 psymtab_include_list
[includes_used
++] = namestring
;
2943 if (includes_used
>= includes_allocated
)
2945 char **orig
= psymtab_include_list
;
2947 psymtab_include_list
= (char **)
2948 alloca ((includes_allocated
*= 2) *
2950 memcpy (psymtab_include_list
, orig
,
2951 includes_used
* sizeof (char *));
2955 case N_LSYM
: /* Typedef or automatic variable. */
2956 case N_STSYM
: /* Data seg var -- static */
2957 case N_LCSYM
: /* BSS " */
2958 case N_ROSYM
: /* Read-only data seg var -- static. */
2959 case N_NBSTS
: /* Gould nobase. */
2960 case N_NBLCS
: /* symbols. */
2962 case N_GSYM
: /* Global (extern) variable; can be
2963 data or bss (sigh FIXME). */
2965 /* Following may probably be ignored; I'll leave them here
2966 for now (until I do Pascal and Modula 2 extensions). */
2968 case N_PC
: /* I may or may not need this; I
2970 case N_M2C
: /* I suspect that I can ignore this here. */
2971 case N_SCOPE
: /* Same. */
2973 /* SET_NAMESTRING ();*/
2974 namestring
= stabstring
;
2975 p
= (char *) strchr (namestring
, ':');
2977 continue; /* Not a debugging symbol. */
2981 /* Main processing section for debugging symbols which
2982 the initial read through the symbol tables needs to worry
2983 about. If we reach this point, the symbol which we are
2984 considering is definitely one we are interested in.
2985 p must also contain the (valid) index into the namestring
2986 which indicates the debugging type symbol. */
2991 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2992 #ifdef STATIC_TRANSFORM_NAME
2993 namestring
= STATIC_TRANSFORM_NAME (namestring
);
2995 add_psymbol_to_list (namestring
, p
- namestring
,
2996 VAR_DOMAIN
, LOC_STATIC
,
2997 &objfile
->static_psymbols
,
2999 psymtab_language
, objfile
);
3002 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3003 /* The addresses in these entries are reported to be
3004 wrong. See the code that reads 'G's for symtabs. */
3005 add_psymbol_to_list (namestring
, p
- namestring
,
3006 VAR_DOMAIN
, LOC_STATIC
,
3007 &objfile
->global_psymbols
,
3009 psymtab_language
, objfile
);
3013 /* When a 'T' entry is defining an anonymous enum, it
3014 may have a name which is the empty string, or a
3015 single space. Since they're not really defining a
3016 symbol, those shouldn't go in the partial symbol
3017 table. We do pick up the elements of such enums at
3018 'check_enum:', below. */
3019 if (p
>= namestring
+ 2
3020 || (p
== namestring
+ 1
3021 && namestring
[0] != ' '))
3023 add_psymbol_to_list (namestring
, p
- namestring
,
3024 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3025 &objfile
->static_psymbols
,
3027 psymtab_language
, objfile
);
3030 /* Also a typedef with the same name. */
3031 add_psymbol_to_list (namestring
, p
- namestring
,
3032 VAR_DOMAIN
, LOC_TYPEDEF
,
3033 &objfile
->static_psymbols
,
3035 psymtab_language
, objfile
);
3041 if (p
!= namestring
) /* a name is there, not just :T... */
3043 add_psymbol_to_list (namestring
, p
- namestring
,
3044 VAR_DOMAIN
, LOC_TYPEDEF
,
3045 &objfile
->static_psymbols
,
3047 psymtab_language
, objfile
);
3050 /* If this is an enumerated type, we need to
3051 add all the enum constants to the partial symbol
3052 table. This does not cover enums without names, e.g.
3053 "enum {a, b} c;" in C, but fortunately those are
3054 rare. There is no way for GDB to find those from the
3055 enum type without spending too much time on it. Thus
3056 to solve this problem, the compiler needs to put out the
3057 enum in a nameless type. GCC2 does this. */
3059 /* We are looking for something of the form
3060 <name> ":" ("t" | "T") [<number> "="] "e"
3061 {<constant> ":" <value> ","} ";". */
3063 /* Skip over the colon and the 't' or 'T'. */
3065 /* This type may be given a number. Also, numbers can come
3066 in pairs like (0,26). Skip over it. */
3067 while ((*p
>= '0' && *p
<= '9')
3068 || *p
== '(' || *p
== ',' || *p
== ')'
3074 /* The aix4 compiler emits extra crud before the members. */
3077 /* Skip over the type (?). */
3081 /* Skip over the colon. */
3085 /* We have found an enumerated type. */
3086 /* According to comments in read_enum_type
3087 a comma could end it instead of a semicolon.
3088 I don't know where that happens.
3090 while (*p
&& *p
!= ';' && *p
!= ',')
3094 /* Check for and handle cretinous dbx symbol name
3096 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
3097 p
= next_symbol_text (objfile
);
3099 /* Point to the character after the name
3100 of the enum constant. */
3101 for (q
= p
; *q
&& *q
!= ':'; q
++)
3103 /* Note that the value doesn't matter for
3104 enum constants in psymtabs, just in symtabs. */
3105 add_psymbol_to_list (p
, q
- p
,
3106 VAR_DOMAIN
, LOC_CONST
,
3107 &objfile
->static_psymbols
, 0,
3108 0, psymtab_language
, objfile
);
3109 /* Point past the name. */
3111 /* Skip over the value. */
3112 while (*p
&& *p
!= ',')
3114 /* Advance past the comma. */
3121 /* Constant, e.g. from "const" in Pascal. */
3122 add_psymbol_to_list (namestring
, p
- namestring
,
3123 VAR_DOMAIN
, LOC_CONST
,
3124 &objfile
->static_psymbols
, sh
.value
,
3125 0, psymtab_language
, objfile
);
3131 int name_len
= p
- namestring
;
3132 char *name
= xmalloc (name_len
+ 1);
3133 memcpy (name
, namestring
, name_len
);
3134 name
[name_len
] = '\0';
3135 function_outside_compilation_unit_complaint (name
);
3138 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3139 add_psymbol_to_list (namestring
, p
- namestring
,
3140 VAR_DOMAIN
, LOC_BLOCK
,
3141 &objfile
->static_psymbols
,
3143 psymtab_language
, objfile
);
3146 /* Global functions were ignored here, but now they
3147 are put into the global psymtab like one would expect.
3148 They're also in the minimal symbol table. */
3152 int name_len
= p
- namestring
;
3153 char *name
= xmalloc (name_len
+ 1);
3154 memcpy (name
, namestring
, name_len
);
3155 name
[name_len
] = '\0';
3156 function_outside_compilation_unit_complaint (name
);
3159 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3160 add_psymbol_to_list (namestring
, p
- namestring
,
3161 VAR_DOMAIN
, LOC_BLOCK
,
3162 &objfile
->global_psymbols
,
3164 psymtab_language
, objfile
);
3167 /* Two things show up here (hopefully); static symbols of
3168 local scope (static used inside braces) or extensions
3169 of structure symbols. We can ignore both. */
3183 case '#': /* for symbol identification (used in live ranges) */
3187 /* It is a C++ nested symbol. We don't need to record it
3188 (I don't think); if we try to look up foo::bar::baz,
3189 then symbols for the symtab containing foo should get
3190 read in, I think. */
3191 /* Someone says sun cc puts out symbols like
3192 /foo/baz/maclib::/usr/local/bin/maclib,
3193 which would get here with a symbol type of ':'. */
3197 /* Unexpected symbol descriptor. The second and subsequent stabs
3198 of a continued stab can show up here. The question is
3199 whether they ever can mimic a normal stab--it would be
3200 nice if not, since we certainly don't want to spend the
3201 time searching to the end of every string looking for
3204 complaint (&symfile_complaints
,
3205 "unknown symbol descriptor `%c'", p
[1]);
3207 /* Ignore it; perhaps it is an extension that we don't
3216 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
3217 /* Solaris 2 end of module, finish current partial
3218 symbol table. END_PSYMTAB will set
3219 pst->texthigh to the proper value, which is
3220 necessary if a module compiled without
3221 debugging info follows this module. */
3224 pst
= (struct partial_symtab
*) 0;
3226 dependencies_used
= 0;
3232 if (sh
.value
> save_pst
->texthigh
)
3233 save_pst
->texthigh
= sh
.value
;
3238 case N_SSYM
: /* Claim: Structure or union element.
3239 Hopefully, I can ignore this. */
3240 case N_ENTRY
: /* Alternate entry point; can ignore. */
3241 case N_MAIN
: /* Can definitely ignore this. */
3242 case N_CATCH
: /* These are GNU C++ extensions */
3243 case N_EHDECL
: /* that can safely be ignored here. */
3253 case N_NSYMS
: /* Ultrix 4.0: symbol count */
3254 case N_DEFD
: /* GNU Modula-2 */
3255 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
3257 case N_OBJ
: /* useless types from Solaris */
3259 /* These symbols aren't interesting; don't worry about them */
3264 /* If we haven't found it yet, ignore it. It's probably some
3265 new type we don't know about yet. */
3266 complaint (&symfile_complaints
, "unknown symbol type %s",
3267 hex_string (type_code
)); /*CUR_SYMBOL_TYPE*/
3271 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
3274 /* end - Handle continuation */
3279 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
3282 enum address_class
class;
3284 (*swap_sym_in
) (cur_bfd
,
3285 ((char *) debug_info
->external_sym
3286 + ((fh
->isymBase
+ cur_sdx
)
3287 * external_sym_size
)),
3290 if (ECOFF_IS_STAB (&sh
))
3296 /* Non absolute static symbols go into the minimal table. */
3297 if (SC_IS_UNDEF (sh
.sc
) || sh
.sc
== scNil
3298 || (sh
.index
== indexNil
3299 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
3301 /* FIXME, premature? */
3306 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3312 /* The value of a stEnd symbol is the displacement from the
3313 corresponding start symbol value, do not relocate it. */
3315 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3322 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3326 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3337 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3338 mst_file_text
, NULL
,
3339 SECT_OFF_TEXT (objfile
), NULL
,
3345 /* Ignore all parameter symbol records. */
3346 if (sh
.index
>= hdr
->iauxMax
)
3348 /* Should not happen, but does when cross-compiling
3349 with the MIPS compiler. FIXME -- pull later. */
3350 index_complaint (name
);
3351 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
3354 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
3355 (debug_info
->external_aux
3359 if (new_sdx
<= cur_sdx
)
3361 /* This should not happen either... FIXME. */
3362 complaint (&symfile_complaints
,
3363 "bad proc end in aux found from symbol %s",
3365 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3368 /* For stProc symbol records, we need to check the
3369 storage class as well, as only (stProc, scText)
3370 entries represent "real" procedures - See the
3371 Compaq document titled "Object File / Symbol Table
3372 Format Specification" for more information. If the
3373 storage class is not scText, we discard the whole
3374 block of symbol records for this stProc. */
3375 if (sh
.st
== stProc
&& sh
.sc
!= scText
)
3378 /* Usually there is a local and a global stProc symbol
3379 for a function. This means that the function name
3380 has already been entered into the mimimal symbol table
3381 while processing the global symbols in pass 2 above.
3382 One notable exception is the PROGRAM name from
3383 f77 compiled executables, it is only put out as
3384 local stProc symbol, and a global MAIN__ stProc symbol
3385 points to it. It doesn't matter though, as gdb is
3386 still able to find the PROGRAM name via the partial
3387 symbol table, and the MAIN__ symbol via the minimal
3389 if (sh
.st
== stProc
)
3390 add_psymbol_to_list (name
, strlen (name
),
3391 VAR_DOMAIN
, LOC_BLOCK
,
3392 &objfile
->global_psymbols
,
3393 0, sh
.value
, psymtab_language
, objfile
);
3395 add_psymbol_to_list (name
, strlen (name
),
3396 VAR_DOMAIN
, LOC_BLOCK
,
3397 &objfile
->static_psymbols
,
3398 0, sh
.value
, psymtab_language
, objfile
);
3400 procaddr
= sh
.value
;
3403 (*swap_sym_in
) (cur_bfd
,
3404 ((char *) debug_info
->external_sym
3405 + ((fh
->isymBase
+ cur_sdx
- 1)
3406 * external_sym_size
)),
3411 /* Kludge for Irix 5.2 zero fh->adr. */
3413 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
3414 pst
->textlow
= procaddr
;
3416 high
= procaddr
+ sh
.value
;
3417 if (high
> pst
->texthigh
)
3418 pst
->texthigh
= high
;
3421 case stStatic
: /* Variable */
3422 if (SC_IS_DATA (sh
.sc
))
3423 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3424 mst_file_data
, NULL
,
3425 SECT_OFF_DATA (objfile
),
3429 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3431 SECT_OFF_BSS (objfile
),
3437 case stIndirect
: /* Irix5 forward declaration */
3438 /* Skip forward declarations from Irix5 cc */
3441 case stTypedef
: /* Typedef */
3442 /* Skip typedefs for forward declarations and opaque
3443 structs from alpha and mips cc. */
3444 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
3446 class = LOC_TYPEDEF
;
3449 case stConstant
: /* Constant decl */
3456 case stBlock
: /* { }, str, un, enum */
3457 /* Do not create a partial symbol for cc unnamed aggregates
3458 and gcc empty aggregates. */
3459 if ((sh
.sc
== scInfo
3460 || SC_IS_COMMON (sh
.sc
))
3462 && sh
.index
!= cur_sdx
+ 2)
3464 add_psymbol_to_list (name
, strlen (name
),
3465 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3466 &objfile
->static_psymbols
,
3468 psymtab_language
, objfile
);
3470 handle_psymbol_enumerators (objfile
, fh
, sh
.st
, sh
.value
);
3472 /* Skip over the block */
3474 if (new_sdx
<= cur_sdx
)
3476 /* This happens with the Ultrix kernel. */
3477 complaint (&symfile_complaints
,
3478 "bad aux index at block symbol %s", name
);
3479 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3484 case stFile
: /* File headers */
3485 case stLabel
: /* Labels */
3486 case stEnd
: /* Ends of files */
3489 case stLocal
: /* Local variables */
3490 /* Normally these are skipped because we skip over
3491 all blocks we see. However, these can occur
3492 as visible symbols in a .h file that contains code. */
3496 /* Both complaints are valid: one gives symbol name,
3497 the other the offending symbol type. */
3498 complaint (&symfile_complaints
, "unknown local symbol %s",
3500 complaint (&symfile_complaints
, "with type %d", sh
.st
);
3504 /* Use this gdb symbol */
3505 add_psymbol_to_list (name
, strlen (name
),
3507 &objfile
->static_psymbols
,
3508 0, sh
.value
, psymtab_language
, objfile
);
3510 cur_sdx
++; /* Go to next file symbol */
3513 /* Now do enter the external symbols. */
3514 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
3515 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
3516 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
3517 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
3518 for (; --cur_sdx
>= 0; ext_ptr
++)
3520 enum address_class
class;
3525 if (ext_ptr
->ifd
!= f_idx
)
3526 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
3527 psh
= &ext_ptr
->asym
;
3529 /* Do not add undefined symbols to the partial symbol table. */
3530 if (SC_IS_UNDEF (psh
->sc
) || psh
->sc
== scNil
)
3533 svalue
= psh
->value
;
3538 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3545 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3549 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3556 /* These are generated for static symbols in .o files,
3561 /* External procedure symbols have been entered
3562 into the minimal symbol table in pass 2 above.
3563 Ignore them, as parse_external will ignore them too. */
3569 unknown_ext_complaint (debug_info
->ssext
+ psh
->iss
);
3570 /* Fall through, pretend it's global. */
3572 /* Global common symbols are resolved by the runtime loader,
3574 if (SC_IS_COMMON (psh
->sc
))
3580 name
= debug_info
->ssext
+ psh
->iss
;
3581 add_psymbol_to_list (name
, strlen (name
),
3583 &objfile
->global_psymbols
,
3585 psymtab_language
, objfile
);
3589 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3590 empty and put on the free list. */
3591 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
3592 psymtab_include_list
, includes_used
,
3593 -1, save_pst
->texthigh
,
3594 dependency_list
, dependencies_used
, textlow_not_set
);
3596 dependencies_used
= 0;
3598 /* The objfile has its functions reordered if this partial symbol
3599 table overlaps any other partial symbol table.
3600 We cannot assume a reordered objfile if a partial symbol table
3601 is contained within another partial symbol table, as partial symbol
3602 tables for include files with executable code are contained
3603 within the partial symbol table for the including source file,
3604 and we do not want to flag the objfile reordered for these cases.
3606 This strategy works well for Irix-5.2 shared libraries, but we
3607 might have to use a more elaborate (and slower) algorithm for
3609 save_pst
= fdr_to_pst
[f_idx
].pst
;
3610 if (save_pst
!= NULL
3611 && save_pst
->textlow
!= 0
3612 && !(objfile
->flags
& OBJF_REORDERED
))
3614 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
3617 && save_pst
->textlow
>= pst
->textlow
3618 && save_pst
->textlow
< pst
->texthigh
3619 && save_pst
->texthigh
> pst
->texthigh
)
3621 objfile
->flags
|= OBJF_REORDERED
;
3628 /* Now scan the FDRs for dependencies */
3629 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3631 fh
= f_idx
+ debug_info
->fdr
;
3632 pst
= fdr_to_pst
[f_idx
].pst
;
3634 if (pst
== (struct partial_symtab
*) NULL
)
3637 /* This should catch stabs-in-ecoff. */
3641 /* Skip the first file indirect entry as it is a self dependency
3642 for source files or a reverse .h -> .c dependency for header files. */
3643 pst
->number_of_dependencies
= 0;
3645 ((struct partial_symtab
**)
3646 obstack_alloc (&objfile
->objfile_obstack
,
3648 * sizeof (struct partial_symtab
*))));
3649 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3653 (*swap_rfd_in
) (cur_bfd
,
3654 ((char *) debug_info
->external_rfd
3655 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3657 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3659 complaint (&symfile_complaints
, "bad file number %ld", rh
);
3663 /* Skip self dependencies of header files. */
3667 /* Do not add to dependeny list if psymtab was empty. */
3668 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*) NULL
)
3670 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
3674 /* Remove the dummy psymtab created for -O3 images above, if it is
3675 still empty, to enable the detection of stripped executables. */
3676 if (objfile
->psymtabs
->next
== NULL
3677 && objfile
->psymtabs
->number_of_dependencies
== 0
3678 && objfile
->psymtabs
->n_global_syms
== 0
3679 && objfile
->psymtabs
->n_static_syms
== 0)
3680 objfile
->psymtabs
= NULL
;
3681 do_cleanups (old_chain
);
3684 /* If the current psymbol has an enumerated type, we need to add
3685 all the the enum constants to the partial symbol table. */
3688 handle_psymbol_enumerators (struct objfile
*objfile
, FDR
*fh
, int stype
,
3691 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3692 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
3693 char *ext_sym
= ((char *) debug_info
->external_sym
3694 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3704 /* It is an enumerated type if the next symbol entry is a stMember
3705 and its auxiliary index is indexNil or its auxiliary entry
3706 is a plain btNil or btVoid.
3707 Alpha cc -migrate enums are recognized by a zero index and
3708 a zero symbol value.
3709 DU 4.0 cc enums are recognized by a member type of btEnum without
3710 qualifiers and a zero symbol value. */
3711 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3712 if (sh
.st
!= stMember
)
3715 if (sh
.index
== indexNil
3716 || (sh
.index
== 0 && svalue
== 0))
3718 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3719 &(debug_info
->external_aux
3720 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3722 if ((tir
.bt
!= btNil
3724 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3725 || tir
.tq0
!= tqNil
)
3737 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3738 if (sh
.st
!= stMember
)
3740 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3742 /* Note that the value doesn't matter for enum constants
3743 in psymtabs, just in symtabs. */
3744 add_psymbol_to_list (name
, strlen (name
),
3745 VAR_DOMAIN
, LOC_CONST
,
3746 &objfile
->static_psymbols
, 0,
3747 (CORE_ADDR
) 0, psymtab_language
, objfile
);
3748 ext_sym
+= external_sym_size
;
3752 /* Get the next symbol. OBJFILE is unused. */
3755 mdebug_next_symbol_text (struct objfile
*objfile
)
3760 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3761 ((char *) debug_info
->external_sym
3762 + ((cur_fdr
->isymBase
+ cur_sdx
)
3763 * debug_swap
->external_sym_size
)),
3765 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3768 /* Ancillary function to psymtab_to_symtab(). Does all the work
3769 for turning the partial symtab PST into a symtab, recurring
3770 first on all dependent psymtabs. The argument FILENAME is
3771 only passed so we can see in debug stack traces what file
3774 This function has a split personality, based on whether the
3775 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3776 The flow of control and even the memory allocation differs. FIXME. */
3779 psymtab_to_symtab_1 (struct partial_symtab
*pst
, char *filename
)
3781 bfd_size_type external_sym_size
;
3782 bfd_size_type external_pdr_size
;
3783 void (*swap_sym_in
) (bfd
*, void *, SYMR
*);
3784 void (*swap_pdr_in
) (bfd
*, void *, PDR
*);
3786 struct symtab
*st
= NULL
;
3788 struct linetable
*lines
;
3789 CORE_ADDR lowest_pdr_addr
= 0;
3790 int last_symtab_ended
= 0;
3796 /* Read in all partial symbtabs on which this one is dependent.
3797 NOTE that we do have circular dependencies, sigh. We solved
3798 that by setting pst->readin before this point. */
3800 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3801 if (!pst
->dependencies
[i
]->readin
)
3803 /* Inform about additional files to be read in. */
3806 fputs_filtered (" ", gdb_stdout
);
3808 fputs_filtered ("and ", gdb_stdout
);
3810 printf_filtered ("%s...",
3811 pst
->dependencies
[i
]->filename
);
3812 wrap_here (""); /* Flush output */
3813 gdb_flush (gdb_stdout
);
3815 /* We only pass the filename for debug purposes */
3816 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3817 pst
->dependencies
[i
]->filename
);
3820 /* Do nothing if this is a dummy psymtab. */
3822 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3823 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3826 /* Now read the symbols for this symtab */
3828 cur_bfd
= CUR_BFD (pst
);
3829 debug_swap
= DEBUG_SWAP (pst
);
3830 debug_info
= DEBUG_INFO (pst
);
3831 pending_list
= PENDING_LIST (pst
);
3832 external_sym_size
= debug_swap
->external_sym_size
;
3833 external_pdr_size
= debug_swap
->external_pdr_size
;
3834 swap_sym_in
= debug_swap
->swap_sym_in
;
3835 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3836 current_objfile
= pst
->objfile
;
3837 cur_fd
= FDR_IDX (pst
);
3838 fh
= ((cur_fd
== -1)
3840 : debug_info
->fdr
+ cur_fd
);
3843 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3844 processing_gcc_compilation
= 0;
3845 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3849 (*swap_sym_in
) (cur_bfd
,
3850 ((char *) debug_info
->external_sym
3851 + (fh
->isymBase
+ 1) * external_sym_size
),
3853 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3856 /* We indicate that this is a GCC compilation so that certain
3857 features will be enabled in stabsread/dbxread. */
3858 processing_gcc_compilation
= 2;
3862 if (processing_gcc_compilation
!= 0)
3865 /* This symbol table contains stabs-in-ecoff entries. */
3867 /* Parse local symbols first */
3869 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3871 current_objfile
= NULL
;
3874 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3880 (*swap_sym_in
) (cur_bfd
,
3881 (((char *) debug_info
->external_sym
)
3882 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3884 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3886 /* XXX This is a hack. It will go away! */
3887 if (ECOFF_IS_STAB (&sh
) || (name
[0] == '#'))
3889 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3891 /* We should never get non N_STAB symbols here, but they
3892 should be harmless, so keep process_one_symbol from
3893 complaining about them. */
3894 if (type_code
& N_STAB
)
3896 /* If we found a trailing N_SO with no name, process
3897 it here instead of in process_one_symbol, so we
3898 can keep a handle to its symtab. The symtab
3899 would otherwise be ended twice, once in
3900 process_one_symbol, and once after this loop. */
3901 if (type_code
== N_SO
3903 && previous_stab_code
!= (unsigned char) N_SO
3906 valu
+= ANOFFSET (pst
->section_offsets
,
3907 SECT_OFF_TEXT (pst
->objfile
));
3908 previous_stab_code
= N_SO
;
3909 st
= end_symtab (valu
, pst
->objfile
,
3910 SECT_OFF_TEXT (pst
->objfile
));
3912 last_symtab_ended
= 1;
3916 last_symtab_ended
= 0;
3917 process_one_symbol (type_code
, 0, valu
, name
,
3918 pst
->section_offsets
, pst
->objfile
);
3921 /* Similarly a hack. */
3922 else if (name
[0] == '#')
3924 process_one_symbol (N_SLINE
, 0, valu
, name
,
3925 pst
->section_offsets
, pst
->objfile
);
3927 if (type_code
== N_FUN
)
3929 /* Make up special symbol to contain
3930 procedure specific info */
3931 struct mdebug_extra_func_info
*e
=
3932 ((struct mdebug_extra_func_info
*)
3933 obstack_alloc (¤t_objfile
->objfile_obstack
,
3934 sizeof (struct mdebug_extra_func_info
)));
3935 struct symbol
*s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
3937 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
3938 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
3939 SYMBOL_CLASS (s
) = LOC_CONST
;
3940 SYMBOL_TYPE (s
) = mdebug_type_void
;
3941 SYMBOL_VALUE (s
) = (long) e
;
3942 e
->pdr
.framereg
= -1;
3943 add_symbol_to_list (s
, &local_symbols
);
3946 else if (sh
.st
== stLabel
)
3948 if (sh
.index
== indexNil
)
3950 /* This is what the gcc2_compiled and __gnu_compiled_*
3951 show up as. So don't complain. */
3956 /* Handle encoded stab line number. */
3957 valu
+= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (pst
->objfile
));
3958 record_line (current_subfile
, sh
.index
, valu
);
3961 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3962 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3963 /* These are generated by gcc-2.x, do not complain */
3966 complaint (&symfile_complaints
, "unknown stabs symbol %s", name
);
3969 if (! last_symtab_ended
)
3971 st
= end_symtab (pst
->texthigh
, pst
->objfile
, SECT_OFF_TEXT (pst
->objfile
));
3975 /* There used to be a call to sort_blocks here, but this should not
3976 be necessary for stabs symtabs. And as sort_blocks modifies the
3977 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3978 it did the wrong thing if the first procedure in a file was
3979 generated via asm statements. */
3981 /* Fill in procedure info next. */
3985 struct cleanup
*old_chain
;
3991 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
3992 old_chain
= make_cleanup (xfree
, pr_block
);
3994 pdr_ptr
= ((char *) debug_info
->external_pdr
3995 + fh
->ipdFirst
* external_pdr_size
);
3996 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4000 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4002 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4004 /* Determine lowest PDR address, the PDRs are not always
4006 if (pdr_in
== pr_block
)
4007 lowest_pdr_addr
= pdr_in
->adr
;
4008 else if (pdr_in
->adr
< lowest_pdr_addr
)
4009 lowest_pdr_addr
= pdr_in
->adr
;
4013 pdr_in_end
= pdr_in
+ fh
->cpd
;
4014 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4015 parse_procedure (pdr_in
, st
, pst
);
4017 do_cleanups (old_chain
);
4022 /* This symbol table contains ordinary ecoff entries. */
4031 st
= new_symtab ("unknown", 0, pst
->objfile
);
4035 maxlines
= 2 * fh
->cline
;
4036 st
= new_symtab (pst
->filename
, maxlines
, pst
->objfile
);
4038 /* The proper language was already determined when building
4039 the psymtab, use it. */
4040 st
->language
= PST_PRIVATE (pst
)->pst_language
;
4043 psymtab_language
= st
->language
;
4045 lines
= LINETABLE (st
);
4047 /* Get a new lexical context */
4049 push_parse_stack ();
4050 top_stack
->cur_st
= st
;
4051 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
4053 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
4054 BLOCK_END (top_stack
->cur_block
) = 0;
4055 top_stack
->blocktype
= stFile
;
4056 top_stack
->cur_type
= 0;
4057 top_stack
->procadr
= 0;
4058 top_stack
->numargs
= 0;
4059 found_ecoff_debugging_info
= 0;
4066 /* Parse local symbols first */
4067 sym_ptr
= ((char *) debug_info
->external_sym
4068 + fh
->isymBase
* external_sym_size
);
4069 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
4070 while (sym_ptr
< sym_end
)
4075 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
4076 c
= parse_symbol (&sh
,
4077 debug_info
->external_aux
+ fh
->iauxBase
,
4078 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4079 sym_ptr
+= c
* external_sym_size
;
4082 /* Linenumbers. At the end, check if we can save memory.
4083 parse_lines has to look ahead an arbitrary number of PDR
4084 structures, so we swap them all first. */
4088 struct cleanup
*old_chain
;
4094 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4096 old_chain
= make_cleanup (xfree
, pr_block
);
4098 pdr_ptr
= ((char *) debug_info
->external_pdr
4099 + fh
->ipdFirst
* external_pdr_size
);
4100 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4104 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4106 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4108 /* Determine lowest PDR address, the PDRs are not always
4110 if (pdr_in
== pr_block
)
4111 lowest_pdr_addr
= pdr_in
->adr
;
4112 else if (pdr_in
->adr
< lowest_pdr_addr
)
4113 lowest_pdr_addr
= pdr_in
->adr
;
4116 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
, lowest_pdr_addr
);
4117 if (lines
->nitems
< fh
->cline
)
4118 lines
= shrink_linetable (lines
);
4120 /* Fill in procedure info next. */
4122 pdr_in_end
= pdr_in
+ fh
->cpd
;
4123 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4124 parse_procedure (pdr_in
, 0, pst
);
4126 do_cleanups (old_chain
);
4130 LINETABLE (st
) = lines
;
4132 /* .. and our share of externals.
4133 XXX use the global list to speed up things here. how?
4134 FIXME, Maybe quit once we have found the right number of ext's? */
4135 top_stack
->cur_st
= st
;
4136 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
4138 top_stack
->blocktype
= stFile
;
4140 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
4141 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
4142 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4144 /* If there are undefined symbols, tell the user.
4145 The alpha has an undefined symbol for every symbol that is
4146 from a shared library, so tell the user only if verbose is on. */
4147 if (info_verbose
&& n_undef_symbols
)
4149 printf_filtered ("File %s contains %d unresolved references:",
4150 st
->filename
, n_undef_symbols
);
4151 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
4152 n_undef_vars
, n_undef_procs
, n_undef_labels
);
4153 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
4163 /* Now link the psymtab and the symtab. */
4166 current_objfile
= NULL
;
4169 /* Ancillary parsing procedures. */
4171 /* Return 1 if the symbol pointed to by SH has a cross reference
4172 to an opaque aggregate type, else 0. */
4175 has_opaque_xref (FDR
*fh
, SYMR
*sh
)
4182 if (sh
->index
== indexNil
)
4185 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
4186 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
4187 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
4191 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
4192 if (rn
->rfd
== 0xfff)
4193 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
4201 /* Lookup the type at relative index RN. Return it in TPP
4202 if found and in any event come up with its name PNAME.
4203 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4204 Return value says how many aux symbols we ate. */
4207 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. */
4208 char **pname
, int bigend
, char *sym_name
)
4217 struct mdebug_pending
*pend
;
4219 *tpp
= (struct type
*) NULL
;
4221 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
4223 /* Escape index means 'the next one' */
4224 if (rn
->rfd
== 0xfff)
4227 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
4234 /* mips cc uses a rf of -1 for opaque struct definitions.
4235 Set TYPE_FLAG_STUB for these types so that check_typedef will
4236 resolve them if the struct gets defined in another compilation unit. */
4239 *pname
= "<undefined>";
4240 *tpp
= init_type (type_code
, 0, TYPE_FLAG_STUB
, (char *) NULL
, current_objfile
);
4244 /* mips cc uses an escaped rn->index of 0 for struct return types
4245 of procedures that were compiled without -g. These will always remain
4247 if (rn
->rfd
== 0xfff && rn
->index
== 0)
4249 *pname
= "<undefined>";
4253 /* Find the relative file descriptor and the symbol in it. */
4254 fh
= get_rfd (fd
, rf
);
4255 xref_fd
= fh
- debug_info
->fdr
;
4257 if (rn
->index
>= fh
->csym
)
4259 /* File indirect entry is corrupt. */
4260 *pname
= "<illegal>";
4261 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4265 /* If we have processed this symbol then we left a forwarding
4266 pointer to the type in the pending list. If not, we`ll put
4267 it in a list of pending types, to be processed later when
4268 the file will be. In any event, we collect the name for the
4271 esh
= ((char *) debug_info
->external_sym
4272 + ((fh
->isymBase
+ rn
->index
)
4273 * debug_swap
->external_sym_size
));
4274 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
4276 /* Make sure that this type of cross reference can be handled. */
4277 if ((sh
.sc
!= scInfo
4278 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
4279 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
4280 && sh
.st
!= stEnum
))
4281 && (sh
.st
!= stBlock
|| !SC_IS_COMMON (sh
.sc
)))
4283 /* File indirect entry is corrupt. */
4284 *pname
= "<illegal>";
4285 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4289 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4291 pend
= is_pending_symbol (fh
, esh
);
4296 /* We have not yet seen this type. */
4298 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
4302 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4304 a) forward declarations of structs/unions/enums which are not
4305 defined in this compilation unit.
4306 For these the type will be void. This is a bad design decision
4307 as cross referencing across compilation units is impossible
4308 due to the missing name.
4309 b) forward declarations of structs/unions/enums/typedefs which
4310 are defined later in this file or in another file in the same
4311 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4312 Simply cross reference those again to get the true type.
4313 The forward references are not entered in the pending list and
4314 in the symbol table. */
4316 (*debug_swap
->swap_tir_in
) (bigend
,
4317 &(debug_info
->external_aux
4318 + fh
->iauxBase
+ sh
.index
)->a_ti
,
4320 if (tir
.tq0
!= tqNil
)
4321 complaint (&symfile_complaints
,
4322 "illegal tq0 in forward typedef for %s", sym_name
);
4326 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4328 *pname
= "<undefined>";
4335 (debug_info
->external_aux
4336 + fh
->iauxBase
+ sh
.index
+ 1),
4337 tpp
, type_code
, pname
,
4338 fh
->fBigendian
, sym_name
);
4342 /* Follow a forward typedef. This might recursively
4343 call cross_ref till we get a non typedef'ed type.
4344 FIXME: This is not correct behaviour, but gdb currently
4345 cannot handle typedefs without type copying. Type
4346 copying is impossible as we might have mutual forward
4347 references between two files and the copied type would not
4348 get filled in when we later parse its definition. */
4349 *tpp
= parse_type (xref_fd
,
4350 debug_info
->external_aux
+ fh
->iauxBase
,
4354 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4355 add_pending (fh
, esh
, *tpp
);
4359 complaint (&symfile_complaints
,
4360 "illegal bt %d in forward typedef for %s", tir
.bt
,
4362 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4368 else if (sh
.st
== stTypedef
)
4370 /* Parse the type for a normal typedef. This might recursively call
4371 cross_ref till we get a non typedef'ed type.
4372 FIXME: This is not correct behaviour, but gdb currently
4373 cannot handle typedefs without type copying. But type copying is
4374 impossible as we might have mutual forward references between
4375 two files and the copied type would not get filled in when
4376 we later parse its definition. */
4377 *tpp
= parse_type (xref_fd
,
4378 debug_info
->external_aux
+ fh
->iauxBase
,
4382 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4386 /* Cross reference to a struct/union/enum which is defined
4387 in another file in the same compilation unit but that file
4388 has not been parsed yet.
4389 Initialize the type only, it will be filled in when
4390 it's definition is parsed. */
4391 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
4393 add_pending (fh
, esh
, *tpp
);
4396 /* We used one auxent normally, two if we got a "next one" rf. */
4401 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4402 keeping the symtab sorted */
4404 static struct symbol
*
4405 mylookup_symbol (char *name
, struct block
*block
,
4406 domain_enum domain
, enum address_class
class)
4408 struct dict_iterator iter
;
4413 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
4415 if (DEPRECATED_SYMBOL_NAME (sym
)[0] == inc
4416 && SYMBOL_DOMAIN (sym
) == domain
4417 && SYMBOL_CLASS (sym
) == class
4418 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), name
) == 0)
4422 block
= BLOCK_SUPERBLOCK (block
);
4424 return mylookup_symbol (name
, block
, domain
, class);
4429 /* Add a new symbol S to a block B. */
4432 add_symbol (struct symbol
*s
, struct block
*b
)
4434 dict_add_symbol (BLOCK_DICT (b
), s
);
4437 /* Add a new block B to a symtab S */
4440 add_block (struct block
*b
, struct symtab
*s
)
4442 struct blockvector
*bv
= BLOCKVECTOR (s
);
4444 bv
= (struct blockvector
*) xrealloc ((void *) bv
,
4445 (sizeof (struct blockvector
)
4446 + BLOCKVECTOR_NBLOCKS (bv
)
4447 * sizeof (bv
->block
)));
4448 if (bv
!= BLOCKVECTOR (s
))
4449 BLOCKVECTOR (s
) = bv
;
4451 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
4454 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4455 MIPS' linenumber encoding might need more than one byte
4456 to describe it, LAST is used to detect these continuation lines.
4458 Combining lines with the same line number seems like a bad idea.
4459 E.g: There could be a line number entry with the same line number after the
4460 prologue and GDB should not ignore it (this is a better way to find
4461 a prologue than mips_skip_prologue).
4462 But due to the compressed line table format there are line number entries
4463 for the same line which are needed to bridge the gap to the next
4464 line number entry. These entries have a bogus address info with them
4465 and we are unable to tell them from intended duplicate line number
4467 This is another reason why -ggdb debugging format is preferable. */
4470 add_line (struct linetable
*lt
, int lineno
, CORE_ADDR adr
, int last
)
4472 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4473 Change them to something sensible. */
4477 last
= -2; /* make sure we record first line */
4479 if (last
== lineno
) /* skip continuation lines */
4482 lt
->item
[lt
->nitems
].line
= lineno
;
4483 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
4487 /* Sorting and reordering procedures */
4489 /* Blocks with a smaller low bound should come first */
4492 compare_blocks (const void *arg1
, const void *arg2
)
4495 struct block
**b1
= (struct block
**) arg1
;
4496 struct block
**b2
= (struct block
**) arg2
;
4498 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
4500 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
4504 /* Sort the blocks of a symtab S.
4505 Reorder the blocks in the blockvector by code-address,
4506 as required by some MI search routines */
4509 sort_blocks (struct symtab
*s
)
4511 struct blockvector
*bv
= BLOCKVECTOR (s
);
4513 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
4516 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
4517 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
4518 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
4519 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
4523 * This is very unfortunate: normally all functions are compiled in
4524 * the order they are found, but if the file is compiled -O3 things
4525 * are very different. It would be nice to find a reliable test
4526 * to detect -O3 images in advance.
4528 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
4529 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
4530 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
4531 sizeof (struct block
*),
4536 int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
4538 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
4539 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
4540 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
4541 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
4544 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
4545 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
4547 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4548 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4549 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4550 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4554 /* Constructor/restructor/destructor procedures */
4556 /* Allocate a new symtab for NAME. Needs an estimate of how many
4557 linenumbers MAXLINES we'll put in it */
4559 static struct symtab
*
4560 new_symtab (char *name
, int maxlines
, struct objfile
*objfile
)
4562 struct symtab
*s
= allocate_symtab (name
, objfile
);
4564 LINETABLE (s
) = new_linetable (maxlines
);
4566 /* All symtabs must have at least two blocks */
4567 BLOCKVECTOR (s
) = new_bvect (2);
4568 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
)
4569 = new_block (NON_FUNCTION_BLOCK
);
4570 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
4571 = new_block (NON_FUNCTION_BLOCK
);
4572 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
4573 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4575 s
->free_code
= free_linetable
;
4576 s
->debugformat
= obsavestring ("ECOFF", 5,
4577 &objfile
->objfile_obstack
);
4581 /* Allocate a new partial_symtab NAME */
4583 static struct partial_symtab
*
4584 new_psymtab (char *name
, struct objfile
*objfile
)
4586 struct partial_symtab
*psymtab
;
4588 psymtab
= allocate_psymtab (name
, objfile
);
4589 psymtab
->section_offsets
= objfile
->section_offsets
;
4591 /* Keep a backpointer to the file's symbols */
4593 psymtab
->read_symtab_private
= ((char *)
4594 obstack_alloc (&objfile
->objfile_obstack
,
4595 sizeof (struct symloc
)));
4596 memset (psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
4597 CUR_BFD (psymtab
) = cur_bfd
;
4598 DEBUG_SWAP (psymtab
) = debug_swap
;
4599 DEBUG_INFO (psymtab
) = debug_info
;
4600 PENDING_LIST (psymtab
) = pending_list
;
4602 /* The way to turn this into a symtab is to call... */
4603 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
4608 /* Allocate a linetable array of the given SIZE. Since the struct
4609 already includes one item, we subtract one when calculating the
4610 proper size to allocate. */
4612 static struct linetable
*
4613 new_linetable (int size
)
4615 struct linetable
*l
;
4617 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
4618 l
= (struct linetable
*) xmalloc (size
);
4623 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4624 I am not so sure about the 3.4 ones.
4626 Since the struct linetable already includes one item, we subtract one when
4627 calculating the proper size to allocate. */
4629 static struct linetable
*
4630 shrink_linetable (struct linetable
*lt
)
4633 return (struct linetable
*) xrealloc ((void *) lt
,
4634 (sizeof (struct linetable
)
4636 * sizeof (lt
->item
))));
4639 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4641 static struct blockvector
*
4642 new_bvect (int nblocks
)
4644 struct blockvector
*bv
;
4647 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4648 bv
= (struct blockvector
*) xzalloc (size
);
4650 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4655 /* Allocate and zero a new block, and set its BLOCK_DICT. If function
4656 is non-zero, assume the block is associated to a function, and make
4657 sure that the symbols are stored linearly; otherwise, store them
4660 static struct block
*
4661 new_block (enum block_type type
)
4663 /* FIXME: carlton/2003-09-11: This should use allocate_block to
4664 allocate the block. Which, in turn, suggests that the block
4665 should be allocated on an obstack. */
4666 struct block
*retval
= xzalloc (sizeof (struct block
));
4668 if (type
== FUNCTION_BLOCK
)
4669 BLOCK_DICT (retval
) = dict_create_linear_expandable ();
4671 BLOCK_DICT (retval
) = dict_create_hashed_expandable ();
4676 /* Create a new symbol with printname NAME */
4678 static struct symbol
*
4679 new_symbol (char *name
)
4681 struct symbol
*s
= ((struct symbol
*)
4682 obstack_alloc (¤t_objfile
->objfile_obstack
,
4683 sizeof (struct symbol
)));
4685 memset (s
, 0, sizeof (*s
));
4686 SYMBOL_LANGUAGE (s
) = psymtab_language
;
4687 SYMBOL_SET_NAMES (s
, name
, strlen (name
), current_objfile
);
4691 /* Create a new type with printname NAME */
4693 static struct type
*
4694 new_type (char *name
)
4698 t
= alloc_type (current_objfile
);
4699 TYPE_NAME (t
) = name
;
4700 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
4704 /* Read ECOFF debugging information from a BFD section. This is
4705 called from elfread.c. It parses the section into a
4706 ecoff_debug_info struct, and then lets the rest of the file handle
4710 elfmdebug_build_psymtabs (struct objfile
*objfile
,
4711 const struct ecoff_debug_swap
*swap
, asection
*sec
)
4713 bfd
*abfd
= objfile
->obfd
;
4714 struct ecoff_debug_info
*info
;
4715 struct cleanup
*back_to
;
4717 /* FIXME: It's not clear whether we should be getting minimal symbol
4718 information from .mdebug in an ELF file, or whether we will.
4719 Re-initialize the minimal symbol reader in case we do. */
4721 init_minimal_symbol_collection ();
4722 back_to
= make_cleanup_discard_minimal_symbols ();
4724 info
= ((struct ecoff_debug_info
*)
4725 obstack_alloc (&objfile
->objfile_obstack
,
4726 sizeof (struct ecoff_debug_info
)));
4728 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4729 error ("Error reading ECOFF debugging information: %s",
4730 bfd_errmsg (bfd_get_error ()));
4732 mdebug_build_psymtabs (objfile
, swap
, info
);
4734 install_minimal_symbols (objfile
);
4735 do_cleanups (back_to
);
4739 _initialize_mdebugread (void)
4742 init_type (TYPE_CODE_VOID
, 1,
4744 "void", (struct objfile
*) NULL
);
4746 init_type (TYPE_CODE_INT
, 1,
4748 "char", (struct objfile
*) NULL
);
4749 mdebug_type_unsigned_char
=
4750 init_type (TYPE_CODE_INT
, 1,
4752 "unsigned char", (struct objfile
*) NULL
);
4754 init_type (TYPE_CODE_INT
, 2,
4756 "short", (struct objfile
*) NULL
);
4757 mdebug_type_unsigned_short
=
4758 init_type (TYPE_CODE_INT
, 2,
4760 "unsigned short", (struct objfile
*) NULL
);
4761 mdebug_type_int_32
=
4762 init_type (TYPE_CODE_INT
, 4,
4764 "int", (struct objfile
*) NULL
);
4765 mdebug_type_unsigned_int_32
=
4766 init_type (TYPE_CODE_INT
, 4,
4768 "unsigned int", (struct objfile
*) NULL
);
4769 mdebug_type_int_64
=
4770 init_type (TYPE_CODE_INT
, 8,
4772 "int", (struct objfile
*) NULL
);
4773 mdebug_type_unsigned_int_64
=
4774 init_type (TYPE_CODE_INT
, 8,
4776 "unsigned int", (struct objfile
*) NULL
);
4777 mdebug_type_long_32
=
4778 init_type (TYPE_CODE_INT
, 4,
4780 "long", (struct objfile
*) NULL
);
4781 mdebug_type_unsigned_long_32
=
4782 init_type (TYPE_CODE_INT
, 4,
4784 "unsigned long", (struct objfile
*) NULL
);
4785 mdebug_type_long_64
=
4786 init_type (TYPE_CODE_INT
, 8,
4788 "long", (struct objfile
*) NULL
);
4789 mdebug_type_unsigned_long_64
=
4790 init_type (TYPE_CODE_INT
, 8,
4792 "unsigned long", (struct objfile
*) NULL
);
4793 mdebug_type_long_long_64
=
4794 init_type (TYPE_CODE_INT
, 8,
4796 "long long", (struct objfile
*) NULL
);
4797 mdebug_type_unsigned_long_long_64
=
4798 init_type (TYPE_CODE_INT
, 8,
4800 "unsigned long long", (struct objfile
*) NULL
);
4801 mdebug_type_adr_32
=
4802 init_type (TYPE_CODE_PTR
, 4,
4804 "adr_32", (struct objfile
*) NULL
);
4805 TYPE_TARGET_TYPE (mdebug_type_adr_32
) = mdebug_type_void
;
4806 mdebug_type_adr_64
=
4807 init_type (TYPE_CODE_PTR
, 8,
4809 "adr_64", (struct objfile
*) NULL
);
4810 TYPE_TARGET_TYPE (mdebug_type_adr_64
) = mdebug_type_void
;
4812 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4814 "float", (struct objfile
*) NULL
);
4815 mdebug_type_double
=
4816 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4818 "double", (struct objfile
*) NULL
);
4819 mdebug_type_complex
=
4820 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4822 "complex", (struct objfile
*) NULL
);
4823 TYPE_TARGET_TYPE (mdebug_type_complex
) = mdebug_type_float
;
4824 mdebug_type_double_complex
=
4825 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4827 "double complex", (struct objfile
*) NULL
);
4828 TYPE_TARGET_TYPE (mdebug_type_double_complex
) = mdebug_type_double
;
4830 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4832 mdebug_type_string
=
4833 init_type (TYPE_CODE_STRING
,
4834 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4836 (struct objfile
*) NULL
);
4838 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4839 good? Would we be better off with TYPE_CODE_ERROR? Should
4840 TYPE_CODE_ERROR print things in hex if it knows the size? */
4841 mdebug_type_fixed_dec
=
4842 init_type (TYPE_CODE_INT
,
4843 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4845 (struct objfile
*) NULL
);
4847 mdebug_type_float_dec
=
4848 init_type (TYPE_CODE_ERROR
,
4849 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4850 0, "floating decimal",
4851 (struct objfile
*) NULL
);
4853 nodebug_func_symbol_type
= init_type (TYPE_CODE_FUNC
, 1, 0,
4854 "<function, no debug info>", NULL
);
4855 TYPE_TARGET_TYPE (nodebug_func_symbol_type
) = mdebug_type_int
;
4856 nodebug_var_symbol_type
=
4857 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4858 "<variable, no debug info>", NULL
);