1 /* Read a symbol table in ECOFF format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
3 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 Free Software Foundation, Inc.
5 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
6 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
26 /* This module provides the function mdebug_build_psymtabs. It reads
27 ECOFF debugging information into partial symbol tables. The
28 debugging information is read from two structures. A struct
29 ecoff_debug_swap includes the sizes of each ECOFF structure and
30 swapping routines; these are fixed for a particular target. A
31 struct ecoff_debug_info points to the debugging information for a
32 particular object file.
34 ECOFF symbol tables are mostly written in the byte order of the
35 target machine. However, one section of the table (the auxiliary
36 symbol information) is written in the host byte order. There is a
37 bit in the other symbol info which describes which host byte order
38 was used. ECOFF thereby takes the trophy from Intel `b.out' for
39 the most brain-dead adaptation of a file format to byte order.
41 This module can read all four of the known byte-order combinations,
42 on any type of host. */
50 #include "gdb_obstack.h"
52 #include "stabsread.h"
53 #include "complaints.h"
55 #include "gdb_assert.h"
57 #include "dictionary.h"
59 /* These are needed if the tm.h file does not contain the necessary
60 mips specific definitions. */
62 #ifndef MIPS_EFI_SYMBOL_NAME
63 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
64 extern void ecoff_relocate_efi (struct symbol
*, CORE_ADDR
);
66 #include "coff/symconst.h"
67 typedef struct mips_extra_func_info
72 *mips_extra_func_info_t
;
79 #include <sys/types.h>
83 #include "gdb_string.h"
87 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
89 #include "libaout.h" /* Private BFD a.out information. */
90 #include "aout/aout64.h"
91 #include "aout/stab_gnu.h" /* STABS information */
93 #include "expression.h"
94 #include "language.h" /* For local_hex_string() */
96 extern void _initialize_mdebugread (void);
98 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
99 We use this define in order to know whether we should override a
100 symbol's ECOFF section with its ELF section. This is necessary in
101 case the symbol's ELF section could not be represented in ECOFF. */
102 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
103 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
106 /* We put a pointer to this structure in the read_symtab_private field
111 /* Index of the FDR that this psymtab represents. */
113 /* The BFD that the psymtab was created from. */
115 const struct ecoff_debug_swap
*debug_swap
;
116 struct ecoff_debug_info
*debug_info
;
117 struct mdebug_pending
**pending_list
;
118 /* Pointer to external symbols for this file. */
120 /* Size of extern_tab. */
122 enum language pst_language
;
125 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
126 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
127 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
128 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
129 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
130 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
132 #define SC_IS_TEXT(sc) ((sc) == scText \
133 || (sc) == scRConst \
136 #define SC_IS_DATA(sc) ((sc) == scData \
141 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
142 #define SC_IS_BSS(sc) ((sc) == scBss)
143 #define SC_IS_SBSS(sc) ((sc) == scSBss)
144 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
146 /* Various complaints about symbol reading that don't abort the process */
148 index_complaint (const char *arg1
)
150 complaint (&symfile_complaints
, "bad aux index at symbol %s", arg1
);
154 unknown_ext_complaint (const char *arg1
)
156 complaint (&symfile_complaints
, "unknown external symbol %s", arg1
);
160 basic_type_complaint (int arg1
, const char *arg2
)
162 complaint (&symfile_complaints
, "cannot map ECOFF basic type 0x%x for %s",
167 bad_tag_guess_complaint (const char *arg1
)
169 complaint (&symfile_complaints
, "guessed tag type of %s incorrectly", arg1
);
173 bad_rfd_entry_complaint (const char *arg1
, int arg2
, int arg3
)
175 complaint (&symfile_complaints
, "bad rfd entry for %s: file %d, index %d",
180 unexpected_type_code_complaint (const char *arg1
)
182 complaint (&symfile_complaints
, "unexpected type code for %s", arg1
);
185 /* Macros and extra defs */
187 /* Puns: hard to find whether -g was used and how */
189 #define MIN_GLEVEL GLEVEL_0
190 #define compare_glevel(a,b) \
191 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
192 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
194 /* Things that really are local to this module */
196 /* Remember what we deduced to be the source language of this psymtab. */
198 static enum language psymtab_language
= language_unknown
;
204 /* How to parse debugging information for CUR_BFD. */
206 static const struct ecoff_debug_swap
*debug_swap
;
208 /* Pointers to debugging information for CUR_BFD. */
210 static struct ecoff_debug_info
*debug_info
;
212 /* Pointer to current file decriptor record, and its index */
217 /* Index of current symbol */
221 /* Note how much "debuggable" this image is. We would like
222 to see at least one FDR with full symbols */
224 static int max_gdbinfo
;
225 static int max_glevel
;
227 /* When examining .o files, report on undefined symbols */
229 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
231 /* Pseudo symbol to use when putting stabs into the symbol table. */
233 static char stabs_symbol
[] = STABS_SYMBOL
;
235 /* Types corresponding to mdebug format bt* basic types. */
237 static struct type
*mdebug_type_void
;
238 static struct type
*mdebug_type_char
;
239 static struct type
*mdebug_type_short
;
240 static struct type
*mdebug_type_int_32
;
241 #define mdebug_type_int mdebug_type_int_32
242 static struct type
*mdebug_type_int_64
;
243 static struct type
*mdebug_type_long_32
;
244 static struct type
*mdebug_type_long_64
;
245 static struct type
*mdebug_type_long_long_64
;
246 static struct type
*mdebug_type_unsigned_char
;
247 static struct type
*mdebug_type_unsigned_short
;
248 static struct type
*mdebug_type_unsigned_int_32
;
249 static struct type
*mdebug_type_unsigned_int_64
;
250 static struct type
*mdebug_type_unsigned_long_32
;
251 static struct type
*mdebug_type_unsigned_long_64
;
252 static struct type
*mdebug_type_unsigned_long_long_64
;
253 static struct type
*mdebug_type_adr_32
;
254 static struct type
*mdebug_type_adr_64
;
255 static struct type
*mdebug_type_float
;
256 static struct type
*mdebug_type_double
;
257 static struct type
*mdebug_type_complex
;
258 static struct type
*mdebug_type_double_complex
;
259 static struct type
*mdebug_type_fixed_dec
;
260 static struct type
*mdebug_type_float_dec
;
261 static struct type
*mdebug_type_string
;
263 /* Types for symbols from files compiled without debugging info. */
265 static struct type
*nodebug_func_symbol_type
;
266 static struct type
*nodebug_var_symbol_type
;
268 /* Nonzero if we have seen ecoff debugging info for a file. */
270 static int found_ecoff_debugging_info
;
272 /* Forward declarations */
274 static int upgrade_type (int, struct type
**, int, union aux_ext
*,
277 static void parse_partial_symbols (struct objfile
*);
279 static int has_opaque_xref (FDR
*, SYMR
*);
281 static int cross_ref (int, union aux_ext
*, struct type
**, enum type_code
,
282 char **, int, char *);
284 static struct symbol
*new_symbol (char *);
286 static struct type
*new_type (char *);
288 enum block_type
{ FUNCTION_BLOCK
, NON_FUNCTION_BLOCK
};
290 static struct block
*new_block (enum block_type
);
292 static struct symtab
*new_symtab (char *, int, struct objfile
*);
294 static struct linetable
*new_linetable (int);
296 static struct blockvector
*new_bvect (int);
298 static struct type
*parse_type (int, union aux_ext
*, unsigned int, int *,
301 static struct symbol
*mylookup_symbol (char *, struct block
*, domain_enum
,
304 static void sort_blocks (struct symtab
*);
306 static struct partial_symtab
*new_psymtab (char *, struct objfile
*);
308 static void psymtab_to_symtab_1 (struct partial_symtab
*, char *);
310 static void add_block (struct block
*, struct symtab
*);
312 static void add_symbol (struct symbol
*, struct block
*);
314 static int add_line (struct linetable
*, int, CORE_ADDR
, int);
316 static struct linetable
*shrink_linetable (struct linetable
*);
318 static void handle_psymbol_enumerators (struct objfile
*, FDR
*, int,
321 static char *mdebug_next_symbol_text (struct objfile
*);
323 /* Address bounds for the signal trampoline in inferior, if any */
325 CORE_ADDR sigtramp_address
, sigtramp_end
;
327 /* Allocate zeroed memory */
330 xzalloc (unsigned int size
)
332 void *p
= xmalloc (size
);
338 /* Exported procedure: Builds a symtab from the PST partial one.
339 Restores the environment in effect when PST was created, delegates
340 most of the work to an ancillary procedure, and sorts
341 and reorders the symtab list at the end */
344 mdebug_psymtab_to_symtab (struct partial_symtab
*pst
)
352 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
353 gdb_flush (gdb_stdout
);
356 next_symbol_text_func
= mdebug_next_symbol_text
;
358 psymtab_to_symtab_1 (pst
, pst
->filename
);
360 /* Match with global symbols. This only needs to be done once,
361 after all of the symtabs and dependencies have been read in. */
362 scan_file_globals (pst
->objfile
);
365 printf_filtered ("done.\n");
368 /* File-level interface functions */
370 /* Find a file descriptor given its index RF relative to a file CF */
373 get_rfd (int cf
, int rf
)
379 fdrs
= debug_info
->fdr
;
381 /* Object files do not have the RFD table, all refs are absolute */
384 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
385 ((char *) debug_info
->external_rfd
387 * debug_swap
->external_rfd_size
)),
392 /* Return a safer print NAME for a file descriptor */
398 return "<stripped file>";
401 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
405 /* Read in and parse the symtab of the file OBJFILE. Symbols from
406 different sections are relocated via the SECTION_OFFSETS. */
409 mdebug_build_psymtabs (struct objfile
*objfile
,
410 const struct ecoff_debug_swap
*swap
,
411 struct ecoff_debug_info
*info
)
413 cur_bfd
= objfile
->obfd
;
417 stabsread_new_init ();
418 buildsym_new_init ();
419 free_header_files ();
420 init_header_files ();
422 /* Make sure all the FDR information is swapped in. */
423 if (info
->fdr
== (FDR
*) NULL
)
429 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->psymbol_obstack
,
430 (info
->symbolic_header
.ifdMax
432 fdr_src
= info
->external_fdr
;
434 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
436 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
437 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
440 parse_partial_symbols (objfile
);
443 /* Check to make sure file was compiled with -g. If not, warn the
444 user of this limitation. */
445 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
447 if (max_gdbinfo
== 0)
448 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
450 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
451 gdb_flush (gdb_stdout
);
456 /* Local utilities */
458 /* Map of FDR indexes to partial symtabs */
462 struct partial_symtab
*pst
; /* the psymtab proper */
463 long n_globals
; /* exported globals (external symbols) */
464 long globals_offset
; /* cumulative */
468 /* Utility stack, used to nest procedures and blocks properly.
469 It is a doubly linked list, to avoid too many alloc/free.
470 Since we might need it quite a few times it is NOT deallocated
473 static struct parse_stack
475 struct parse_stack
*next
, *prev
;
476 struct symtab
*cur_st
; /* Current symtab. */
477 struct block
*cur_block
; /* Block in it. */
479 /* What are we parsing. stFile, or stBlock are for files and
480 blocks. stProc or stStaticProc means we have seen the start of a
481 procedure, but not the start of the block within in. When we see
482 the start of that block, we change it to stNil, without pushing a
483 new block, i.e. stNil means both a procedure and a block. */
487 struct type
*cur_type
; /* Type we parse fields for. */
488 int cur_field
; /* Field number in cur_type. */
489 CORE_ADDR procadr
; /* Start addres of this procedure */
490 int numargs
; /* Its argument count */
493 *top_stack
; /* Top stack ptr */
496 /* Enter a new lexical context */
499 push_parse_stack (void)
501 struct parse_stack
*new;
503 /* Reuse frames if possible */
504 if (top_stack
&& top_stack
->prev
)
505 new = top_stack
->prev
;
507 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
508 /* Initialize new frame with previous content */
511 struct parse_stack
*prev
= new->prev
;
514 top_stack
->prev
= new;
516 new->next
= top_stack
;
521 /* Exit a lexical context */
524 pop_parse_stack (void)
529 top_stack
= top_stack
->next
;
533 /* Cross-references might be to things we haven't looked at
534 yet, e.g. type references. To avoid too many type
535 duplications we keep a quick fixup table, an array
536 of lists of references indexed by file descriptor */
538 struct mdebug_pending
540 struct mdebug_pending
*next
; /* link */
541 char *s
; /* the unswapped symbol */
542 struct type
*t
; /* its partial type descriptor */
546 /* The pending information is kept for an entire object file, and used
547 to be in the sym_private field. I took it out when I split
548 mdebugread from mipsread, because this might not be the only type
549 of symbols read from an object file. Instead, we allocate the
550 pending information table when we create the partial symbols, and
551 we store a pointer to the single table in each psymtab. */
553 static struct mdebug_pending
**pending_list
;
555 /* Check whether we already saw symbol SH in file FH */
557 static struct mdebug_pending
*
558 is_pending_symbol (FDR
*fh
, char *sh
)
560 int f_idx
= fh
- debug_info
->fdr
;
561 struct mdebug_pending
*p
;
563 /* Linear search is ok, list is typically no more than 10 deep */
564 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
570 /* Add a new symbol SH of type T */
573 add_pending (FDR
*fh
, char *sh
, struct type
*t
)
575 int f_idx
= fh
- debug_info
->fdr
;
576 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
578 /* Make sure we do not make duplicates */
581 p
= ((struct mdebug_pending
*)
582 obstack_alloc (¤t_objfile
->psymbol_obstack
,
583 sizeof (struct mdebug_pending
)));
586 p
->next
= pending_list
[f_idx
];
587 pending_list
[f_idx
] = p
;
592 /* Parsing Routines proper. */
594 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
595 For blocks, procedures and types we open a new lexical context.
596 This is basically just a big switch on the symbol's type. Argument
597 AX is the base pointer of aux symbols for this file (fh->iauxBase).
598 EXT_SH points to the unswapped symbol, which is needed for struct,
599 union, etc., types; it is NULL for an EXTR. BIGEND says whether
600 aux symbols are big-endian or little-endian. Return count of
601 SYMR's handled (normally one). */
604 parse_symbol (SYMR
*sh
, union aux_ext
*ax
, char *ext_sh
, int bigend
,
605 struct section_offsets
*section_offsets
, struct objfile
*objfile
)
607 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
608 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
612 struct mdebug_pending
*pend
;
616 enum address_class
class;
618 long svalue
= sh
->value
;
621 if (ext_sh
== (char *) NULL
)
622 name
= debug_info
->ssext
+ sh
->iss
;
624 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
630 /* Do not relocate relative values.
631 The value of a stEnd symbol is the displacement from the
632 corresponding start symbol value.
633 The value of a stBlock symbol is the displacement from the
634 procedure address. */
635 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
636 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
643 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
647 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS (objfile
));
656 case stGlobal
: /* external symbol, goes into global block */
658 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
660 s
= new_symbol (name
);
661 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
664 case stStatic
: /* static data, goes into current block. */
666 b
= top_stack
->cur_block
;
667 s
= new_symbol (name
);
668 if (SC_IS_COMMON (sh
->sc
))
670 /* It is a FORTRAN common block. At least for SGI Fortran the
671 address is not in the symbol; we need to fix it later in
672 scan_file_globals. */
673 int bucket
= hashname (DEPRECATED_SYMBOL_NAME (s
));
674 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
675 global_sym_chain
[bucket
] = s
;
678 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
681 case stLocal
: /* local variable, goes into current block */
682 if (sh
->sc
== scRegister
)
684 class = LOC_REGISTER
;
685 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
689 b
= top_stack
->cur_block
;
690 s
= new_symbol (name
);
691 SYMBOL_VALUE (s
) = svalue
;
693 data
: /* Common code for symbols describing data */
694 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
695 SYMBOL_CLASS (s
) = class;
698 /* Type could be missing if file is compiled without debugging info. */
699 if (SC_IS_UNDEF (sh
->sc
)
700 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
701 SYMBOL_TYPE (s
) = nodebug_var_symbol_type
;
703 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
704 /* Value of a data symbol is its memory address */
707 case stParam
: /* arg to procedure, goes into current block */
709 found_ecoff_debugging_info
= 1;
710 top_stack
->numargs
++;
712 /* Special GNU C++ name. */
713 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
714 name
= "this"; /* FIXME, not alloc'd in obstack */
715 s
= new_symbol (name
);
717 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
721 /* Pass by value in register. */
722 SYMBOL_CLASS (s
) = LOC_REGPARM
;
723 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
726 /* Pass by reference on stack. */
727 SYMBOL_CLASS (s
) = LOC_REF_ARG
;
730 /* Pass by reference in register. */
731 SYMBOL_CLASS (s
) = LOC_REGPARM_ADDR
;
732 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
735 /* Pass by value on stack. */
736 SYMBOL_CLASS (s
) = LOC_ARG
;
739 SYMBOL_VALUE (s
) = svalue
;
740 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
741 add_symbol (s
, top_stack
->cur_block
);
744 case stLabel
: /* label, goes into current block */
745 s
= new_symbol (name
);
746 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
; /* so that it can be used */
747 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
748 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
749 SYMBOL_TYPE (s
) = mdebug_type_int
;
750 add_symbol (s
, top_stack
->cur_block
);
753 case stProc
: /* Procedure, usually goes into global block */
754 case stStaticProc
: /* Static procedure, goes into current block */
755 /* For stProc symbol records, we need to check the storage class
756 as well, as only (stProc, scText) entries represent "real"
757 procedures - See the Compaq document titled "Object File /
758 Symbol Table Format Specification" for more information.
759 If the storage class is not scText, we discard the whole block
760 of symbol records for this stProc. */
761 if (sh
->st
== stProc
&& sh
->sc
!= scText
)
763 char *ext_tsym
= ext_sh
;
764 int keep_counting
= 1;
767 while (keep_counting
)
769 ext_tsym
+= external_sym_size
;
770 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
780 complaint (&symfile_complaints
,
781 "unknown symbol type 0x%x", sh
->st
);
787 s
= new_symbol (name
);
788 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
789 SYMBOL_CLASS (s
) = LOC_BLOCK
;
790 /* Type of the return value */
791 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
795 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
796 if (STREQ (name
, "malloc") && TYPE_CODE (t
) == TYPE_CODE_VOID
)
798 /* I don't know why, but, at least under Alpha GNU/Linux,
799 when linking against a malloc without debugging
800 symbols, its read as a function returning void---this
801 is bad because it means we cannot call functions with
802 string arguments interactively; i.e., "call
803 printf("howdy\n")" would fail with the error message
804 "program has no memory available". To avoid this, we
805 patch up the type and make it void*
806 instead. (davidm@azstarnet.com)
808 t
= make_pointer_type (t
, NULL
);
811 b
= top_stack
->cur_block
;
812 if (sh
->st
== stProc
)
814 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
815 /* The next test should normally be true, but provides a
816 hook for nested functions (which we don't want to make
818 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
819 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
820 /* Irix 5 sometimes has duplicate names for the same
821 function. We want to add such names up at the global
822 level, not as a nested function. */
823 else if (sh
->value
== top_stack
->procadr
)
824 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
828 /* Make a type for the procedure itself */
829 SYMBOL_TYPE (s
) = lookup_function_type (t
);
831 /* All functions in C++ have prototypes. For C we don't have enough
832 information in the debug info. */
833 if (SYMBOL_LANGUAGE (s
) == language_cplus
)
834 TYPE_FLAGS (SYMBOL_TYPE (s
)) |= TYPE_FLAG_PROTOTYPED
;
836 /* Create and enter a new lexical context */
837 b
= new_block (FUNCTION_BLOCK
);
838 SYMBOL_BLOCK_VALUE (s
) = b
;
839 BLOCK_FUNCTION (b
) = s
;
840 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
841 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
842 add_block (b
, top_stack
->cur_st
);
844 /* Not if we only have partial info */
845 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
849 top_stack
->cur_block
= b
;
850 top_stack
->blocktype
= sh
->st
;
851 top_stack
->cur_type
= SYMBOL_TYPE (s
);
852 top_stack
->cur_field
= -1;
853 top_stack
->procadr
= sh
->value
;
854 top_stack
->numargs
= 0;
857 /* Beginning of code for structure, union, and enum definitions.
858 They all share a common set of local variables, defined here. */
860 enum type_code type_code
;
866 case stStruct
: /* Start a block defining a struct type */
867 type_code
= TYPE_CODE_STRUCT
;
868 goto structured_common
;
870 case stUnion
: /* Start a block defining a union type */
871 type_code
= TYPE_CODE_UNION
;
872 goto structured_common
;
874 case stEnum
: /* Start a block defining an enum type */
875 type_code
= TYPE_CODE_ENUM
;
876 goto structured_common
;
878 case stBlock
: /* Either a lexical block, or some type */
879 if (sh
->sc
!= scInfo
&& !SC_IS_COMMON (sh
->sc
))
880 goto case_stBlock_code
; /* Lexical block */
882 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
884 /* Common code for handling struct, union, enum, and/or as-yet-
885 unknown-type blocks of info about structured data. `type_code'
886 has been set to the proper TYPE_CODE, if we know it. */
888 found_ecoff_debugging_info
= 1;
890 top_stack
->blocktype
= stBlock
;
892 /* First count the number of fields and the highest value. */
895 for (ext_tsym
= ext_sh
+ external_sym_size
;
897 ext_tsym
+= external_sym_size
)
901 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
906 /* C++ encodes class types as structures where there the
907 methods are encoded as stProc. The scope of stProc
908 symbols also ends with stEnd, thus creating a risk of
909 taking the wrong stEnd symbol record as the end of
910 the current struct, which would cause GDB to undercount
911 the real number of fields in this struct. To make sure
912 we really reached the right stEnd symbol record, we
913 check the associated name, and match it against the
914 struct name. Since method names are mangled while
915 the class name is not, there is no risk of having a
916 method whose name is identical to the class name
917 (in particular constructor method names are different
918 from the class name). There is therefore no risk that
919 this check stops the count on the StEnd of a method.
921 Also, assume that we're really at the end when tsym.iss
923 if (tsym
.iss
== issNull
924 || strcmp (debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
,
930 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
932 /* If the type of the member is Nil (or Void),
933 without qualifiers, assume the tag is an
935 Alpha cc -migrate enums are recognized by a zero
936 index and a zero symbol value.
937 DU 4.0 cc enums are recognized by a member type of
938 btEnum without qualifiers and a zero symbol value. */
939 if (tsym
.index
== indexNil
940 || (tsym
.index
== 0 && sh
->value
== 0))
941 type_code
= TYPE_CODE_ENUM
;
944 (*debug_swap
->swap_tir_in
) (bigend
,
945 &ax
[tsym
.index
].a_ti
,
947 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
948 || (tir
.bt
== btEnum
&& sh
->value
== 0))
950 type_code
= TYPE_CODE_ENUM
;
954 if (tsym
.value
> max_value
)
955 max_value
= tsym
.value
;
964 /* This is a no-op; is it trying to tell us something
965 we should be checking? */
966 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED */
970 /* This is something like a struct within a
971 struct. Skip over the fields of the inner
972 struct. The -1 is because the for loop will
973 increment ext_tsym. */
974 ext_tsym
= ((char *) debug_info
->external_sym
975 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
976 * external_sym_size
));
982 /* mips cc puts out a typedef for struct x if it is not yet
983 defined when it encounters
984 struct y { struct x *xp; };
989 /* Irix5 cc puts out a stIndirect for struct x if it is not
990 yet defined when it encounters
991 struct y { struct x *xp; };
996 complaint (&symfile_complaints
,
997 "declaration block contains unhandled symbol type %d",
1003 /* In an stBlock, there is no way to distinguish structs,
1004 unions, and enums at this point. This is a bug in the
1005 original design (that has been fixed with the recent
1006 addition of the stStruct, stUnion, and stEnum symbol
1007 types.) The way you can tell is if/when you see a variable
1008 or field of that type. In that case the variable's type
1009 (in the AUX table) says if the type is struct, union, or
1010 enum, and points back to the stBlock here. So you can
1011 patch the tag kind up later - but only if there actually is
1012 a variable or field of that type.
1014 So until we know for sure, we will guess at this point.
1016 If the first member has index==indexNil or a void type,
1017 assume we have an enumeration.
1018 Otherwise, if there is more than one member, and all
1019 the members have offset 0, assume we have a union.
1020 Otherwise, assume we have a struct.
1022 The heuristic could guess wrong in the case of of an
1023 enumeration with no members or a union with one (or zero)
1024 members, or when all except the last field of a struct have
1025 width zero. These are uncommon and/or illegal situations,
1026 and in any case guessing wrong probably doesn't matter
1029 But if we later do find out we were wrong, we fixup the tag
1030 kind. Members of an enumeration must be handled
1031 differently from struct/union fields, and that is harder to
1032 patch up, but luckily we shouldn't need to. (If there are
1033 any enumeration members, we can tell for sure it's an enum
1036 if (type_code
== TYPE_CODE_UNDEF
)
1038 if (nfields
> 1 && max_value
== 0)
1039 type_code
= TYPE_CODE_UNION
;
1041 type_code
= TYPE_CODE_STRUCT
;
1044 /* Create a new type or use the pending type. */
1045 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1046 if (pend
== (struct mdebug_pending
*) NULL
)
1048 t
= new_type (NULL
);
1049 add_pending (cur_fdr
, ext_sh
, t
);
1054 /* Do not set the tag name if it is a compiler generated tag name
1055 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1056 Alpha cc puts out an sh->iss of zero for those. */
1057 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1058 TYPE_TAG_NAME (t
) = NULL
;
1060 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1063 TYPE_CODE (t
) = type_code
;
1064 TYPE_LENGTH (t
) = sh
->value
;
1065 TYPE_NFIELDS (t
) = nfields
;
1066 TYPE_FIELDS (t
) = f
= ((struct field
*)
1068 nfields
* sizeof (struct field
)));
1070 if (type_code
== TYPE_CODE_ENUM
)
1072 int unsigned_enum
= 1;
1074 /* This is a non-empty enum. */
1076 /* DEC c89 has the number of enumerators in the sh.value field,
1077 not the type length, so we have to compensate for that
1078 incompatibility quirk.
1079 This might do the wrong thing for an enum with one or two
1080 enumerators and gcc -gcoff -fshort-enums, but these cases
1081 are hopefully rare enough.
1082 Alpha cc -migrate has a sh.value field of zero, we adjust
1084 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
)
1085 || TYPE_LENGTH (t
) == 0)
1086 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1087 for (ext_tsym
= ext_sh
+ external_sym_size
;
1089 ext_tsym
+= external_sym_size
)
1092 struct symbol
*enum_sym
;
1094 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1096 if (tsym
.st
!= stMember
)
1099 FIELD_BITPOS (*f
) = tsym
.value
;
1100 FIELD_TYPE (*f
) = t
;
1101 FIELD_NAME (*f
) = debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1102 FIELD_BITSIZE (*f
) = 0;
1103 FIELD_STATIC_KIND (*f
) = 0;
1105 enum_sym
= ((struct symbol
*)
1106 obstack_alloc (¤t_objfile
->symbol_obstack
,
1107 sizeof (struct symbol
)));
1108 memset (enum_sym
, 0, sizeof (struct symbol
));
1109 DEPRECATED_SYMBOL_NAME (enum_sym
) =
1110 obsavestring (f
->name
, strlen (f
->name
),
1111 ¤t_objfile
->symbol_obstack
);
1112 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1113 SYMBOL_TYPE (enum_sym
) = t
;
1114 SYMBOL_DOMAIN (enum_sym
) = VAR_DOMAIN
;
1115 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1116 if (SYMBOL_VALUE (enum_sym
) < 0)
1118 add_symbol (enum_sym
, top_stack
->cur_block
);
1120 /* Skip the stMembers that we've handled. */
1125 TYPE_FLAGS (t
) |= TYPE_FLAG_UNSIGNED
;
1127 /* make this the current type */
1128 top_stack
->cur_type
= t
;
1129 top_stack
->cur_field
= 0;
1131 /* Do not create a symbol for alpha cc unnamed structs. */
1135 /* gcc puts out an empty struct for an opaque struct definitions,
1136 do not create a symbol for it either. */
1137 if (TYPE_NFIELDS (t
) == 0)
1139 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1143 s
= new_symbol (name
);
1144 SYMBOL_DOMAIN (s
) = STRUCT_DOMAIN
;
1145 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1146 SYMBOL_VALUE (s
) = 0;
1147 SYMBOL_TYPE (s
) = t
;
1148 add_symbol (s
, top_stack
->cur_block
);
1151 /* End of local variables shared by struct, union, enum, and
1152 block (as yet unknown struct/union/enum) processing. */
1156 found_ecoff_debugging_info
= 1;
1157 /* beginnning of (code) block. Value of symbol
1158 is the displacement from procedure start */
1159 push_parse_stack ();
1161 /* Do not start a new block if this is the outermost block of a
1162 procedure. This allows the LOC_BLOCK symbol to point to the
1163 block with the local variables, so funcname::var works. */
1164 if (top_stack
->blocktype
== stProc
1165 || top_stack
->blocktype
== stStaticProc
)
1167 top_stack
->blocktype
= stNil
;
1171 top_stack
->blocktype
= stBlock
;
1172 b
= new_block (NON_FUNCTION_BLOCK
);
1173 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1174 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1175 top_stack
->cur_block
= b
;
1176 add_block (b
, top_stack
->cur_st
);
1179 case stEnd
: /* end (of anything) */
1180 if (sh
->sc
== scInfo
|| SC_IS_COMMON (sh
->sc
))
1182 /* Finished with type */
1183 top_stack
->cur_type
= 0;
1185 else if (sh
->sc
== scText
&&
1186 (top_stack
->blocktype
== stProc
||
1187 top_stack
->blocktype
== stStaticProc
))
1189 /* Finished with procedure */
1190 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1191 struct mips_extra_func_info
*e
;
1192 struct block
*b
= top_stack
->cur_block
;
1193 struct type
*ftype
= top_stack
->cur_type
;
1196 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1198 /* Make up special symbol to contain procedure specific info */
1199 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1200 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
1201 SYMBOL_CLASS (s
) = LOC_CONST
;
1202 SYMBOL_TYPE (s
) = mdebug_type_void
;
1203 e
= ((struct mips_extra_func_info
*)
1204 obstack_alloc (¤t_objfile
->symbol_obstack
,
1205 sizeof (struct mips_extra_func_info
)));
1206 memset (e
, 0, sizeof (struct mips_extra_func_info
));
1207 SYMBOL_VALUE (s
) = (long) e
;
1208 e
->numargs
= top_stack
->numargs
;
1209 e
->pdr
.framereg
= -1;
1210 add_symbol (s
, top_stack
->cur_block
);
1212 /* f77 emits proc-level with address bounds==[0,0],
1213 So look for such child blocks, and patch them. */
1214 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1216 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1217 if (BLOCK_SUPERBLOCK (b_bad
) == b
1218 && BLOCK_START (b_bad
) == top_stack
->procadr
1219 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1221 BLOCK_START (b_bad
) = BLOCK_START (b
);
1222 BLOCK_END (b_bad
) = BLOCK_END (b
);
1226 if (TYPE_NFIELDS (ftype
) <= 0)
1228 /* No parameter type information is recorded with the function's
1229 type. Set that from the type of the parameter symbols. */
1230 int nparams
= top_stack
->numargs
;
1236 struct dict_iterator iter
;
1237 TYPE_NFIELDS (ftype
) = nparams
;
1238 TYPE_FIELDS (ftype
) = (struct field
*)
1239 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1242 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1244 if (iparams
== nparams
)
1247 switch (SYMBOL_CLASS (sym
))
1252 case LOC_REGPARM_ADDR
:
1253 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1254 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
1264 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1266 /* End of (code) block. The value of the symbol is the
1267 displacement from the procedure`s start address of the
1268 end of this block. */
1269 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1271 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1273 /* End of outermost block. Pop parse stack and ignore. The
1274 following stEnd of stProc will take care of the block. */
1277 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1279 /* End of file. Pop parse stack and ignore. Higher
1280 level code deals with this. */
1284 complaint (&symfile_complaints
,
1285 "stEnd with storage class %d not handled", sh
->sc
);
1287 pop_parse_stack (); /* restore previous lexical context */
1290 case stMember
: /* member of struct or union */
1291 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1292 FIELD_NAME (*f
) = name
;
1293 FIELD_BITPOS (*f
) = sh
->value
;
1295 FIELD_TYPE (*f
) = parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1296 FIELD_BITSIZE (*f
) = bitsize
;
1297 FIELD_STATIC_KIND (*f
) = 0;
1300 case stIndirect
: /* forward declaration on Irix5 */
1301 /* Forward declarations from Irix5 cc are handled by cross_ref,
1305 case stTypedef
: /* type definition */
1306 found_ecoff_debugging_info
= 1;
1308 /* Typedefs for forward declarations and opaque structs from alpha cc
1309 are handled by cross_ref, skip them. */
1313 /* Parse the type or use the pending type. */
1314 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1315 if (pend
== (struct mdebug_pending
*) NULL
)
1317 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *) NULL
, bigend
, name
);
1318 add_pending (cur_fdr
, ext_sh
, t
);
1323 /* mips cc puts out a typedef with the name of the struct for forward
1324 declarations. These should not go into the symbol table and
1325 TYPE_NAME should not be set for them.
1326 They can't be distinguished from an intentional typedef to
1327 the same name however:
1329 struct x { int ix; int jx; };
1333 struct xx {int ixx; int jxx; };
1334 generates a cross referencing stTypedef for x and xx.
1335 The user visible effect of this is that the type of a pointer
1336 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1337 The problem is fixed with alpha cc and Irix5 cc. */
1339 /* However if the typedef cross references to an opaque aggregate, it
1340 is safe to omit it from the symbol table. */
1342 if (has_opaque_xref (cur_fdr
, sh
))
1344 s
= new_symbol (name
);
1345 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1346 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1347 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1348 SYMBOL_TYPE (s
) = t
;
1349 add_symbol (s
, top_stack
->cur_block
);
1351 /* Incomplete definitions of structs should not get a name. */
1352 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1353 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1354 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1355 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1357 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1358 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1360 /* If we are giving a name to a type such as "pointer to
1361 foo" or "function returning foo", we better not set
1362 the TYPE_NAME. If the program contains "typedef char
1363 *caddr_t;", we don't want all variables of type char
1364 * to print as caddr_t. This is not just a
1365 consequence of GDB's type management; CC and GCC (at
1366 least through version 2.4) both output variables of
1367 either type char * or caddr_t with the type
1368 refering to the stTypedef symbol for caddr_t. If a future
1369 compiler cleans this up it GDB is not ready for it
1370 yet, but if it becomes ready we somehow need to
1371 disable this check (without breaking the PCC/GCC2.4
1376 Fortunately, this check seems not to be necessary
1377 for anything except pointers or functions. */
1380 TYPE_NAME (SYMBOL_TYPE (s
)) = DEPRECATED_SYMBOL_NAME (s
);
1384 case stFile
: /* file name */
1385 push_parse_stack ();
1386 top_stack
->blocktype
= sh
->st
;
1389 /* I`ve never seen these for C */
1391 break; /* register relocation */
1393 break; /* forwarding address */
1395 break; /* constant */
1397 complaint (&symfile_complaints
, "unknown symbol type 0x%x", sh
->st
);
1404 /* Parse the type information provided in the raw AX entries for
1405 the symbol SH. Return the bitfield size in BS, in case.
1406 We must byte-swap the AX entries before we use them; BIGEND says whether
1407 they are big-endian or little-endian (from fh->fBigendian). */
1409 static struct type
*
1410 parse_type (int fd
, union aux_ext
*ax
, unsigned int aux_index
, int *bs
,
1411 int bigend
, char *sym_name
)
1413 /* Null entries in this map are treated specially */
1414 static struct type
**map_bt
[] =
1416 &mdebug_type_void
, /* btNil */
1417 &mdebug_type_adr_32
, /* btAdr */
1418 &mdebug_type_char
, /* btChar */
1419 &mdebug_type_unsigned_char
, /* btUChar */
1420 &mdebug_type_short
, /* btShort */
1421 &mdebug_type_unsigned_short
, /* btUShort */
1422 &mdebug_type_int_32
, /* btInt */
1423 &mdebug_type_unsigned_int_32
, /* btUInt */
1424 &mdebug_type_long_32
, /* btLong */
1425 &mdebug_type_unsigned_long_32
, /* btULong */
1426 &mdebug_type_float
, /* btFloat */
1427 &mdebug_type_double
, /* btDouble */
1434 &mdebug_type_complex
, /* btComplex */
1435 &mdebug_type_double_complex
, /* btDComplex */
1437 &mdebug_type_fixed_dec
, /* btFixedDec */
1438 &mdebug_type_float_dec
, /* btFloatDec */
1439 &mdebug_type_string
, /* btString */
1442 &mdebug_type_void
, /* btVoid */
1443 0, /* DEC C++: Pointer to member */
1444 0, /* DEC C++: Virtual function table */
1445 0, /* DEC C++: Class (Record) */
1446 &mdebug_type_long_64
, /* btLong64 */
1447 &mdebug_type_unsigned_long_64
, /* btULong64 */
1448 &mdebug_type_long_long_64
, /* btLongLong64 */
1449 &mdebug_type_unsigned_long_long_64
, /* btULongLong64 */
1450 &mdebug_type_adr_64
, /* btAdr64 */
1451 &mdebug_type_int_64
, /* btInt64 */
1452 &mdebug_type_unsigned_int_64
, /* btUInt64 */
1456 struct type
*tp
= 0;
1457 enum type_code type_code
= TYPE_CODE_UNDEF
;
1459 /* Handle undefined types, they have indexNil. */
1460 if (aux_index
== indexNil
)
1461 return mdebug_type_int
;
1463 /* Handle corrupt aux indices. */
1464 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1466 index_complaint (sym_name
);
1467 return mdebug_type_int
;
1471 /* Use aux as a type information record, map its basic type. */
1472 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1473 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1475 basic_type_complaint (t
->bt
, sym_name
);
1476 return mdebug_type_int
;
1480 tp
= *map_bt
[t
->bt
];
1485 /* Cannot use builtin types -- build our own */
1489 type_code
= TYPE_CODE_STRUCT
;
1492 type_code
= TYPE_CODE_UNION
;
1495 type_code
= TYPE_CODE_ENUM
;
1498 type_code
= TYPE_CODE_RANGE
;
1501 type_code
= TYPE_CODE_SET
;
1504 /* alpha cc -migrate uses this for typedefs. The true type will
1505 be obtained by crossreferencing below. */
1506 type_code
= TYPE_CODE_ERROR
;
1509 /* alpha cc uses this for typedefs. The true type will be
1510 obtained by crossreferencing below. */
1511 type_code
= TYPE_CODE_ERROR
;
1514 basic_type_complaint (t
->bt
, sym_name
);
1515 return mdebug_type_int
;
1519 /* Move on to next aux */
1524 int width
= AUX_GET_WIDTH (bigend
, ax
);
1525 /* Inhibit core dumps if TIR is corrupted. */
1526 if (bs
== (int *) NULL
)
1528 /* Alpha cc -migrate encodes char and unsigned char types
1529 as short and unsigned short types with a field width of 8.
1530 Enum types also have a field width which we ignore for now. */
1531 if (t
->bt
== btShort
&& width
== 8)
1532 tp
= mdebug_type_char
;
1533 else if (t
->bt
== btUShort
&& width
== 8)
1534 tp
= mdebug_type_unsigned_char
;
1535 else if (t
->bt
== btEnum
)
1538 complaint (&symfile_complaints
, "can't handle TIR fBitfield for %s",
1546 /* A btIndirect entry cross references to an aux entry containing
1548 if (t
->bt
== btIndirect
)
1555 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1557 if (rn
->rfd
== 0xfff)
1559 rf
= AUX_GET_ISYM (bigend
, ax
);
1567 complaint (&symfile_complaints
,
1568 "unable to cross ref btIndirect for %s", sym_name
);
1569 return mdebug_type_int
;
1571 xref_fh
= get_rfd (fd
, rf
);
1572 xref_fd
= xref_fh
- debug_info
->fdr
;
1573 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1574 rn
->index
, (int *) NULL
, xref_fh
->fBigendian
, sym_name
);
1577 /* All these types really point to some (common) MIPS type
1578 definition, and only the type-qualifiers fully identify
1579 them. We'll make the same effort at sharing. */
1580 if (t
->bt
== btStruct
||
1584 /* btSet (I think) implies that the name is a tag name, not a typedef
1585 name. This apparently is a MIPS extension for C sets. */
1590 /* Try to cross reference this type, build new type on failure. */
1591 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1592 if (tp
== (struct type
*) NULL
)
1593 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1595 /* DEC c89 produces cross references to qualified aggregate types,
1596 dereference them. */
1597 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1598 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1599 tp
= TYPE_TARGET_TYPE (tp
);
1601 /* Make sure that TYPE_CODE(tp) has an expected type code.
1602 Any type may be returned from cross_ref if file indirect entries
1604 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1605 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1606 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1608 unexpected_type_code_complaint (sym_name
);
1613 /* Usually, TYPE_CODE(tp) is already type_code. The main
1614 exception is if we guessed wrong re struct/union/enum.
1615 But for struct vs. union a wrong guess is harmless, so
1616 don't complain(). */
1617 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1618 && type_code
!= TYPE_CODE_ENUM
)
1619 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1620 && type_code
== TYPE_CODE_ENUM
))
1622 bad_tag_guess_complaint (sym_name
);
1625 if (TYPE_CODE (tp
) != type_code
)
1627 TYPE_CODE (tp
) = type_code
;
1630 /* Do not set the tag name if it is a compiler generated tag name
1631 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1632 if (name
[0] == '.' || name
[0] == '\0')
1633 TYPE_TAG_NAME (tp
) = NULL
;
1634 else if (TYPE_TAG_NAME (tp
) == NULL
1635 || strcmp (TYPE_TAG_NAME (tp
), name
) != 0)
1636 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1637 ¤t_objfile
->type_obstack
);
1641 /* All these types really point to some (common) MIPS type
1642 definition, and only the type-qualifiers fully identify
1643 them. We'll make the same effort at sharing.
1644 FIXME: We are not doing any guessing on range types. */
1645 if (t
->bt
== btRange
)
1649 /* Try to cross reference this type, build new type on failure. */
1650 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1651 if (tp
== (struct type
*) NULL
)
1652 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1654 /* Make sure that TYPE_CODE(tp) has an expected type code.
1655 Any type may be returned from cross_ref if file indirect entries
1657 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1659 unexpected_type_code_complaint (sym_name
);
1663 /* Usually, TYPE_CODE(tp) is already type_code. The main
1664 exception is if we guessed wrong re struct/union/enum. */
1665 if (TYPE_CODE (tp
) != type_code
)
1667 bad_tag_guess_complaint (sym_name
);
1668 TYPE_CODE (tp
) = type_code
;
1670 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1671 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1672 ¤t_objfile
->type_obstack
);
1675 if (t
->bt
== btTypedef
)
1679 /* Try to cross reference this type, it should succeed. */
1680 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1681 if (tp
== (struct type
*) NULL
)
1683 complaint (&symfile_complaints
,
1684 "unable to cross ref btTypedef for %s", sym_name
);
1685 tp
= mdebug_type_int
;
1689 /* Deal with range types */
1690 if (t
->bt
== btRange
)
1692 TYPE_NFIELDS (tp
) = 2;
1693 TYPE_FIELDS (tp
) = ((struct field
*)
1694 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1695 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1696 ¤t_objfile
->type_obstack
);
1697 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1699 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1700 ¤t_objfile
->type_obstack
);
1701 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1705 /* Parse all the type qualifiers now. If there are more
1706 than 6 the game will continue in the next aux */
1710 #define PARSE_TQ(tq) \
1711 if (t->tq != tqNil) \
1712 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1724 /* mips cc 2.x and gcc never put out continued aux entries. */
1728 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1732 /* Complain for illegal continuations due to corrupt aux entries. */
1734 complaint (&symfile_complaints
, "illegal TIR continued for %s", sym_name
);
1739 /* Make up a complex type from a basic one. Type is passed by
1740 reference in TPP and side-effected as necessary. The type
1741 qualifier TQ says how to handle the aux symbols at AX for
1742 the symbol SX we are currently analyzing. BIGEND says whether
1743 aux symbols are big-endian or little-endian.
1744 Returns the number of aux symbols we parsed. */
1747 upgrade_type (int fd
, struct type
**tpp
, int tq
, union aux_ext
*ax
, int bigend
,
1753 /* Used in array processing */
1764 t
= lookup_pointer_type (*tpp
);
1769 t
= lookup_function_type (*tpp
);
1776 /* Determine and record the domain type (type of index) */
1777 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1783 rf
= AUX_GET_ISYM (bigend
, ax
);
1786 fh
= get_rfd (fd
, rf
);
1788 indx
= parse_type (fh
- debug_info
->fdr
,
1789 debug_info
->external_aux
+ fh
->iauxBase
,
1790 id
, (int *) NULL
, bigend
, sym_name
);
1792 /* The bounds type should be an integer type, but might be anything
1793 else due to corrupt aux entries. */
1794 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1796 complaint (&symfile_complaints
,
1797 "illegal array index type for %s, assuming int", sym_name
);
1798 indx
= mdebug_type_int
;
1801 /* Get the bounds, and create the array type. */
1803 lower
= AUX_GET_DNLOW (bigend
, ax
);
1805 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1807 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1809 range
= create_range_type ((struct type
*) NULL
, indx
,
1812 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1814 /* We used to fill in the supplied array element bitsize
1815 here if the TYPE_LENGTH of the target type was zero.
1816 This happens for a `pointer to an array of anonymous structs',
1817 but in this case the array element bitsize is also zero,
1818 so nothing is gained.
1819 And we used to check the TYPE_LENGTH of the target type against
1820 the supplied array element bitsize.
1821 gcc causes a mismatch for `pointer to array of object',
1822 since the sdb directives it uses do not have a way of
1823 specifying the bitsize, but it does no harm (the
1824 TYPE_LENGTH should be correct) and we should be able to
1825 ignore the erroneous bitsize from the auxiliary entry safely.
1826 dbx seems to ignore it too. */
1828 /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
1830 if (TYPE_LENGTH (*tpp
) == 0)
1832 TYPE_FLAGS (t
) |= TYPE_FLAG_TARGET_STUB
;
1839 /* Volatile -- currently ignored */
1843 /* Const -- currently ignored */
1847 complaint (&symfile_complaints
, "unknown type qualifier 0x%x", tq
);
1853 /* Parse a procedure descriptor record PR. Note that the procedure is
1854 parsed _after_ the local symbols, now we just insert the extra
1855 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1856 already been placed in the procedure's main block. Note also that
1857 images that have been partially stripped (ld -x) have been deprived
1858 of local symbols, and we have to cope with them here. FIRST_OFF is
1859 the offset of the first procedure for this FDR; we adjust the
1860 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1861 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1862 in question, or NULL to use top_stack->cur_block. */
1864 static void parse_procedure (PDR
*, struct symtab
*, struct partial_symtab
*);
1867 parse_procedure (PDR
*pr
, struct symtab
*search_symtab
,
1868 struct partial_symtab
*pst
)
1870 struct symbol
*s
, *i
;
1872 struct mips_extra_func_info
*e
;
1875 /* Simple rule to find files linked "-x" */
1876 if (cur_fdr
->rss
== -1)
1880 /* Static procedure at address pr->adr. Sigh. */
1881 /* FIXME-32x64. assuming pr->adr fits in long. */
1882 complaint (&symfile_complaints
,
1883 "can't handle PDR for static proc at 0x%lx",
1884 (unsigned long) pr
->adr
);
1892 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1893 ((char *) debug_info
->external_ext
1895 * debug_swap
->external_ext_size
)),
1897 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1905 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1906 ((char *) debug_info
->external_sym
1907 + ((cur_fdr
->isymBase
+ pr
->isym
)
1908 * debug_swap
->external_sym_size
)),
1910 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1913 if (search_symtab
!= NULL
)
1916 /* This loses both in the case mentioned (want a static, find a global),
1917 but also if we are looking up a non-mangled name which happens to
1918 match the name of a mangled function. */
1919 /* We have to save the cur_fdr across the call to lookup_symbol.
1920 If the pdr is for a static function and if a global function with
1921 the same name exists, lookup_symbol will eventually read in the symtab
1922 for the global function and clobber cur_fdr. */
1923 FDR
*save_cur_fdr
= cur_fdr
;
1924 s
= lookup_symbol (sh_name
, NULL
, VAR_DOMAIN
, 0, NULL
);
1925 cur_fdr
= save_cur_fdr
;
1929 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1935 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1936 VAR_DOMAIN
, LOC_BLOCK
);
1940 b
= SYMBOL_BLOCK_VALUE (s
);
1944 complaint (&symfile_complaints
, "PDR for %s, but no symbol", sh_name
);
1948 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1949 s
= new_symbol (sh_name
);
1950 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1951 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1952 /* Donno its type, hope int is ok */
1953 SYMBOL_TYPE (s
) = lookup_function_type (mdebug_type_int
);
1954 add_symbol (s
, top_stack
->cur_block
);
1955 /* Wont have symbols for this one */
1957 SYMBOL_BLOCK_VALUE (s
) = b
;
1958 BLOCK_FUNCTION (b
) = s
;
1959 BLOCK_START (b
) = pr
->adr
;
1960 /* BOUND used to be the end of procedure's text, but the
1961 argument is no longer passed in. */
1962 BLOCK_END (b
) = bound
;
1963 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1964 add_block (b
, top_stack
->cur_st
);
1968 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_DOMAIN
, LOC_CONST
);
1972 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1974 e
->pdr
.isym
= (long) s
;
1976 /* GDB expects the absolute function start address for the
1977 procedure descriptor in e->pdr.adr.
1978 As the address in the procedure descriptor is usually relative,
1979 we would have to relocate e->pdr.adr with cur_fdr->adr and
1980 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
1981 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
1982 in shared libraries on some systems, and on other systems
1983 e->pdr.adr is sometimes offset by a bogus value.
1984 To work around these problems, we replace e->pdr.adr with
1985 the start address of the function. */
1986 e
->pdr
.adr
= BLOCK_START (b
);
1988 /* Correct incorrect setjmp procedure descriptor from the library
1989 to make backtrace through setjmp work. */
1990 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1992 complaint (&symfile_complaints
, "fixing bad setjmp PDR from libc");
1993 e
->pdr
.pcreg
= RA_REGNUM
;
1994 e
->pdr
.regmask
= 0x80000000;
1995 e
->pdr
.regoffset
= -4;
1999 /* It would be reasonable that functions that have been compiled
2000 without debugging info have a btNil type for their return value,
2001 and functions that are void and are compiled with debugging info
2003 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2004 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2006 The glevel field in cur_fdr could be used to determine the presence
2007 of debugging info, but GCC doesn't always pass the -g switch settings
2008 to the assembler and GAS doesn't set the glevel field from the -g switch
2010 To work around these problems, the return value type of a TYPE_CODE_VOID
2011 function is adjusted accordingly if no debugging info was found in the
2012 compilation unit. */
2014 if (processing_gcc_compilation
== 0
2015 && found_ecoff_debugging_info
== 0
2016 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
2017 SYMBOL_TYPE (s
) = nodebug_func_symbol_type
;
2020 /* Relocate the extra function info pointed to by the symbol table. */
2023 ecoff_relocate_efi (struct symbol
*sym
, CORE_ADDR delta
)
2025 struct mips_extra_func_info
*e
;
2027 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (sym
);
2029 e
->pdr
.adr
+= delta
;
2032 /* Parse the external symbol ES. Just call parse_symbol() after
2033 making sure we know where the aux are for it.
2034 BIGEND says whether aux entries are big-endian or little-endian.
2036 This routine clobbers top_stack->cur_block and ->cur_st. */
2038 static void parse_external (EXTR
*, int, struct section_offsets
*,
2042 parse_external (EXTR
*es
, int bigend
, struct section_offsets
*section_offsets
,
2043 struct objfile
*objfile
)
2047 if (es
->ifd
!= ifdNil
)
2050 cur_fdr
= debug_info
->fdr
+ cur_fd
;
2051 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
2055 cur_fdr
= debug_info
->fdr
;
2059 /* Reading .o files */
2060 if (SC_IS_UNDEF (es
->asym
.sc
) || es
->asym
.sc
== scNil
)
2063 switch (es
->asym
.st
)
2066 /* These are generated for static symbols in .o files,
2087 /* FIXME: Turn this into a complaint? */
2089 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
2090 what
, debug_info
->ssext
+ es
->asym
.iss
,
2091 fdr_name (cur_fdr
));
2095 switch (es
->asym
.st
)
2099 /* There is no need to parse the external procedure symbols.
2100 If they are from objects compiled without -g, their index will
2101 be indexNil, and the symbol definition from the minimal symbol
2102 is preferrable (yielding a function returning int instead of int).
2103 If the index points to a local procedure symbol, the local
2104 symbol already provides the correct type.
2105 Note that the index of the external procedure symbol points
2106 to the local procedure symbol in the local symbol table, and
2107 _not_ to the auxiliary symbol info. */
2111 /* Global common symbols are resolved by the runtime loader,
2113 if (SC_IS_COMMON (es
->asym
.sc
))
2116 /* Note that the case of a symbol with indexNil must be handled
2117 anyways by parse_symbol(). */
2118 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
, objfile
);
2125 /* Parse the line number info for file descriptor FH into
2126 GDB's linetable LT. MIPS' encoding requires a little bit
2127 of magic to get things out. Note also that MIPS' line
2128 numbers can go back and forth, apparently we can live
2129 with that and do not need to reorder our linetables */
2131 static void parse_lines (FDR
*, PDR
*, struct linetable
*, int,
2132 struct partial_symtab
*, CORE_ADDR
);
2135 parse_lines (FDR
*fh
, PDR
*pr
, struct linetable
*lt
, int maxlines
,
2136 struct partial_symtab
*pst
, CORE_ADDR lowest_pdr_addr
)
2138 unsigned char *base
;
2140 int delta
, count
, lineno
= 0;
2142 if (fh
->cbLine
== 0)
2145 /* Scan by procedure descriptors */
2147 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2151 unsigned char *halt
;
2153 /* No code for this one */
2154 if (pr
->iline
== ilineNil
||
2155 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2158 /* Determine start and end address of compressed line bytes for
2160 base
= debug_info
->line
+ fh
->cbLineOffset
;
2161 if (j
!= (fh
->cpd
- 1))
2162 halt
= base
+ pr
[1].cbLineOffset
;
2164 halt
= base
+ fh
->cbLine
;
2165 base
+= pr
->cbLineOffset
;
2167 adr
= pst
->textlow
+ pr
->adr
- lowest_pdr_addr
;
2169 l
= adr
>> 2; /* in words */
2170 for (lineno
= pr
->lnLow
; base
< halt
;)
2172 count
= *base
& 0x0f;
2173 delta
= *base
++ >> 4;
2178 delta
= (base
[0] << 8) | base
[1];
2179 if (delta
>= 0x8000)
2183 lineno
+= delta
; /* first delta is 0 */
2185 /* Complain if the line table overflows. Could happen
2186 with corrupt binaries. */
2187 if (lt
->nitems
>= maxlines
)
2189 complaint (&symfile_complaints
,
2190 "guessed size of linetable for %s incorrectly",
2194 k
= add_line (lt
, lineno
, l
, k
);
2201 function_outside_compilation_unit_complaint (const char *arg1
)
2203 complaint (&symfile_complaints
,
2204 "function `%s' appears to be defined outside of all compilation units",
2208 /* Master parsing procedure for first-pass reading of file symbols
2209 into a partial_symtab. */
2212 parse_partial_symbols (struct objfile
*objfile
)
2214 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2215 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2216 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2217 void (*const swap_ext_in
) (bfd
*, void *, EXTR
*) = debug_swap
->swap_ext_in
;
2218 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
2219 void (*const swap_rfd_in
) (bfd
*, void *, RFDT
*) = debug_swap
->swap_rfd_in
;
2221 HDRR
*hdr
= &debug_info
->symbolic_header
;
2222 /* Running pointers */
2230 struct partial_symtab
*pst
;
2231 int textlow_not_set
= 1;
2232 int past_first_source_file
= 0;
2234 /* List of current psymtab's include files */
2235 char **psymtab_include_list
;
2236 int includes_allocated
;
2239 struct pst_map
*fdr_to_pst
;
2240 /* Index within current psymtab dependency list */
2241 struct partial_symtab
**dependency_list
;
2242 int dependencies_used
, dependencies_allocated
;
2243 struct cleanup
*old_chain
;
2245 enum language prev_language
;
2246 asection
*text_sect
;
2247 int relocatable
= 0;
2249 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2250 the shared libraries are prelinked at a high memory address.
2251 We have to adjust the start address of the object file for this case,
2252 by setting it to the start address of the first procedure in the file.
2253 But we should do no adjustments if we are debugging a .o file, where
2254 the text section (and fh->adr) really starts at zero. */
2255 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2256 if (text_sect
!= NULL
2257 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2260 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2261 sizeof (EXTR
) * hdr
->iextMax
);
2263 includes_allocated
= 30;
2265 psymtab_include_list
= (char **) alloca (includes_allocated
*
2267 next_symbol_text_func
= mdebug_next_symbol_text
;
2269 dependencies_allocated
= 30;
2270 dependencies_used
= 0;
2272 (struct partial_symtab
**) alloca (dependencies_allocated
*
2273 sizeof (struct partial_symtab
*));
2275 last_source_file
= NULL
;
2280 * Only parse the Local and External symbols, and the Relative FDR.
2281 * Fixup enough of the loader symtab to be able to use it.
2282 * Allocate space only for the file's portions we need to
2287 max_glevel
= MIN_GLEVEL
;
2289 /* Allocate the map FDR -> PST.
2290 Minor hack: -O3 images might claim some global data belongs
2291 to FDR -1. We`ll go along with that */
2292 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2293 old_chain
= make_cleanup (xfree
, fdr_to_pst
);
2296 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2297 fdr_to_pst
[-1].pst
= pst
;
2301 /* Allocate the global pending list. */
2303 ((struct mdebug_pending
**)
2304 obstack_alloc (&objfile
->psymbol_obstack
,
2305 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2306 memset (pending_list
, 0,
2307 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2309 /* Pass 0 over external syms: swap them in. */
2310 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2311 make_cleanup (xfree
, ext_block
);
2313 ext_out
= (char *) debug_info
->external_ext
;
2314 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2316 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2317 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2319 /* Pass 1 over external syms: Presize and partition the list */
2321 ext_in_end
= ext_in
+ hdr
->iextMax
;
2322 for (; ext_in
< ext_in_end
; ext_in
++)
2324 /* See calls to complain below. */
2325 if (ext_in
->ifd
>= -1
2326 && ext_in
->ifd
< hdr
->ifdMax
2327 && ext_in
->asym
.iss
>= 0
2328 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2329 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2332 /* Pass 1.5 over files: partition out global symbol space */
2334 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2336 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2337 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2338 fdr_to_pst
[f_idx
].n_globals
= 0;
2343 For ECOFF in ELF, we skip the creation of the minimal symbols.
2344 The ECOFF symbols should be a subset of the Elf symbols, and the
2345 section information of the elf symbols will be more accurate.
2346 FIXME! What about Irix 5's native linker?
2348 By default, Elf sections which don't exist in ECOFF
2349 get put in ECOFF's absolute section by the gnu linker.
2350 Since absolute sections don't get relocated, we
2351 end up calculating an address different from that of
2352 the symbol's minimal symbol (created earlier from the
2355 To fix this, either :
2356 1) don't create the duplicate symbol
2357 (assumes ECOFF symtab is a subset of the ELF symtab;
2358 assumes no side-effects result from ignoring ECOFF symbol)
2359 2) create it, only if lookup for existing symbol in ELF's minimal
2362 assumes no side-effects result from ignoring ECOFF symbol)
2363 3) create it, but lookup ELF's minimal symbol and use it's section
2364 during relocation, then modify "uniqify" phase to merge and
2365 eliminate the duplicate symbol
2366 (highly inefficient)
2368 I've implemented #1 here...
2369 Skip the creation of the minimal symbols based on the ECOFF
2372 /* Pass 2 over external syms: fill in external symbols */
2374 ext_in_end
= ext_in
+ hdr
->iextMax
;
2375 for (; ext_in
< ext_in_end
; ext_in
++)
2377 enum minimal_symbol_type ms_type
= mst_text
;
2378 CORE_ADDR svalue
= ext_in
->asym
.value
;
2380 /* The Irix 5 native tools seem to sometimes generate bogus
2381 external symbols. */
2382 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2384 complaint (&symfile_complaints
,
2385 "bad ifd for external symbol: %d (max %ld)", ext_in
->ifd
,
2389 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2391 complaint (&symfile_complaints
,
2392 "bad iss for external symbol: %ld (max %ld)",
2393 ext_in
->asym
.iss
, hdr
->issExtMax
);
2397 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2398 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2401 if (SC_IS_UNDEF (ext_in
->asym
.sc
) || ext_in
->asym
.sc
== scNil
)
2405 /* Pass 3 over files, over local syms: fill in static symbols */
2406 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2408 /* Process ECOFF Symbol Types and Storage Classes */
2409 switch (ext_in
->asym
.st
)
2412 /* Beginnning of Procedure */
2413 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2416 /* Load time only static procs */
2417 ms_type
= mst_file_text
;
2418 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2421 /* External symbol */
2422 if (SC_IS_COMMON (ext_in
->asym
.sc
))
2424 /* The value of a common symbol is its size, not its address.
2428 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2431 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2433 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2436 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2438 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2441 svalue
+= ANOFFSET (objfile
->section_offsets
,
2442 get_section_index (objfile
, ".sbss"));
2450 /* On certain platforms, some extra label symbols can be
2451 generated by the linker. One possible usage for this kind
2452 of symbols is to represent the address of the begining of a
2453 given section. For instance, on Tru64 5.1, the address of
2454 the _ftext label is the start address of the .text section.
2456 The storage class of these symbols is usually directly
2457 related to the section to which the symbol refers. For
2458 instance, on Tru64 5.1, the storage class for the _fdata
2459 label is scData, refering to the .data section.
2461 It is actually possible that the section associated to the
2462 storage class of the label does not exist. On True64 5.1
2463 for instance, the libm.so shared library does not contain
2464 any .data section, although it contains a _fpdata label
2465 which storage class is scData... Since these symbols are
2466 usually useless for the debugger user anyway, we just
2467 discard these symbols.
2470 if (SC_IS_TEXT (ext_in
->asym
.sc
))
2472 if (objfile
->sect_index_text
== -1)
2475 ms_type
= mst_file_text
;
2476 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2478 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2480 if (objfile
->sect_index_data
== -1)
2483 ms_type
= mst_file_data
;
2484 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2486 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2488 if (objfile
->sect_index_bss
== -1)
2491 ms_type
= mst_file_bss
;
2492 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2494 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2496 const int sbss_sect_index
= get_section_index (objfile
, ".sbss");
2498 if (sbss_sect_index
== -1)
2501 ms_type
= mst_file_bss
;
2502 svalue
+= ANOFFSET (objfile
->section_offsets
, sbss_sect_index
);
2509 /* The alpha has the section start addresses in stLocal symbols
2510 whose name starts with a `.'. Skip those but complain for all
2511 other stLocal symbols.
2512 Irix6 puts the section start addresses in stNil symbols, skip
2518 ms_type
= mst_unknown
;
2519 unknown_ext_complaint (name
);
2521 if (!ECOFF_IN_ELF (cur_bfd
))
2522 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2525 /* Pass 3 over files, over local syms: fill in static symbols */
2526 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2528 struct partial_symtab
*save_pst
;
2532 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2536 fdr_to_pst
[f_idx
].pst
= NULL
;
2540 /* Determine the start address for this object file from the
2541 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2545 if (relocatable
|| textlow
!= 0)
2546 textlow
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2550 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
2553 objfile
->global_psymbols
.next
,
2554 objfile
->static_psymbols
.next
);
2555 pst
->read_symtab_private
= ((char *)
2556 obstack_alloc (&objfile
->psymbol_obstack
,
2557 sizeof (struct symloc
)));
2558 memset (pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2561 FDR_IDX (pst
) = f_idx
;
2562 CUR_BFD (pst
) = cur_bfd
;
2563 DEBUG_SWAP (pst
) = debug_swap
;
2564 DEBUG_INFO (pst
) = debug_info
;
2565 PENDING_LIST (pst
) = pending_list
;
2567 /* The way to turn this into a symtab is to call... */
2568 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2570 /* Set up language for the pst.
2571 The language from the FDR is used if it is unambigious (e.g. cfront
2572 with native cc and g++ will set the language to C).
2573 Otherwise we have to deduce the language from the filename.
2574 Native ecoff has every header file in a separate FDR, so
2575 deduce_language_from_filename will return language_unknown for
2576 a header file, which is not what we want.
2577 But the FDRs for the header files are after the FDR for the source
2578 file, so we can assign the language of the source file to the
2579 following header files. Then we save the language in the private
2580 pst data so that we can reuse it when building symtabs. */
2581 prev_language
= psymtab_language
;
2585 case langCplusplusV2
:
2586 psymtab_language
= language_cplus
;
2589 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2592 if (psymtab_language
== language_unknown
)
2593 psymtab_language
= prev_language
;
2594 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2596 pst
->texthigh
= pst
->textlow
;
2598 /* For stabs-in-ecoff files, the second symbol must be @stab.
2599 This symbol is emitted by mips-tfile to signal that the
2600 current object file uses encapsulated stabs instead of mips
2601 ecoff for local symbols. (It is the second symbol because
2602 the first symbol is the stFile used to signal the start of a
2604 processing_gcc_compilation
= 0;
2607 (*swap_sym_in
) (cur_bfd
,
2608 ((char *) debug_info
->external_sym
2609 + (fh
->isymBase
+ 1) * external_sym_size
),
2611 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2612 processing_gcc_compilation
= 2;
2615 if (processing_gcc_compilation
!= 0)
2617 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2622 (*swap_sym_in
) (cur_bfd
,
2623 (((char *) debug_info
->external_sym
)
2624 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2626 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2627 if (!ECOFF_IS_STAB (&sh
))
2629 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2634 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2635 if (sh
.st
== stStaticProc
)
2637 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2638 prim_record_minimal_symbol_and_info (namestring
,
2642 SECT_OFF_TEXT (objfile
),
2646 procaddr
= sh
.value
;
2648 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2649 (debug_info
->external_aux
2652 (*swap_sym_in
) (cur_bfd
,
2653 ((char *) debug_info
->external_sym
2654 + ((fh
->isymBase
+ isym
- 1)
2655 * external_sym_size
)),
2659 CORE_ADDR high
= procaddr
+ sh
.value
;
2661 /* Kludge for Irix 5.2 zero fh->adr. */
2663 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2664 pst
->textlow
= procaddr
;
2665 if (high
> pst
->texthigh
)
2666 pst
->texthigh
= high
;
2669 else if (sh
.st
== stStatic
)
2684 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2685 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2686 prim_record_minimal_symbol_and_info (namestring
,
2690 SECT_OFF_DATA (objfile
),
2696 /* FIXME! Shouldn't this use cases for bss,
2697 then have the default be abs? */
2698 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2699 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2700 prim_record_minimal_symbol_and_info (namestring
,
2704 SECT_OFF_BSS (objfile
),
2712 /* Handle stabs continuation */
2714 char *stabstring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2715 int len
= strlen (stabstring
);
2716 while (stabstring
[len
- 1] == '\\')
2719 char *stabstring1
= stabstring
;
2723 /* Ignore continuation char from 1st string */
2726 /* Read next stabstring */
2728 (*swap_sym_in
) (cur_bfd
,
2729 (((char *) debug_info
->external_sym
)
2730 + (fh
->isymBase
+ cur_sdx
)
2731 * external_sym_size
),
2733 stabstring2
= debug_info
->ss
+ fh
->issBase
+ sh2
.iss
;
2734 len2
= strlen (stabstring2
);
2736 /* Concatinate stabstring2 with stabstring1 */
2738 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
2739 stabstring
= xrealloc (stabstring
, len
+ len2
+ 1);
2742 stabstring
= xmalloc (len
+ len2
+ 1);
2743 strcpy (stabstring
, stabstring1
);
2745 strcpy (stabstring
+ len
, stabstring2
);
2753 * Standard, external, non-debugger, symbols
2756 case N_TEXT
| N_EXT
:
2757 case N_NBTEXT
| N_EXT
:
2758 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2761 case N_DATA
| N_EXT
:
2762 case N_NBDATA
| N_EXT
:
2763 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2768 case N_NBBSS
| N_EXT
:
2769 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
2770 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2777 /* Standard, local, non-debugger, symbols */
2781 /* We need to be able to deal with both N_FN or N_TEXT,
2782 because we have no way of knowing whether the sys-supplied ld
2783 or GNU ld was used to make the executable. Sequents throw
2784 in another wrinkle -- they renumbered N_FN. */
2792 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2795 case N_UNDF
| N_EXT
:
2796 continue; /* Just undefined, not COMMON */
2801 /* Lots of symbol types we can just ignore. */
2808 /* Keep going . . . */
2811 * Special symbol types for GNU
2814 case N_INDR
| N_EXT
:
2816 case N_SETA
| N_EXT
:
2818 case N_SETT
| N_EXT
:
2820 case N_SETD
| N_EXT
:
2822 case N_SETB
| N_EXT
:
2833 static int prev_so_symnum
= -10;
2834 static int first_so_symnum
;
2836 int prev_textlow_not_set
;
2838 valu
= sh
.value
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2840 prev_textlow_not_set
= textlow_not_set
;
2842 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2843 /* A zero value is probably an indication for the SunPRO 3.0
2844 compiler. end_psymtab explicitly tests for zero, so
2845 don't relocate it. */
2849 textlow_not_set
= 1;
2853 textlow_not_set
= 0;
2855 textlow_not_set
= 0;
2857 past_first_source_file
= 1;
2859 if (prev_so_symnum
!= symnum
- 1)
2860 { /* Here if prev stab wasn't N_SO */
2861 first_so_symnum
= symnum
;
2865 pst
= (struct partial_symtab
*) 0;
2867 dependencies_used
= 0;
2871 prev_so_symnum
= symnum
;
2873 /* End the current partial symtab and start a new one */
2875 /* SET_NAMESTRING ();*/
2876 namestring
= stabstring
;
2878 /* Null name means end of .o file. Don't start a new one. */
2879 if (*namestring
== '\000')
2882 /* Some compilers (including gcc) emit a pair of initial N_SOs.
2883 The first one is a directory name; the second the file name.
2884 If pst exists, is empty, and has a filename ending in '/',
2885 we assume the previous N_SO was a directory name. */
2887 p
= strrchr (namestring
, '/');
2888 if (p
&& *(p
+ 1) == '\000')
2889 continue; /* Simply ignore directory name SOs */
2891 /* Some other compilers (C++ ones in particular) emit useless
2892 SOs for non-existant .c files. We ignore all subsequent SOs that
2893 immediately follow the first. */
2905 enum language tmp_language
;
2906 /* Mark down an include file in the current psymtab */
2908 /* SET_NAMESTRING ();*/
2909 namestring
= stabstring
;
2911 tmp_language
= deduce_language_from_filename (namestring
);
2913 /* Only change the psymtab's language if we've learned
2914 something useful (eg. tmp_language is not language_unknown).
2915 In addition, to match what start_subfile does, never change
2917 if (tmp_language
!= language_unknown
2918 && (tmp_language
!= language_c
2919 || psymtab_language
!= language_cplus
))
2920 psymtab_language
= tmp_language
;
2922 /* In C++, one may expect the same filename to come round many
2923 times, when code is coming alternately from the main file
2924 and from inline functions in other files. So I check to see
2925 if this is a file we've seen before -- either the main
2926 source file, or a previously included file.
2928 This seems to be a lot of time to be spending on N_SOL, but
2929 things like "break c-exp.y:435" need to work (I
2930 suppose the psymtab_include_list could be hashed or put
2931 in a binary tree, if profiling shows this is a major hog). */
2932 if (pst
&& STREQ (namestring
, pst
->filename
))
2936 for (i
= 0; i
< includes_used
; i
++)
2937 if (STREQ (namestring
, psymtab_include_list
[i
]))
2946 psymtab_include_list
[includes_used
++] = namestring
;
2947 if (includes_used
>= includes_allocated
)
2949 char **orig
= psymtab_include_list
;
2951 psymtab_include_list
= (char **)
2952 alloca ((includes_allocated
*= 2) *
2954 memcpy (psymtab_include_list
, orig
,
2955 includes_used
* sizeof (char *));
2959 case N_LSYM
: /* Typedef or automatic variable. */
2960 case N_STSYM
: /* Data seg var -- static */
2961 case N_LCSYM
: /* BSS " */
2962 case N_ROSYM
: /* Read-only data seg var -- static. */
2963 case N_NBSTS
: /* Gould nobase. */
2964 case N_NBLCS
: /* symbols. */
2966 case N_GSYM
: /* Global (extern) variable; can be
2967 data or bss (sigh FIXME). */
2969 /* Following may probably be ignored; I'll leave them here
2970 for now (until I do Pascal and Modula 2 extensions). */
2972 case N_PC
: /* I may or may not need this; I
2974 case N_M2C
: /* I suspect that I can ignore this here. */
2975 case N_SCOPE
: /* Same. */
2977 /* SET_NAMESTRING ();*/
2978 namestring
= stabstring
;
2979 p
= (char *) strchr (namestring
, ':');
2981 continue; /* Not a debugging symbol. */
2985 /* Main processing section for debugging symbols which
2986 the initial read through the symbol tables needs to worry
2987 about. If we reach this point, the symbol which we are
2988 considering is definitely one we are interested in.
2989 p must also contain the (valid) index into the namestring
2990 which indicates the debugging type symbol. */
2995 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2996 #ifdef STATIC_TRANSFORM_NAME
2997 namestring
= STATIC_TRANSFORM_NAME (namestring
);
2999 add_psymbol_to_list (namestring
, p
- namestring
,
3000 VAR_DOMAIN
, LOC_STATIC
,
3001 &objfile
->static_psymbols
,
3003 psymtab_language
, objfile
);
3006 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3007 /* The addresses in these entries are reported to be
3008 wrong. See the code that reads 'G's for symtabs. */
3009 add_psymbol_to_list (namestring
, p
- namestring
,
3010 VAR_DOMAIN
, LOC_STATIC
,
3011 &objfile
->global_psymbols
,
3013 psymtab_language
, objfile
);
3017 /* When a 'T' entry is defining an anonymous enum, it
3018 may have a name which is the empty string, or a
3019 single space. Since they're not really defining a
3020 symbol, those shouldn't go in the partial symbol
3021 table. We do pick up the elements of such enums at
3022 'check_enum:', below. */
3023 if (p
>= namestring
+ 2
3024 || (p
== namestring
+ 1
3025 && namestring
[0] != ' '))
3027 add_psymbol_to_list (namestring
, p
- namestring
,
3028 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3029 &objfile
->static_psymbols
,
3031 psymtab_language
, objfile
);
3034 /* Also a typedef with the same name. */
3035 add_psymbol_to_list (namestring
, p
- namestring
,
3036 VAR_DOMAIN
, LOC_TYPEDEF
,
3037 &objfile
->static_psymbols
,
3039 psymtab_language
, objfile
);
3045 if (p
!= namestring
) /* a name is there, not just :T... */
3047 add_psymbol_to_list (namestring
, p
- namestring
,
3048 VAR_DOMAIN
, LOC_TYPEDEF
,
3049 &objfile
->static_psymbols
,
3051 psymtab_language
, objfile
);
3054 /* If this is an enumerated type, we need to
3055 add all the enum constants to the partial symbol
3056 table. This does not cover enums without names, e.g.
3057 "enum {a, b} c;" in C, but fortunately those are
3058 rare. There is no way for GDB to find those from the
3059 enum type without spending too much time on it. Thus
3060 to solve this problem, the compiler needs to put out the
3061 enum in a nameless type. GCC2 does this. */
3063 /* We are looking for something of the form
3064 <name> ":" ("t" | "T") [<number> "="] "e"
3065 {<constant> ":" <value> ","} ";". */
3067 /* Skip over the colon and the 't' or 'T'. */
3069 /* This type may be given a number. Also, numbers can come
3070 in pairs like (0,26). Skip over it. */
3071 while ((*p
>= '0' && *p
<= '9')
3072 || *p
== '(' || *p
== ',' || *p
== ')'
3078 /* The aix4 compiler emits extra crud before the members. */
3081 /* Skip over the type (?). */
3085 /* Skip over the colon. */
3089 /* We have found an enumerated type. */
3090 /* According to comments in read_enum_type
3091 a comma could end it instead of a semicolon.
3092 I don't know where that happens.
3094 while (*p
&& *p
!= ';' && *p
!= ',')
3098 /* Check for and handle cretinous dbx symbol name
3100 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
3101 p
= next_symbol_text (objfile
);
3103 /* Point to the character after the name
3104 of the enum constant. */
3105 for (q
= p
; *q
&& *q
!= ':'; q
++)
3107 /* Note that the value doesn't matter for
3108 enum constants in psymtabs, just in symtabs. */
3109 add_psymbol_to_list (p
, q
- p
,
3110 VAR_DOMAIN
, LOC_CONST
,
3111 &objfile
->static_psymbols
, 0,
3112 0, psymtab_language
, objfile
);
3113 /* Point past the name. */
3115 /* Skip over the value. */
3116 while (*p
&& *p
!= ',')
3118 /* Advance past the comma. */
3125 /* Constant, e.g. from "const" in Pascal. */
3126 add_psymbol_to_list (namestring
, p
- namestring
,
3127 VAR_DOMAIN
, LOC_CONST
,
3128 &objfile
->static_psymbols
, sh
.value
,
3129 0, psymtab_language
, objfile
);
3135 int name_len
= p
- namestring
;
3136 char *name
= xmalloc (name_len
+ 1);
3137 memcpy (name
, namestring
, name_len
);
3138 name
[name_len
] = '\0';
3139 function_outside_compilation_unit_complaint (name
);
3142 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3143 add_psymbol_to_list (namestring
, p
- namestring
,
3144 VAR_DOMAIN
, LOC_BLOCK
,
3145 &objfile
->static_psymbols
,
3147 psymtab_language
, objfile
);
3150 /* Global functions were ignored here, but now they
3151 are put into the global psymtab like one would expect.
3152 They're also in the minimal symbol table. */
3156 int name_len
= p
- namestring
;
3157 char *name
= xmalloc (name_len
+ 1);
3158 memcpy (name
, namestring
, name_len
);
3159 name
[name_len
] = '\0';
3160 function_outside_compilation_unit_complaint (name
);
3163 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3164 add_psymbol_to_list (namestring
, p
- namestring
,
3165 VAR_DOMAIN
, LOC_BLOCK
,
3166 &objfile
->global_psymbols
,
3168 psymtab_language
, objfile
);
3171 /* Two things show up here (hopefully); static symbols of
3172 local scope (static used inside braces) or extensions
3173 of structure symbols. We can ignore both. */
3187 case '#': /* for symbol identification (used in live ranges) */
3191 /* It is a C++ nested symbol. We don't need to record it
3192 (I don't think); if we try to look up foo::bar::baz,
3193 then symbols for the symtab containing foo should get
3194 read in, I think. */
3195 /* Someone says sun cc puts out symbols like
3196 /foo/baz/maclib::/usr/local/bin/maclib,
3197 which would get here with a symbol type of ':'. */
3201 /* Unexpected symbol descriptor. The second and subsequent stabs
3202 of a continued stab can show up here. The question is
3203 whether they ever can mimic a normal stab--it would be
3204 nice if not, since we certainly don't want to spend the
3205 time searching to the end of every string looking for
3208 complaint (&symfile_complaints
,
3209 "unknown symbol descriptor `%c'", p
[1]);
3211 /* Ignore it; perhaps it is an extension that we don't
3220 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
3221 /* Solaris 2 end of module, finish current partial
3222 symbol table. END_PSYMTAB will set
3223 pst->texthigh to the proper value, which is
3224 necessary if a module compiled without
3225 debugging info follows this module. */
3228 pst
= (struct partial_symtab
*) 0;
3230 dependencies_used
= 0;
3236 if (sh
.value
> save_pst
->texthigh
)
3237 save_pst
->texthigh
= sh
.value
;
3242 case N_SSYM
: /* Claim: Structure or union element.
3243 Hopefully, I can ignore this. */
3244 case N_ENTRY
: /* Alternate entry point; can ignore. */
3245 case N_MAIN
: /* Can definitely ignore this. */
3246 case N_CATCH
: /* These are GNU C++ extensions */
3247 case N_EHDECL
: /* that can safely be ignored here. */
3257 case N_NSYMS
: /* Ultrix 4.0: symbol count */
3258 case N_DEFD
: /* GNU Modula-2 */
3259 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
3261 case N_OBJ
: /* useless types from Solaris */
3263 /* These symbols aren't interesting; don't worry about them */
3268 /* If we haven't found it yet, ignore it. It's probably some
3269 new type we don't know about yet. */
3270 complaint (&symfile_complaints
, "unknown symbol type %s",
3271 local_hex_string (type_code
)); /*CUR_SYMBOL_TYPE*/
3275 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
3278 /* end - Handle continuation */
3283 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
3286 enum address_class
class;
3288 (*swap_sym_in
) (cur_bfd
,
3289 ((char *) debug_info
->external_sym
3290 + ((fh
->isymBase
+ cur_sdx
)
3291 * external_sym_size
)),
3294 if (ECOFF_IS_STAB (&sh
))
3300 /* Non absolute static symbols go into the minimal table. */
3301 if (SC_IS_UNDEF (sh
.sc
) || sh
.sc
== scNil
3302 || (sh
.index
== indexNil
3303 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
3305 /* FIXME, premature? */
3310 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3316 /* The value of a stEnd symbol is the displacement from the
3317 corresponding start symbol value, do not relocate it. */
3319 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3326 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3330 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3341 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3342 mst_file_text
, NULL
,
3343 SECT_OFF_TEXT (objfile
), NULL
,
3349 /* Ignore all parameter symbol records. */
3350 if (sh
.index
>= hdr
->iauxMax
)
3352 /* Should not happen, but does when cross-compiling
3353 with the MIPS compiler. FIXME -- pull later. */
3354 index_complaint (name
);
3355 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
3358 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
3359 (debug_info
->external_aux
3363 if (new_sdx
<= cur_sdx
)
3365 /* This should not happen either... FIXME. */
3366 complaint (&symfile_complaints
,
3367 "bad proc end in aux found from symbol %s",
3369 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3372 /* For stProc symbol records, we need to check the
3373 storage class as well, as only (stProc, scText)
3374 entries represent "real" procedures - See the
3375 Compaq document titled "Object File / Symbol Table
3376 Format Specification" for more information. If the
3377 storage class is not scText, we discard the whole
3378 block of symbol records for this stProc. */
3379 if (sh
.st
== stProc
&& sh
.sc
!= scText
)
3382 /* Usually there is a local and a global stProc symbol
3383 for a function. This means that the function name
3384 has already been entered into the mimimal symbol table
3385 while processing the global symbols in pass 2 above.
3386 One notable exception is the PROGRAM name from
3387 f77 compiled executables, it is only put out as
3388 local stProc symbol, and a global MAIN__ stProc symbol
3389 points to it. It doesn't matter though, as gdb is
3390 still able to find the PROGRAM name via the partial
3391 symbol table, and the MAIN__ symbol via the minimal
3393 if (sh
.st
== stProc
)
3394 add_psymbol_to_list (name
, strlen (name
),
3395 VAR_DOMAIN
, LOC_BLOCK
,
3396 &objfile
->global_psymbols
,
3397 0, sh
.value
, psymtab_language
, objfile
);
3399 add_psymbol_to_list (name
, strlen (name
),
3400 VAR_DOMAIN
, LOC_BLOCK
,
3401 &objfile
->static_psymbols
,
3402 0, sh
.value
, psymtab_language
, objfile
);
3404 procaddr
= sh
.value
;
3407 (*swap_sym_in
) (cur_bfd
,
3408 ((char *) debug_info
->external_sym
3409 + ((fh
->isymBase
+ cur_sdx
- 1)
3410 * external_sym_size
)),
3415 /* Kludge for Irix 5.2 zero fh->adr. */
3417 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
3418 pst
->textlow
= procaddr
;
3420 high
= procaddr
+ sh
.value
;
3421 if (high
> pst
->texthigh
)
3422 pst
->texthigh
= high
;
3425 case stStatic
: /* Variable */
3426 if (SC_IS_DATA (sh
.sc
))
3427 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3428 mst_file_data
, NULL
,
3429 SECT_OFF_DATA (objfile
),
3433 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3435 SECT_OFF_BSS (objfile
),
3441 case stIndirect
: /* Irix5 forward declaration */
3442 /* Skip forward declarations from Irix5 cc */
3445 case stTypedef
: /* Typedef */
3446 /* Skip typedefs for forward declarations and opaque
3447 structs from alpha and mips cc. */
3448 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
3450 class = LOC_TYPEDEF
;
3453 case stConstant
: /* Constant decl */
3460 case stBlock
: /* { }, str, un, enum */
3461 /* Do not create a partial symbol for cc unnamed aggregates
3462 and gcc empty aggregates. */
3463 if ((sh
.sc
== scInfo
3464 || SC_IS_COMMON (sh
.sc
))
3466 && sh
.index
!= cur_sdx
+ 2)
3468 add_psymbol_to_list (name
, strlen (name
),
3469 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3470 &objfile
->static_psymbols
,
3472 psymtab_language
, objfile
);
3474 handle_psymbol_enumerators (objfile
, fh
, sh
.st
, sh
.value
);
3476 /* Skip over the block */
3478 if (new_sdx
<= cur_sdx
)
3480 /* This happens with the Ultrix kernel. */
3481 complaint (&symfile_complaints
,
3482 "bad aux index at block symbol %s", name
);
3483 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3488 case stFile
: /* File headers */
3489 case stLabel
: /* Labels */
3490 case stEnd
: /* Ends of files */
3493 case stLocal
: /* Local variables */
3494 /* Normally these are skipped because we skip over
3495 all blocks we see. However, these can occur
3496 as visible symbols in a .h file that contains code. */
3500 /* Both complaints are valid: one gives symbol name,
3501 the other the offending symbol type. */
3502 complaint (&symfile_complaints
, "unknown local symbol %s",
3504 complaint (&symfile_complaints
, "with type %d", sh
.st
);
3508 /* Use this gdb symbol */
3509 add_psymbol_to_list (name
, strlen (name
),
3511 &objfile
->static_psymbols
,
3512 0, sh
.value
, psymtab_language
, objfile
);
3514 cur_sdx
++; /* Go to next file symbol */
3517 /* Now do enter the external symbols. */
3518 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
3519 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
3520 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
3521 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
3522 for (; --cur_sdx
>= 0; ext_ptr
++)
3524 enum address_class
class;
3529 if (ext_ptr
->ifd
!= f_idx
)
3530 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
3531 psh
= &ext_ptr
->asym
;
3533 /* Do not add undefined symbols to the partial symbol table. */
3534 if (SC_IS_UNDEF (psh
->sc
) || psh
->sc
== scNil
)
3537 svalue
= psh
->value
;
3542 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3549 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3553 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3560 /* These are generated for static symbols in .o files,
3565 /* External procedure symbols have been entered
3566 into the minimal symbol table in pass 2 above.
3567 Ignore them, as parse_external will ignore them too. */
3573 unknown_ext_complaint (debug_info
->ssext
+ psh
->iss
);
3574 /* Fall through, pretend it's global. */
3576 /* Global common symbols are resolved by the runtime loader,
3578 if (SC_IS_COMMON (psh
->sc
))
3584 name
= debug_info
->ssext
+ psh
->iss
;
3585 add_psymbol_to_list (name
, strlen (name
),
3587 &objfile
->global_psymbols
,
3589 psymtab_language
, objfile
);
3593 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3594 empty and put on the free list. */
3595 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
3596 psymtab_include_list
, includes_used
,
3597 -1, save_pst
->texthigh
,
3598 dependency_list
, dependencies_used
, textlow_not_set
);
3600 dependencies_used
= 0;
3602 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
3603 objfile
->ei
.entry_point
< save_pst
->texthigh
)
3605 objfile
->ei
.deprecated_entry_file_lowpc
= save_pst
->textlow
;
3606 objfile
->ei
.deprecated_entry_file_highpc
= save_pst
->texthigh
;
3609 /* The objfile has its functions reordered if this partial symbol
3610 table overlaps any other partial symbol table.
3611 We cannot assume a reordered objfile if a partial symbol table
3612 is contained within another partial symbol table, as partial symbol
3613 tables for include files with executable code are contained
3614 within the partial symbol table for the including source file,
3615 and we do not want to flag the objfile reordered for these cases.
3617 This strategy works well for Irix-5.2 shared libraries, but we
3618 might have to use a more elaborate (and slower) algorithm for
3620 save_pst
= fdr_to_pst
[f_idx
].pst
;
3621 if (save_pst
!= NULL
3622 && save_pst
->textlow
!= 0
3623 && !(objfile
->flags
& OBJF_REORDERED
))
3625 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
3628 && save_pst
->textlow
>= pst
->textlow
3629 && save_pst
->textlow
< pst
->texthigh
3630 && save_pst
->texthigh
> pst
->texthigh
)
3632 objfile
->flags
|= OBJF_REORDERED
;
3639 /* Now scan the FDRs for dependencies */
3640 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3642 fh
= f_idx
+ debug_info
->fdr
;
3643 pst
= fdr_to_pst
[f_idx
].pst
;
3645 if (pst
== (struct partial_symtab
*) NULL
)
3648 /* This should catch stabs-in-ecoff. */
3652 /* Skip the first file indirect entry as it is a self dependency
3653 for source files or a reverse .h -> .c dependency for header files. */
3654 pst
->number_of_dependencies
= 0;
3656 ((struct partial_symtab
**)
3657 obstack_alloc (&objfile
->psymbol_obstack
,
3659 * sizeof (struct partial_symtab
*))));
3660 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3664 (*swap_rfd_in
) (cur_bfd
,
3665 ((char *) debug_info
->external_rfd
3666 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3668 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3670 complaint (&symfile_complaints
, "bad file number %ld", rh
);
3674 /* Skip self dependencies of header files. */
3678 /* Do not add to dependeny list if psymtab was empty. */
3679 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*) NULL
)
3681 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
3685 /* Remove the dummy psymtab created for -O3 images above, if it is
3686 still empty, to enable the detection of stripped executables. */
3687 if (objfile
->psymtabs
->next
== NULL
3688 && objfile
->psymtabs
->number_of_dependencies
== 0
3689 && objfile
->psymtabs
->n_global_syms
== 0
3690 && objfile
->psymtabs
->n_static_syms
== 0)
3691 objfile
->psymtabs
= NULL
;
3692 do_cleanups (old_chain
);
3695 /* If the current psymbol has an enumerated type, we need to add
3696 all the the enum constants to the partial symbol table. */
3699 handle_psymbol_enumerators (struct objfile
*objfile
, FDR
*fh
, int stype
,
3702 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3703 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
3704 char *ext_sym
= ((char *) debug_info
->external_sym
3705 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3715 /* It is an enumerated type if the next symbol entry is a stMember
3716 and its auxiliary index is indexNil or its auxiliary entry
3717 is a plain btNil or btVoid.
3718 Alpha cc -migrate enums are recognized by a zero index and
3719 a zero symbol value.
3720 DU 4.0 cc enums are recognized by a member type of btEnum without
3721 qualifiers and a zero symbol value. */
3722 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3723 if (sh
.st
!= stMember
)
3726 if (sh
.index
== indexNil
3727 || (sh
.index
== 0 && svalue
== 0))
3729 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3730 &(debug_info
->external_aux
3731 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3733 if ((tir
.bt
!= btNil
3735 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3736 || tir
.tq0
!= tqNil
)
3748 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3749 if (sh
.st
!= stMember
)
3751 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3753 /* Note that the value doesn't matter for enum constants
3754 in psymtabs, just in symtabs. */
3755 add_psymbol_to_list (name
, strlen (name
),
3756 VAR_DOMAIN
, LOC_CONST
,
3757 &objfile
->static_psymbols
, 0,
3758 (CORE_ADDR
) 0, psymtab_language
, objfile
);
3759 ext_sym
+= external_sym_size
;
3763 /* Get the next symbol. OBJFILE is unused. */
3766 mdebug_next_symbol_text (struct objfile
*objfile
)
3771 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3772 ((char *) debug_info
->external_sym
3773 + ((cur_fdr
->isymBase
+ cur_sdx
)
3774 * debug_swap
->external_sym_size
)),
3776 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3779 /* Ancillary function to psymtab_to_symtab(). Does all the work
3780 for turning the partial symtab PST into a symtab, recurring
3781 first on all dependent psymtabs. The argument FILENAME is
3782 only passed so we can see in debug stack traces what file
3785 This function has a split personality, based on whether the
3786 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3787 The flow of control and even the memory allocation differs. FIXME. */
3790 psymtab_to_symtab_1 (struct partial_symtab
*pst
, char *filename
)
3792 bfd_size_type external_sym_size
;
3793 bfd_size_type external_pdr_size
;
3794 void (*swap_sym_in
) (bfd
*, void *, SYMR
*);
3795 void (*swap_pdr_in
) (bfd
*, void *, PDR
*);
3797 struct symtab
*st
= NULL
;
3799 struct linetable
*lines
;
3800 CORE_ADDR lowest_pdr_addr
= 0;
3801 int last_symtab_ended
= 0;
3807 /* Read in all partial symbtabs on which this one is dependent.
3808 NOTE that we do have circular dependencies, sigh. We solved
3809 that by setting pst->readin before this point. */
3811 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3812 if (!pst
->dependencies
[i
]->readin
)
3814 /* Inform about additional files to be read in. */
3817 fputs_filtered (" ", gdb_stdout
);
3819 fputs_filtered ("and ", gdb_stdout
);
3821 printf_filtered ("%s...",
3822 pst
->dependencies
[i
]->filename
);
3823 wrap_here (""); /* Flush output */
3824 gdb_flush (gdb_stdout
);
3826 /* We only pass the filename for debug purposes */
3827 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3828 pst
->dependencies
[i
]->filename
);
3831 /* Do nothing if this is a dummy psymtab. */
3833 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3834 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3837 /* Now read the symbols for this symtab */
3839 cur_bfd
= CUR_BFD (pst
);
3840 debug_swap
= DEBUG_SWAP (pst
);
3841 debug_info
= DEBUG_INFO (pst
);
3842 pending_list
= PENDING_LIST (pst
);
3843 external_sym_size
= debug_swap
->external_sym_size
;
3844 external_pdr_size
= debug_swap
->external_pdr_size
;
3845 swap_sym_in
= debug_swap
->swap_sym_in
;
3846 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3847 current_objfile
= pst
->objfile
;
3848 cur_fd
= FDR_IDX (pst
);
3849 fh
= ((cur_fd
== -1)
3851 : debug_info
->fdr
+ cur_fd
);
3854 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3855 processing_gcc_compilation
= 0;
3856 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3860 (*swap_sym_in
) (cur_bfd
,
3861 ((char *) debug_info
->external_sym
3862 + (fh
->isymBase
+ 1) * external_sym_size
),
3864 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3867 /* We indicate that this is a GCC compilation so that certain
3868 features will be enabled in stabsread/dbxread. */
3869 processing_gcc_compilation
= 2;
3873 if (processing_gcc_compilation
!= 0)
3876 /* This symbol table contains stabs-in-ecoff entries. */
3878 /* Parse local symbols first */
3880 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3882 current_objfile
= NULL
;
3885 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3891 (*swap_sym_in
) (cur_bfd
,
3892 (((char *) debug_info
->external_sym
)
3893 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3895 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3897 /* XXX This is a hack. It will go away! */
3898 if (ECOFF_IS_STAB (&sh
) || (name
[0] == '#'))
3900 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3902 /* We should never get non N_STAB symbols here, but they
3903 should be harmless, so keep process_one_symbol from
3904 complaining about them. */
3905 if (type_code
& N_STAB
)
3907 /* If we found a trailing N_SO with no name, process
3908 it here instead of in process_one_symbol, so we
3909 can keep a handle to its symtab. The symtab
3910 would otherwise be ended twice, once in
3911 process_one_symbol, and once after this loop. */
3912 if (type_code
== N_SO
3914 && previous_stab_code
!= (unsigned char) N_SO
3917 valu
+= ANOFFSET (pst
->section_offsets
,
3918 SECT_OFF_TEXT (pst
->objfile
));
3919 previous_stab_code
= N_SO
;
3920 st
= end_symtab (valu
, pst
->objfile
,
3921 SECT_OFF_TEXT (pst
->objfile
));
3923 last_symtab_ended
= 1;
3927 last_symtab_ended
= 0;
3928 process_one_symbol (type_code
, 0, valu
, name
,
3929 pst
->section_offsets
, pst
->objfile
);
3932 /* Similarly a hack. */
3933 else if (name
[0] == '#')
3935 process_one_symbol (N_SLINE
, 0, valu
, name
,
3936 pst
->section_offsets
, pst
->objfile
);
3938 if (type_code
== N_FUN
)
3940 /* Make up special symbol to contain
3941 procedure specific info */
3942 struct mips_extra_func_info
*e
=
3943 ((struct mips_extra_func_info
*)
3944 obstack_alloc (¤t_objfile
->symbol_obstack
,
3945 sizeof (struct mips_extra_func_info
)));
3946 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3948 memset (e
, 0, sizeof (struct mips_extra_func_info
));
3949 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
3950 SYMBOL_CLASS (s
) = LOC_CONST
;
3951 SYMBOL_TYPE (s
) = mdebug_type_void
;
3952 SYMBOL_VALUE (s
) = (long) e
;
3953 e
->pdr
.framereg
= -1;
3954 add_symbol_to_list (s
, &local_symbols
);
3957 else if (sh
.st
== stLabel
)
3959 if (sh
.index
== indexNil
)
3961 /* This is what the gcc2_compiled and __gnu_compiled_*
3962 show up as. So don't complain. */
3967 /* Handle encoded stab line number. */
3968 valu
+= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (pst
->objfile
));
3969 record_line (current_subfile
, sh
.index
, valu
);
3972 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3973 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3974 /* These are generated by gcc-2.x, do not complain */
3977 complaint (&symfile_complaints
, "unknown stabs symbol %s", name
);
3980 if (! last_symtab_ended
)
3982 st
= end_symtab (pst
->texthigh
, pst
->objfile
, SECT_OFF_TEXT (pst
->objfile
));
3986 /* There used to be a call to sort_blocks here, but this should not
3987 be necessary for stabs symtabs. And as sort_blocks modifies the
3988 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3989 it did the wrong thing if the first procedure in a file was
3990 generated via asm statements. */
3992 /* Fill in procedure info next. */
3996 struct cleanup
*old_chain
;
4002 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4003 old_chain
= make_cleanup (xfree
, pr_block
);
4005 pdr_ptr
= ((char *) debug_info
->external_pdr
4006 + fh
->ipdFirst
* external_pdr_size
);
4007 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4011 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4013 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4015 /* Determine lowest PDR address, the PDRs are not always
4017 if (pdr_in
== pr_block
)
4018 lowest_pdr_addr
= pdr_in
->adr
;
4019 else if (pdr_in
->adr
< lowest_pdr_addr
)
4020 lowest_pdr_addr
= pdr_in
->adr
;
4024 pdr_in_end
= pdr_in
+ fh
->cpd
;
4025 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4026 parse_procedure (pdr_in
, st
, pst
);
4028 do_cleanups (old_chain
);
4033 /* This symbol table contains ordinary ecoff entries. */
4042 st
= new_symtab ("unknown", 0, pst
->objfile
);
4046 maxlines
= 2 * fh
->cline
;
4047 st
= new_symtab (pst
->filename
, maxlines
, pst
->objfile
);
4049 /* The proper language was already determined when building
4050 the psymtab, use it. */
4051 st
->language
= PST_PRIVATE (pst
)->pst_language
;
4054 psymtab_language
= st
->language
;
4056 lines
= LINETABLE (st
);
4058 /* Get a new lexical context */
4060 push_parse_stack ();
4061 top_stack
->cur_st
= st
;
4062 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
4064 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
4065 BLOCK_END (top_stack
->cur_block
) = 0;
4066 top_stack
->blocktype
= stFile
;
4067 top_stack
->cur_type
= 0;
4068 top_stack
->procadr
= 0;
4069 top_stack
->numargs
= 0;
4070 found_ecoff_debugging_info
= 0;
4077 /* Parse local symbols first */
4078 sym_ptr
= ((char *) debug_info
->external_sym
4079 + fh
->isymBase
* external_sym_size
);
4080 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
4081 while (sym_ptr
< sym_end
)
4086 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
4087 c
= parse_symbol (&sh
,
4088 debug_info
->external_aux
+ fh
->iauxBase
,
4089 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4090 sym_ptr
+= c
* external_sym_size
;
4093 /* Linenumbers. At the end, check if we can save memory.
4094 parse_lines has to look ahead an arbitrary number of PDR
4095 structures, so we swap them all first. */
4099 struct cleanup
*old_chain
;
4105 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4107 old_chain
= make_cleanup (xfree
, pr_block
);
4109 pdr_ptr
= ((char *) debug_info
->external_pdr
4110 + fh
->ipdFirst
* external_pdr_size
);
4111 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4115 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4117 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4119 /* Determine lowest PDR address, the PDRs are not always
4121 if (pdr_in
== pr_block
)
4122 lowest_pdr_addr
= pdr_in
->adr
;
4123 else if (pdr_in
->adr
< lowest_pdr_addr
)
4124 lowest_pdr_addr
= pdr_in
->adr
;
4127 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
, lowest_pdr_addr
);
4128 if (lines
->nitems
< fh
->cline
)
4129 lines
= shrink_linetable (lines
);
4131 /* Fill in procedure info next. */
4133 pdr_in_end
= pdr_in
+ fh
->cpd
;
4134 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4135 parse_procedure (pdr_in
, 0, pst
);
4137 do_cleanups (old_chain
);
4141 LINETABLE (st
) = lines
;
4143 /* .. and our share of externals.
4144 XXX use the global list to speed up things here. how?
4145 FIXME, Maybe quit once we have found the right number of ext's? */
4146 top_stack
->cur_st
= st
;
4147 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
4149 top_stack
->blocktype
= stFile
;
4151 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
4152 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
4153 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4155 /* If there are undefined symbols, tell the user.
4156 The alpha has an undefined symbol for every symbol that is
4157 from a shared library, so tell the user only if verbose is on. */
4158 if (info_verbose
&& n_undef_symbols
)
4160 printf_filtered ("File %s contains %d unresolved references:",
4161 st
->filename
, n_undef_symbols
);
4162 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
4163 n_undef_vars
, n_undef_procs
, n_undef_labels
);
4164 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
4174 /* Now link the psymtab and the symtab. */
4177 current_objfile
= NULL
;
4180 /* Ancillary parsing procedures. */
4182 /* Return 1 if the symbol pointed to by SH has a cross reference
4183 to an opaque aggregate type, else 0. */
4186 has_opaque_xref (FDR
*fh
, SYMR
*sh
)
4193 if (sh
->index
== indexNil
)
4196 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
4197 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
4198 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
4202 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
4203 if (rn
->rfd
== 0xfff)
4204 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
4212 /* Lookup the type at relative index RN. Return it in TPP
4213 if found and in any event come up with its name PNAME.
4214 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4215 Return value says how many aux symbols we ate. */
4218 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. */
4219 char **pname
, int bigend
, char *sym_name
)
4228 struct mdebug_pending
*pend
;
4230 *tpp
= (struct type
*) NULL
;
4232 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
4234 /* Escape index means 'the next one' */
4235 if (rn
->rfd
== 0xfff)
4238 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
4245 /* mips cc uses a rf of -1 for opaque struct definitions.
4246 Set TYPE_FLAG_STUB for these types so that check_typedef will
4247 resolve them if the struct gets defined in another compilation unit. */
4250 *pname
= "<undefined>";
4251 *tpp
= init_type (type_code
, 0, TYPE_FLAG_STUB
, (char *) NULL
, current_objfile
);
4255 /* mips cc uses an escaped rn->index of 0 for struct return types
4256 of procedures that were compiled without -g. These will always remain
4258 if (rn
->rfd
== 0xfff && rn
->index
== 0)
4260 *pname
= "<undefined>";
4264 /* Find the relative file descriptor and the symbol in it. */
4265 fh
= get_rfd (fd
, rf
);
4266 xref_fd
= fh
- debug_info
->fdr
;
4268 if (rn
->index
>= fh
->csym
)
4270 /* File indirect entry is corrupt. */
4271 *pname
= "<illegal>";
4272 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4276 /* If we have processed this symbol then we left a forwarding
4277 pointer to the type in the pending list. If not, we`ll put
4278 it in a list of pending types, to be processed later when
4279 the file will be. In any event, we collect the name for the
4282 esh
= ((char *) debug_info
->external_sym
4283 + ((fh
->isymBase
+ rn
->index
)
4284 * debug_swap
->external_sym_size
));
4285 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
4287 /* Make sure that this type of cross reference can be handled. */
4288 if ((sh
.sc
!= scInfo
4289 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
4290 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
4291 && sh
.st
!= stEnum
))
4292 && (sh
.st
!= stBlock
|| !SC_IS_COMMON (sh
.sc
)))
4294 /* File indirect entry is corrupt. */
4295 *pname
= "<illegal>";
4296 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4300 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4302 pend
= is_pending_symbol (fh
, esh
);
4307 /* We have not yet seen this type. */
4309 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
4313 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4315 a) forward declarations of structs/unions/enums which are not
4316 defined in this compilation unit.
4317 For these the type will be void. This is a bad design decision
4318 as cross referencing across compilation units is impossible
4319 due to the missing name.
4320 b) forward declarations of structs/unions/enums/typedefs which
4321 are defined later in this file or in another file in the same
4322 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4323 Simply cross reference those again to get the true type.
4324 The forward references are not entered in the pending list and
4325 in the symbol table. */
4327 (*debug_swap
->swap_tir_in
) (bigend
,
4328 &(debug_info
->external_aux
4329 + fh
->iauxBase
+ sh
.index
)->a_ti
,
4331 if (tir
.tq0
!= tqNil
)
4332 complaint (&symfile_complaints
,
4333 "illegal tq0 in forward typedef for %s", sym_name
);
4337 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4339 *pname
= "<undefined>";
4346 (debug_info
->external_aux
4347 + fh
->iauxBase
+ sh
.index
+ 1),
4348 tpp
, type_code
, pname
,
4349 fh
->fBigendian
, sym_name
);
4353 /* Follow a forward typedef. This might recursively
4354 call cross_ref till we get a non typedef'ed type.
4355 FIXME: This is not correct behaviour, but gdb currently
4356 cannot handle typedefs without type copying. Type
4357 copying is impossible as we might have mutual forward
4358 references between two files and the copied type would not
4359 get filled in when we later parse its definition. */
4360 *tpp
= parse_type (xref_fd
,
4361 debug_info
->external_aux
+ fh
->iauxBase
,
4365 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4366 add_pending (fh
, esh
, *tpp
);
4370 complaint (&symfile_complaints
,
4371 "illegal bt %d in forward typedef for %s", tir
.bt
,
4373 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4379 else if (sh
.st
== stTypedef
)
4381 /* Parse the type for a normal typedef. This might recursively call
4382 cross_ref till we get a non typedef'ed type.
4383 FIXME: This is not correct behaviour, but gdb currently
4384 cannot handle typedefs without type copying. But type copying is
4385 impossible as we might have mutual forward references between
4386 two files and the copied type would not get filled in when
4387 we later parse its definition. */
4388 *tpp
= parse_type (xref_fd
,
4389 debug_info
->external_aux
+ fh
->iauxBase
,
4393 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4397 /* Cross reference to a struct/union/enum which is defined
4398 in another file in the same compilation unit but that file
4399 has not been parsed yet.
4400 Initialize the type only, it will be filled in when
4401 it's definition is parsed. */
4402 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
4404 add_pending (fh
, esh
, *tpp
);
4407 /* We used one auxent normally, two if we got a "next one" rf. */
4412 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4413 keeping the symtab sorted */
4415 static struct symbol
*
4416 mylookup_symbol (char *name
, struct block
*block
,
4417 domain_enum domain
, enum address_class
class)
4419 struct dict_iterator iter
;
4424 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
4426 if (DEPRECATED_SYMBOL_NAME (sym
)[0] == inc
4427 && SYMBOL_DOMAIN (sym
) == domain
4428 && SYMBOL_CLASS (sym
) == class
4429 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), name
) == 0)
4433 block
= BLOCK_SUPERBLOCK (block
);
4435 return mylookup_symbol (name
, block
, domain
, class);
4440 /* Add a new symbol S to a block B. */
4443 add_symbol (struct symbol
*s
, struct block
*b
)
4445 dict_add_symbol (BLOCK_DICT (b
), s
);
4448 /* Add a new block B to a symtab S */
4451 add_block (struct block
*b
, struct symtab
*s
)
4453 struct blockvector
*bv
= BLOCKVECTOR (s
);
4455 bv
= (struct blockvector
*) xrealloc ((void *) bv
,
4456 (sizeof (struct blockvector
)
4457 + BLOCKVECTOR_NBLOCKS (bv
)
4458 * sizeof (bv
->block
)));
4459 if (bv
!= BLOCKVECTOR (s
))
4460 BLOCKVECTOR (s
) = bv
;
4462 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
4465 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4466 MIPS' linenumber encoding might need more than one byte
4467 to describe it, LAST is used to detect these continuation lines.
4469 Combining lines with the same line number seems like a bad idea.
4470 E.g: There could be a line number entry with the same line number after the
4471 prologue and GDB should not ignore it (this is a better way to find
4472 a prologue than mips_skip_prologue).
4473 But due to the compressed line table format there are line number entries
4474 for the same line which are needed to bridge the gap to the next
4475 line number entry. These entries have a bogus address info with them
4476 and we are unable to tell them from intended duplicate line number
4478 This is another reason why -ggdb debugging format is preferable. */
4481 add_line (struct linetable
*lt
, int lineno
, CORE_ADDR adr
, int last
)
4483 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4484 Change them to something sensible. */
4488 last
= -2; /* make sure we record first line */
4490 if (last
== lineno
) /* skip continuation lines */
4493 lt
->item
[lt
->nitems
].line
= lineno
;
4494 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
4498 /* Sorting and reordering procedures */
4500 /* Blocks with a smaller low bound should come first */
4503 compare_blocks (const void *arg1
, const void *arg2
)
4506 struct block
**b1
= (struct block
**) arg1
;
4507 struct block
**b2
= (struct block
**) arg2
;
4509 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
4511 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
4515 /* Sort the blocks of a symtab S.
4516 Reorder the blocks in the blockvector by code-address,
4517 as required by some MI search routines */
4520 sort_blocks (struct symtab
*s
)
4522 struct blockvector
*bv
= BLOCKVECTOR (s
);
4524 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
4527 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
4528 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
4529 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
4530 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
4534 * This is very unfortunate: normally all functions are compiled in
4535 * the order they are found, but if the file is compiled -O3 things
4536 * are very different. It would be nice to find a reliable test
4537 * to detect -O3 images in advance.
4539 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
4540 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
4541 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
4542 sizeof (struct block
*),
4547 int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
4549 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
4550 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
4551 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
4552 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
4555 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
4556 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
4558 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4559 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4560 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4561 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4565 /* Constructor/restructor/destructor procedures */
4567 /* Allocate a new symtab for NAME. Needs an estimate of how many
4568 linenumbers MAXLINES we'll put in it */
4570 static struct symtab
*
4571 new_symtab (char *name
, int maxlines
, struct objfile
*objfile
)
4573 struct symtab
*s
= allocate_symtab (name
, objfile
);
4575 LINETABLE (s
) = new_linetable (maxlines
);
4577 /* All symtabs must have at least two blocks */
4578 BLOCKVECTOR (s
) = new_bvect (2);
4579 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
)
4580 = new_block (NON_FUNCTION_BLOCK
);
4581 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
4582 = new_block (NON_FUNCTION_BLOCK
);
4583 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
4584 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4586 s
->free_code
= free_linetable
;
4587 s
->debugformat
= obsavestring ("ECOFF", 5,
4588 &objfile
->symbol_obstack
);
4592 /* Allocate a new partial_symtab NAME */
4594 static struct partial_symtab
*
4595 new_psymtab (char *name
, struct objfile
*objfile
)
4597 struct partial_symtab
*psymtab
;
4599 psymtab
= allocate_psymtab (name
, objfile
);
4600 psymtab
->section_offsets
= objfile
->section_offsets
;
4602 /* Keep a backpointer to the file's symbols */
4604 psymtab
->read_symtab_private
= ((char *)
4605 obstack_alloc (&objfile
->psymbol_obstack
,
4606 sizeof (struct symloc
)));
4607 memset (psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
4608 CUR_BFD (psymtab
) = cur_bfd
;
4609 DEBUG_SWAP (psymtab
) = debug_swap
;
4610 DEBUG_INFO (psymtab
) = debug_info
;
4611 PENDING_LIST (psymtab
) = pending_list
;
4613 /* The way to turn this into a symtab is to call... */
4614 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
4619 /* Allocate a linetable array of the given SIZE. Since the struct
4620 already includes one item, we subtract one when calculating the
4621 proper size to allocate. */
4623 static struct linetable
*
4624 new_linetable (int size
)
4626 struct linetable
*l
;
4628 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
4629 l
= (struct linetable
*) xmalloc (size
);
4634 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4635 I am not so sure about the 3.4 ones.
4637 Since the struct linetable already includes one item, we subtract one when
4638 calculating the proper size to allocate. */
4640 static struct linetable
*
4641 shrink_linetable (struct linetable
*lt
)
4644 return (struct linetable
*) xrealloc ((void *) lt
,
4645 (sizeof (struct linetable
)
4647 * sizeof (lt
->item
))));
4650 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4652 static struct blockvector
*
4653 new_bvect (int nblocks
)
4655 struct blockvector
*bv
;
4658 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4659 bv
= (struct blockvector
*) xzalloc (size
);
4661 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4666 /* Allocate and zero a new block, and set its BLOCK_DICT. If function
4667 is non-zero, assume the block is associated to a function, and make
4668 sure that the symbols are stored linearly; otherwise, store them
4671 static struct block
*
4672 new_block (enum block_type type
)
4674 /* FIXME: carlton/2003-09-11: This should use allocate_block to
4675 allocate the block. Which, in turn, suggests that the block
4676 should be allocated on an obstack. */
4677 struct block
*retval
= xzalloc (sizeof (struct block
));
4679 if (type
== FUNCTION_BLOCK
)
4680 BLOCK_DICT (retval
) = dict_create_linear_expandable ();
4682 BLOCK_DICT (retval
) = dict_create_hashed_expandable ();
4687 /* Create a new symbol with printname NAME */
4689 static struct symbol
*
4690 new_symbol (char *name
)
4692 struct symbol
*s
= ((struct symbol
*)
4693 obstack_alloc (¤t_objfile
->symbol_obstack
,
4694 sizeof (struct symbol
)));
4696 memset (s
, 0, sizeof (*s
));
4697 SYMBOL_LANGUAGE (s
) = psymtab_language
;
4698 SYMBOL_SET_NAMES (s
, name
, strlen (name
), current_objfile
);
4702 /* Create a new type with printname NAME */
4704 static struct type
*
4705 new_type (char *name
)
4709 t
= alloc_type (current_objfile
);
4710 TYPE_NAME (t
) = name
;
4711 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
4715 /* Read ECOFF debugging information from a BFD section. This is
4716 called from elfread.c. It parses the section into a
4717 ecoff_debug_info struct, and then lets the rest of the file handle
4721 elfmdebug_build_psymtabs (struct objfile
*objfile
,
4722 const struct ecoff_debug_swap
*swap
, asection
*sec
)
4724 bfd
*abfd
= objfile
->obfd
;
4725 struct ecoff_debug_info
*info
;
4726 struct cleanup
*back_to
;
4728 /* FIXME: It's not clear whether we should be getting minimal symbol
4729 information from .mdebug in an ELF file, or whether we will.
4730 Re-initialize the minimal symbol reader in case we do. */
4732 init_minimal_symbol_collection ();
4733 back_to
= make_cleanup_discard_minimal_symbols ();
4735 info
= ((struct ecoff_debug_info
*)
4736 obstack_alloc (&objfile
->psymbol_obstack
,
4737 sizeof (struct ecoff_debug_info
)));
4739 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4740 error ("Error reading ECOFF debugging information: %s",
4741 bfd_errmsg (bfd_get_error ()));
4743 mdebug_build_psymtabs (objfile
, swap
, info
);
4745 install_minimal_symbols (objfile
);
4746 do_cleanups (back_to
);
4750 /* Things used for calling functions in the inferior.
4751 These functions are exported to our companion
4752 mips-tdep.c file and are here because they play
4753 with the symbol-table explicitly. */
4755 /* Sigtramp: make sure we have all the necessary information
4756 about the signal trampoline code. Since the official code
4757 from MIPS does not do so, we make up that information ourselves.
4758 If they fix the library (unlikely) this code will neutralize itself. */
4760 /* FIXME: This function is called only by mips-tdep.c. It needs to be
4761 here because it calls functions defined in this file, but perhaps
4762 this could be handled in a better way. Only compile it in when
4763 tm-mips.h is included. */
4768 fixup_sigtramp (void)
4772 struct block
*b
, *b0
= NULL
;
4774 sigtramp_address
= -1;
4776 /* We have to handle the following cases here:
4777 a) The Mips library has a sigtramp label within sigvec.
4778 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
4779 s
= lookup_symbol ("sigvec", 0, VAR_DOMAIN
, 0, NULL
);
4782 b0
= SYMBOL_BLOCK_VALUE (s
);
4783 s
= lookup_symbol ("sigtramp", b0
, VAR_DOMAIN
, 0, NULL
);
4787 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
4788 s
= lookup_symbol ("_sigtramp", 0, VAR_DOMAIN
, 0, NULL
);
4791 /* But maybe this program uses its own version of sigvec */
4795 /* Did we or MIPSco fix the library ? */
4796 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
4798 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
4799 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
4803 sigtramp_address
= SYMBOL_VALUE (s
);
4804 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
4806 /* But what symtab does it live in ? */
4807 st
= find_pc_symtab (SYMBOL_VALUE (s
));
4810 * Ok, there goes the fix: turn it into a procedure, with all the
4811 * needed info. Note we make it a nested procedure of sigvec,
4812 * which is the way the (assembly) code is actually written.
4814 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
4815 SYMBOL_CLASS (s
) = LOC_BLOCK
;
4816 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
4818 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = mdebug_type_void
;
4820 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4821 b
= new_block (NON_FUNCTION_BLOCK
);
4822 SYMBOL_BLOCK_VALUE (s
) = b
;
4823 BLOCK_START (b
) = sigtramp_address
;
4824 BLOCK_END (b
) = sigtramp_end
;
4825 BLOCK_FUNCTION (b
) = s
;
4826 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
4830 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4832 struct mips_extra_func_info
*e
=
4833 ((struct mips_extra_func_info
*)
4834 xzalloc (sizeof (struct mips_extra_func_info
)));
4836 e
->numargs
= 0; /* the kernel thinks otherwise */
4837 e
->pdr
.frameoffset
= 32;
4838 e
->pdr
.framereg
= SP_REGNUM
;
4839 /* Note that setting pcreg is no longer strictly necessary as
4840 mips_frame_saved_pc is now aware of signal handler frames. */
4841 e
->pdr
.pcreg
= PC_REGNUM
;
4842 e
->pdr
.regmask
= -2;
4843 /* Offset to saved r31, in the sigtramp case the saved registers
4844 are above the frame in the sigcontext.
4845 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4846 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4847 and 32 * 4 bytes for the floating point registers. */
4848 e
->pdr
.regoffset
= 4 + 12 + 31 * 4;
4849 e
->pdr
.fregmask
= -1;
4850 /* Offset to saved f30 (first saved *double* register). */
4851 e
->pdr
.fregoffset
= 4 + 12 + 32 * 4 + 12 + 30 * 4;
4852 e
->pdr
.isym
= (long) s
;
4853 e
->pdr
.adr
= sigtramp_address
;
4855 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
4856 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
4857 SYMBOL_VALUE (s
) = (long) e
;
4858 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
4859 SYMBOL_CLASS (s
) = LOC_CONST
;
4860 SYMBOL_TYPE (s
) = mdebug_type_void
;
4861 current_objfile
= NULL
;
4864 dict_add_symbol (BLOCK_DICT (b
), s
);
4867 #endif /* TM_MIPS_H */
4870 _initialize_mdebugread (void)
4873 init_type (TYPE_CODE_VOID
, 1,
4875 "void", (struct objfile
*) NULL
);
4877 init_type (TYPE_CODE_INT
, 1,
4879 "char", (struct objfile
*) NULL
);
4880 mdebug_type_unsigned_char
=
4881 init_type (TYPE_CODE_INT
, 1,
4883 "unsigned char", (struct objfile
*) NULL
);
4885 init_type (TYPE_CODE_INT
, 2,
4887 "short", (struct objfile
*) NULL
);
4888 mdebug_type_unsigned_short
=
4889 init_type (TYPE_CODE_INT
, 2,
4891 "unsigned short", (struct objfile
*) NULL
);
4892 mdebug_type_int_32
=
4893 init_type (TYPE_CODE_INT
, 4,
4895 "int", (struct objfile
*) NULL
);
4896 mdebug_type_unsigned_int_32
=
4897 init_type (TYPE_CODE_INT
, 4,
4899 "unsigned int", (struct objfile
*) NULL
);
4900 mdebug_type_int_64
=
4901 init_type (TYPE_CODE_INT
, 8,
4903 "int", (struct objfile
*) NULL
);
4904 mdebug_type_unsigned_int_64
=
4905 init_type (TYPE_CODE_INT
, 8,
4907 "unsigned int", (struct objfile
*) NULL
);
4908 mdebug_type_long_32
=
4909 init_type (TYPE_CODE_INT
, 4,
4911 "long", (struct objfile
*) NULL
);
4912 mdebug_type_unsigned_long_32
=
4913 init_type (TYPE_CODE_INT
, 4,
4915 "unsigned long", (struct objfile
*) NULL
);
4916 mdebug_type_long_64
=
4917 init_type (TYPE_CODE_INT
, 8,
4919 "long", (struct objfile
*) NULL
);
4920 mdebug_type_unsigned_long_64
=
4921 init_type (TYPE_CODE_INT
, 8,
4923 "unsigned long", (struct objfile
*) NULL
);
4924 mdebug_type_long_long_64
=
4925 init_type (TYPE_CODE_INT
, 8,
4927 "long long", (struct objfile
*) NULL
);
4928 mdebug_type_unsigned_long_long_64
=
4929 init_type (TYPE_CODE_INT
, 8,
4931 "unsigned long long", (struct objfile
*) NULL
);
4932 mdebug_type_adr_32
=
4933 init_type (TYPE_CODE_PTR
, 4,
4935 "adr_32", (struct objfile
*) NULL
);
4936 TYPE_TARGET_TYPE (mdebug_type_adr_32
) = mdebug_type_void
;
4937 mdebug_type_adr_64
=
4938 init_type (TYPE_CODE_PTR
, 8,
4940 "adr_64", (struct objfile
*) NULL
);
4941 TYPE_TARGET_TYPE (mdebug_type_adr_64
) = mdebug_type_void
;
4943 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4945 "float", (struct objfile
*) NULL
);
4946 mdebug_type_double
=
4947 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4949 "double", (struct objfile
*) NULL
);
4950 mdebug_type_complex
=
4951 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4953 "complex", (struct objfile
*) NULL
);
4954 TYPE_TARGET_TYPE (mdebug_type_complex
) = mdebug_type_float
;
4955 mdebug_type_double_complex
=
4956 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4958 "double complex", (struct objfile
*) NULL
);
4959 TYPE_TARGET_TYPE (mdebug_type_double_complex
) = mdebug_type_double
;
4961 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4963 mdebug_type_string
=
4964 init_type (TYPE_CODE_STRING
,
4965 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4967 (struct objfile
*) NULL
);
4969 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4970 good? Would we be better off with TYPE_CODE_ERROR? Should
4971 TYPE_CODE_ERROR print things in hex if it knows the size? */
4972 mdebug_type_fixed_dec
=
4973 init_type (TYPE_CODE_INT
,
4974 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4976 (struct objfile
*) NULL
);
4978 mdebug_type_float_dec
=
4979 init_type (TYPE_CODE_ERROR
,
4980 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4981 0, "floating decimal",
4982 (struct objfile
*) NULL
);
4984 nodebug_func_symbol_type
= init_type (TYPE_CODE_FUNC
, 1, 0,
4985 "<function, no debug info>", NULL
);
4986 TYPE_TARGET_TYPE (nodebug_func_symbol_type
) = mdebug_type_int
;
4987 nodebug_var_symbol_type
=
4988 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4989 "<variable, no debug info>", NULL
);