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
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 /* These are needed if the tm.h file does not contain the necessary
58 mips specific definitions. */
60 #ifndef MIPS_EFI_SYMBOL_NAME
61 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
62 extern void ecoff_relocate_efi (struct symbol
*, CORE_ADDR
);
64 #include "coff/symconst.h"
65 typedef struct mips_extra_func_info
70 *mips_extra_func_info_t
;
77 #include <sys/types.h>
81 #include "gdb_string.h"
85 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
87 #include "libaout.h" /* Private BFD a.out information. */
88 #include "aout/aout64.h"
89 #include "aout/stab_gnu.h" /* STABS information */
91 #include "expression.h"
92 #include "language.h" /* For local_hex_string() */
94 extern void _initialize_mdebugread (void);
96 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
97 We use this define in order to know whether we should override a
98 symbol's ECOFF section with its ELF section. This is necessary in
99 case the symbol's ELF section could not be represented in ECOFF. */
100 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
101 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
104 /* We put a pointer to this structure in the read_symtab_private field
109 /* Index of the FDR that this psymtab represents. */
111 /* The BFD that the psymtab was created from. */
113 const struct ecoff_debug_swap
*debug_swap
;
114 struct ecoff_debug_info
*debug_info
;
115 struct mdebug_pending
**pending_list
;
116 /* Pointer to external symbols for this file. */
118 /* Size of extern_tab. */
120 enum language pst_language
;
123 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
124 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
125 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
126 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
127 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
128 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
130 #define SC_IS_TEXT(sc) ((sc) == scText \
131 || (sc) == scRConst \
134 #define SC_IS_DATA(sc) ((sc) == scData \
139 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
140 #define SC_IS_BSS(sc) ((sc) == scBss)
141 #define SC_IS_SBSS(sc) ((sc) == scSBss)
142 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
144 /* Various complaints about symbol reading that don't abort the process */
146 static struct complaint bad_file_number_complaint
=
147 {"bad file number %d", 0, 0};
149 static struct complaint index_complaint
=
150 {"bad aux index at symbol %s", 0, 0};
152 static struct complaint aux_index_complaint
=
153 {"bad proc end in aux found from symbol %s", 0, 0};
155 static struct complaint block_index_complaint
=
156 {"bad aux index at block symbol %s", 0, 0};
158 static struct complaint unknown_ext_complaint
=
159 {"unknown external symbol %s", 0, 0};
161 static struct complaint unknown_sym_complaint
=
162 {"unknown local symbol %s", 0, 0};
164 static struct complaint unknown_st_complaint
=
165 {"with type %d", 0, 0};
167 static struct complaint block_overflow_complaint
=
168 {"block containing %s overfilled", 0, 0};
170 static struct complaint basic_type_complaint
=
171 {"cannot map ECOFF basic type 0x%x for %s", 0, 0};
173 static struct complaint unknown_type_qual_complaint
=
174 {"unknown type qualifier 0x%x", 0, 0};
176 static struct complaint array_index_type_complaint
=
177 {"illegal array index type for %s, assuming int", 0, 0};
179 static struct complaint bad_tag_guess_complaint
=
180 {"guessed tag type of %s incorrectly", 0, 0};
182 static struct complaint block_member_complaint
=
183 {"declaration block contains unhandled symbol type %d", 0, 0};
185 static struct complaint stEnd_complaint
=
186 {"stEnd with storage class %d not handled", 0, 0};
188 static struct complaint unknown_mdebug_symtype_complaint
=
189 {"unknown symbol type 0x%x", 0, 0};
191 static struct complaint stab_unknown_complaint
=
192 {"unknown stabs symbol %s", 0, 0};
194 static struct complaint pdr_for_nonsymbol_complaint
=
195 {"PDR for %s, but no symbol", 0, 0};
197 static struct complaint pdr_static_symbol_complaint
=
198 {"can't handle PDR for static proc at 0x%lx", 0, 0};
200 static struct complaint bad_setjmp_pdr_complaint
=
201 {"fixing bad setjmp PDR from libc", 0, 0};
203 static struct complaint bad_fbitfield_complaint
=
204 {"can't handle TIR fBitfield for %s", 0, 0};
206 static struct complaint bad_continued_complaint
=
207 {"illegal TIR continued for %s", 0, 0};
209 static struct complaint bad_rfd_entry_complaint
=
210 {"bad rfd entry for %s: file %d, index %d", 0, 0};
212 static struct complaint unexpected_type_code_complaint
=
213 {"unexpected type code for %s", 0, 0};
215 static struct complaint unable_to_cross_ref_complaint
=
216 {"unable to cross ref btTypedef for %s", 0, 0};
218 static struct complaint bad_indirect_xref_complaint
=
219 {"unable to cross ref btIndirect for %s", 0, 0};
221 static struct complaint illegal_forward_tq0_complaint
=
222 {"illegal tq0 in forward typedef for %s", 0, 0};
224 static struct complaint illegal_forward_bt_complaint
=
225 {"illegal bt %d in forward typedef for %s", 0, 0};
227 static struct complaint bad_linetable_guess_complaint
=
228 {"guessed size of linetable for %s incorrectly", 0, 0};
230 static struct complaint bad_ext_ifd_complaint
=
231 {"bad ifd for external symbol: %d (max %d)", 0, 0};
233 static struct complaint bad_ext_iss_complaint
=
234 {"bad iss for external symbol: %ld (max %ld)", 0, 0};
236 /* Macros and extra defs */
238 /* Puns: hard to find whether -g was used and how */
240 #define MIN_GLEVEL GLEVEL_0
241 #define compare_glevel(a,b) \
242 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
243 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
245 /* Things that really are local to this module */
247 /* Remember what we deduced to be the source language of this psymtab. */
249 static enum language psymtab_language
= language_unknown
;
255 /* How to parse debugging information for CUR_BFD. */
257 static const struct ecoff_debug_swap
*debug_swap
;
259 /* Pointers to debugging information for CUR_BFD. */
261 static struct ecoff_debug_info
*debug_info
;
263 /* Pointer to current file decriptor record, and its index */
268 /* Index of current symbol */
272 /* Note how much "debuggable" this image is. We would like
273 to see at least one FDR with full symbols */
275 static int max_gdbinfo
;
276 static int max_glevel
;
278 /* When examining .o files, report on undefined symbols */
280 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
282 /* Pseudo symbol to use when putting stabs into the symbol table. */
284 static char stabs_symbol
[] = STABS_SYMBOL
;
286 /* Types corresponding to mdebug format bt* basic types. */
288 static struct type
*mdebug_type_void
;
289 static struct type
*mdebug_type_char
;
290 static struct type
*mdebug_type_short
;
291 static struct type
*mdebug_type_int_32
;
292 #define mdebug_type_int mdebug_type_int_32
293 static struct type
*mdebug_type_int_64
;
294 static struct type
*mdebug_type_long_32
;
295 static struct type
*mdebug_type_long_64
;
296 static struct type
*mdebug_type_long_long_64
;
297 static struct type
*mdebug_type_unsigned_char
;
298 static struct type
*mdebug_type_unsigned_short
;
299 static struct type
*mdebug_type_unsigned_int_32
;
300 static struct type
*mdebug_type_unsigned_int_64
;
301 static struct type
*mdebug_type_unsigned_long_32
;
302 static struct type
*mdebug_type_unsigned_long_64
;
303 static struct type
*mdebug_type_unsigned_long_long_64
;
304 static struct type
*mdebug_type_adr_32
;
305 static struct type
*mdebug_type_adr_64
;
306 static struct type
*mdebug_type_float
;
307 static struct type
*mdebug_type_double
;
308 static struct type
*mdebug_type_complex
;
309 static struct type
*mdebug_type_double_complex
;
310 static struct type
*mdebug_type_fixed_dec
;
311 static struct type
*mdebug_type_float_dec
;
312 static struct type
*mdebug_type_string
;
314 /* Types for symbols from files compiled without debugging info. */
316 static struct type
*nodebug_func_symbol_type
;
317 static struct type
*nodebug_var_symbol_type
;
319 /* Nonzero if we have seen ecoff debugging info for a file. */
321 static int found_ecoff_debugging_info
;
323 /* Forward declarations */
325 static int upgrade_type (int, struct type
**, int, union aux_ext
*,
328 static void parse_partial_symbols (struct objfile
*);
330 static int has_opaque_xref (FDR
*, SYMR
*);
332 static int cross_ref (int, union aux_ext
*, struct type
**, enum type_code
,
333 char **, int, char *);
335 static struct symbol
*new_symbol (char *);
337 static struct type
*new_type (char *);
339 static struct block
*new_block (int);
341 static struct symtab
*new_symtab (char *, int, int, struct objfile
*);
343 static struct linetable
*new_linetable (int);
345 static struct blockvector
*new_bvect (int);
347 static struct type
*parse_type (int, union aux_ext
*, unsigned int, int *,
350 static struct symbol
*mylookup_symbol (char *, struct block
*, namespace_enum
,
353 static struct block
*shrink_block (struct block
*, struct symtab
*);
355 static void sort_blocks (struct symtab
*);
357 static struct partial_symtab
*new_psymtab (char *, struct objfile
*);
359 static void psymtab_to_symtab_1 (struct partial_symtab
*, char *);
361 static void add_block (struct block
*, struct symtab
*);
363 static void add_symbol (struct symbol
*, struct block
*);
365 static int add_line (struct linetable
*, int, CORE_ADDR
, int);
367 static struct linetable
*shrink_linetable (struct linetable
*);
369 static void handle_psymbol_enumerators (struct objfile
*, FDR
*, int,
372 static char *mdebug_next_symbol_text (struct objfile
*);
374 /* Address bounds for the signal trampoline in inferior, if any */
376 CORE_ADDR sigtramp_address
, sigtramp_end
;
378 /* Allocate zeroed memory */
381 xzalloc (unsigned int size
)
383 void *p
= xmalloc (size
);
389 /* Exported procedure: Builds a symtab from the PST partial one.
390 Restores the environment in effect when PST was created, delegates
391 most of the work to an ancillary procedure, and sorts
392 and reorders the symtab list at the end */
395 mdebug_psymtab_to_symtab (struct partial_symtab
*pst
)
403 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
404 gdb_flush (gdb_stdout
);
407 next_symbol_text_func
= mdebug_next_symbol_text
;
409 psymtab_to_symtab_1 (pst
, pst
->filename
);
411 /* Match with global symbols. This only needs to be done once,
412 after all of the symtabs and dependencies have been read in. */
413 scan_file_globals (pst
->objfile
);
416 printf_filtered ("done.\n");
419 /* File-level interface functions */
421 /* Find a file descriptor given its index RF relative to a file CF */
424 get_rfd (int cf
, int rf
)
430 fdrs
= debug_info
->fdr
;
432 /* Object files do not have the RFD table, all refs are absolute */
435 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
436 ((char *) debug_info
->external_rfd
438 * debug_swap
->external_rfd_size
)),
443 /* Return a safer print NAME for a file descriptor */
449 return "<stripped file>";
452 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
456 /* Read in and parse the symtab of the file OBJFILE. Symbols from
457 different sections are relocated via the SECTION_OFFSETS. */
460 mdebug_build_psymtabs (struct objfile
*objfile
,
461 const struct ecoff_debug_swap
*swap
,
462 struct ecoff_debug_info
*info
)
464 cur_bfd
= objfile
->obfd
;
468 stabsread_new_init ();
469 buildsym_new_init ();
470 free_header_files ();
471 init_header_files ();
473 /* Make sure all the FDR information is swapped in. */
474 if (info
->fdr
== (FDR
*) NULL
)
480 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->psymbol_obstack
,
481 (info
->symbolic_header
.ifdMax
483 fdr_src
= info
->external_fdr
;
485 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
487 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
488 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
491 parse_partial_symbols (objfile
);
494 /* Check to make sure file was compiled with -g. If not, warn the
495 user of this limitation. */
496 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
498 if (max_gdbinfo
== 0)
499 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
501 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
502 gdb_flush (gdb_stdout
);
507 /* Local utilities */
509 /* Map of FDR indexes to partial symtabs */
513 struct partial_symtab
*pst
; /* the psymtab proper */
514 long n_globals
; /* exported globals (external symbols) */
515 long globals_offset
; /* cumulative */
519 /* Utility stack, used to nest procedures and blocks properly.
520 It is a doubly linked list, to avoid too many alloc/free.
521 Since we might need it quite a few times it is NOT deallocated
524 static struct parse_stack
526 struct parse_stack
*next
, *prev
;
527 struct symtab
*cur_st
; /* Current symtab. */
528 struct block
*cur_block
; /* Block in it. */
530 /* What are we parsing. stFile, or stBlock are for files and
531 blocks. stProc or stStaticProc means we have seen the start of a
532 procedure, but not the start of the block within in. When we see
533 the start of that block, we change it to stNil, without pushing a
534 new block, i.e. stNil means both a procedure and a block. */
538 int maxsyms
; /* Max symbols in this block. */
539 struct type
*cur_type
; /* Type we parse fields for. */
540 int cur_field
; /* Field number in cur_type. */
541 CORE_ADDR procadr
; /* Start addres of this procedure */
542 int numargs
; /* Its argument count */
545 *top_stack
; /* Top stack ptr */
548 /* Enter a new lexical context */
551 push_parse_stack (void)
553 struct parse_stack
*new;
555 /* Reuse frames if possible */
556 if (top_stack
&& top_stack
->prev
)
557 new = top_stack
->prev
;
559 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
560 /* Initialize new frame with previous content */
563 register struct parse_stack
*prev
= new->prev
;
566 top_stack
->prev
= new;
568 new->next
= top_stack
;
573 /* Exit a lexical context */
576 pop_parse_stack (void)
581 top_stack
= top_stack
->next
;
585 /* Cross-references might be to things we haven't looked at
586 yet, e.g. type references. To avoid too many type
587 duplications we keep a quick fixup table, an array
588 of lists of references indexed by file descriptor */
590 struct mdebug_pending
592 struct mdebug_pending
*next
; /* link */
593 char *s
; /* the unswapped symbol */
594 struct type
*t
; /* its partial type descriptor */
598 /* The pending information is kept for an entire object file, and used
599 to be in the sym_private field. I took it out when I split
600 mdebugread from mipsread, because this might not be the only type
601 of symbols read from an object file. Instead, we allocate the
602 pending information table when we create the partial symbols, and
603 we store a pointer to the single table in each psymtab. */
605 static struct mdebug_pending
**pending_list
;
607 /* Check whether we already saw symbol SH in file FH */
609 static struct mdebug_pending
*
610 is_pending_symbol (FDR
*fh
, char *sh
)
612 int f_idx
= fh
- debug_info
->fdr
;
613 register struct mdebug_pending
*p
;
615 /* Linear search is ok, list is typically no more than 10 deep */
616 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
622 /* Add a new symbol SH of type T */
625 add_pending (FDR
*fh
, char *sh
, struct type
*t
)
627 int f_idx
= fh
- debug_info
->fdr
;
628 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
630 /* Make sure we do not make duplicates */
633 p
= ((struct mdebug_pending
*)
634 obstack_alloc (¤t_objfile
->psymbol_obstack
,
635 sizeof (struct mdebug_pending
)));
638 p
->next
= pending_list
[f_idx
];
639 pending_list
[f_idx
] = p
;
644 /* Parsing Routines proper. */
646 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
647 For blocks, procedures and types we open a new lexical context.
648 This is basically just a big switch on the symbol's type. Argument
649 AX is the base pointer of aux symbols for this file (fh->iauxBase).
650 EXT_SH points to the unswapped symbol, which is needed for struct,
651 union, etc., types; it is NULL for an EXTR. BIGEND says whether
652 aux symbols are big-endian or little-endian. Return count of
653 SYMR's handled (normally one). */
656 parse_symbol (SYMR
*sh
, union aux_ext
*ax
, char *ext_sh
, int bigend
,
657 struct section_offsets
*section_offsets
, struct objfile
*objfile
)
659 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
660 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
664 struct mdebug_pending
*pend
;
668 enum address_class
class;
670 long svalue
= sh
->value
;
673 if (ext_sh
== (char *) NULL
)
674 name
= debug_info
->ssext
+ sh
->iss
;
676 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
682 /* Do not relocate relative values.
683 The value of a stEnd symbol is the displacement from the
684 corresponding start symbol value.
685 The value of a stBlock symbol is the displacement from the
686 procedure address. */
687 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
688 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
695 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
699 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS (objfile
));
708 case stGlobal
: /* external symbol, goes into global block */
710 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
712 s
= new_symbol (name
);
713 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
716 case stStatic
: /* static data, goes into current block. */
718 b
= top_stack
->cur_block
;
719 s
= new_symbol (name
);
720 if (SC_IS_COMMON (sh
->sc
))
722 /* It is a FORTRAN common block. At least for SGI Fortran the
723 address is not in the symbol; we need to fix it later in
724 scan_file_globals. */
725 int bucket
= hashname (SYMBOL_NAME (s
));
726 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
727 global_sym_chain
[bucket
] = s
;
730 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
733 case stLocal
: /* local variable, goes into current block */
734 if (sh
->sc
== scRegister
)
736 class = LOC_REGISTER
;
737 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
741 b
= top_stack
->cur_block
;
742 s
= new_symbol (name
);
743 SYMBOL_VALUE (s
) = svalue
;
745 data
: /* Common code for symbols describing data */
746 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
747 SYMBOL_CLASS (s
) = class;
750 /* Type could be missing if file is compiled without debugging info. */
751 if (SC_IS_UNDEF (sh
->sc
)
752 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
753 SYMBOL_TYPE (s
) = nodebug_var_symbol_type
;
755 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
756 /* Value of a data symbol is its memory address */
759 case stParam
: /* arg to procedure, goes into current block */
761 found_ecoff_debugging_info
= 1;
762 top_stack
->numargs
++;
764 /* Special GNU C++ name. */
765 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
766 name
= "this"; /* FIXME, not alloc'd in obstack */
767 s
= new_symbol (name
);
769 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
773 /* Pass by value in register. */
774 SYMBOL_CLASS (s
) = LOC_REGPARM
;
775 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
778 /* Pass by reference on stack. */
779 SYMBOL_CLASS (s
) = LOC_REF_ARG
;
782 /* Pass by reference in register. */
783 SYMBOL_CLASS (s
) = LOC_REGPARM_ADDR
;
784 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
787 /* Pass by value on stack. */
788 SYMBOL_CLASS (s
) = LOC_ARG
;
791 SYMBOL_VALUE (s
) = svalue
;
792 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
793 add_symbol (s
, top_stack
->cur_block
);
796 case stLabel
: /* label, goes into current block */
797 s
= new_symbol (name
);
798 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
799 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
800 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
801 SYMBOL_TYPE (s
) = mdebug_type_int
;
802 add_symbol (s
, top_stack
->cur_block
);
805 case stProc
: /* Procedure, usually goes into global block */
806 case stStaticProc
: /* Static procedure, goes into current block */
807 s
= new_symbol (name
);
808 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
809 SYMBOL_CLASS (s
) = LOC_BLOCK
;
810 /* Type of the return value */
811 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
815 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
816 if (STREQ (name
, "malloc") && TYPE_CODE (t
) == TYPE_CODE_VOID
)
818 /* I don't know why, but, at least under Alpha GNU/Linux,
819 when linking against a malloc without debugging
820 symbols, its read as a function returning void---this
821 is bad because it means we cannot call functions with
822 string arguments interactively; i.e., "call
823 printf("howdy\n")" would fail with the error message
824 "program has no memory available". To avoid this, we
825 patch up the type and make it void*
826 instead. (davidm@azstarnet.com)
828 t
= make_pointer_type (t
, NULL
);
831 b
= top_stack
->cur_block
;
832 if (sh
->st
== stProc
)
834 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
835 /* The next test should normally be true, but provides a
836 hook for nested functions (which we don't want to make
838 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
839 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
840 /* Irix 5 sometimes has duplicate names for the same
841 function. We want to add such names up at the global
842 level, not as a nested function. */
843 else if (sh
->value
== top_stack
->procadr
)
844 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
848 /* Make a type for the procedure itself */
849 SYMBOL_TYPE (s
) = lookup_function_type (t
);
851 /* Create and enter a new lexical context */
852 b
= new_block (top_stack
->maxsyms
);
853 SYMBOL_BLOCK_VALUE (s
) = b
;
854 BLOCK_FUNCTION (b
) = s
;
855 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
856 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
857 add_block (b
, top_stack
->cur_st
);
859 /* Not if we only have partial info */
860 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
864 top_stack
->cur_block
= b
;
865 top_stack
->blocktype
= sh
->st
;
866 top_stack
->cur_type
= SYMBOL_TYPE (s
);
867 top_stack
->cur_field
= -1;
868 top_stack
->procadr
= sh
->value
;
869 top_stack
->numargs
= 0;
872 /* Beginning of code for structure, union, and enum definitions.
873 They all share a common set of local variables, defined here. */
875 enum type_code type_code
;
881 case stStruct
: /* Start a block defining a struct type */
882 type_code
= TYPE_CODE_STRUCT
;
883 goto structured_common
;
885 case stUnion
: /* Start a block defining a union type */
886 type_code
= TYPE_CODE_UNION
;
887 goto structured_common
;
889 case stEnum
: /* Start a block defining an enum type */
890 type_code
= TYPE_CODE_ENUM
;
891 goto structured_common
;
893 case stBlock
: /* Either a lexical block, or some type */
894 if (sh
->sc
!= scInfo
&& !SC_IS_COMMON (sh
->sc
))
895 goto case_stBlock_code
; /* Lexical block */
897 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
899 /* Common code for handling struct, union, enum, and/or as-yet-
900 unknown-type blocks of info about structured data. `type_code'
901 has been set to the proper TYPE_CODE, if we know it. */
903 found_ecoff_debugging_info
= 1;
905 top_stack
->blocktype
= stBlock
;
907 /* First count the number of fields and the highest value. */
910 for (ext_tsym
= ext_sh
+ external_sym_size
;
912 ext_tsym
+= external_sym_size
)
916 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
924 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
926 /* If the type of the member is Nil (or Void),
927 without qualifiers, assume the tag is an
929 Alpha cc -migrate enums are recognized by a zero
930 index and a zero symbol value.
931 DU 4.0 cc enums are recognized by a member type of
932 btEnum without qualifiers and a zero symbol value. */
933 if (tsym
.index
== indexNil
934 || (tsym
.index
== 0 && sh
->value
== 0))
935 type_code
= TYPE_CODE_ENUM
;
938 (*debug_swap
->swap_tir_in
) (bigend
,
939 &ax
[tsym
.index
].a_ti
,
941 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
942 || (tir
.bt
== btEnum
&& sh
->value
== 0))
944 type_code
= TYPE_CODE_ENUM
;
948 if (tsym
.value
> max_value
)
949 max_value
= tsym
.value
;
958 /* This is a no-op; is it trying to tell us something
959 we should be checking? */
960 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED */
964 /* This is something like a struct within a
965 struct. Skip over the fields of the inner
966 struct. The -1 is because the for loop will
967 increment ext_tsym. */
968 ext_tsym
= ((char *) debug_info
->external_sym
969 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
970 * external_sym_size
));
976 /* mips cc puts out a typedef for struct x if it is not yet
977 defined when it encounters
978 struct y { struct x *xp; };
983 /* Irix5 cc puts out a stIndirect for struct x if it is not
984 yet defined when it encounters
985 struct y { struct x *xp; };
990 complain (&block_member_complaint
, tsym
.st
);
995 /* In an stBlock, there is no way to distinguish structs,
996 unions, and enums at this point. This is a bug in the
997 original design (that has been fixed with the recent
998 addition of the stStruct, stUnion, and stEnum symbol
999 types.) The way you can tell is if/when you see a variable
1000 or field of that type. In that case the variable's type
1001 (in the AUX table) says if the type is struct, union, or
1002 enum, and points back to the stBlock here. So you can
1003 patch the tag kind up later - but only if there actually is
1004 a variable or field of that type.
1006 So until we know for sure, we will guess at this point.
1008 If the first member has index==indexNil or a void type,
1009 assume we have an enumeration.
1010 Otherwise, if there is more than one member, and all
1011 the members have offset 0, assume we have a union.
1012 Otherwise, assume we have a struct.
1014 The heuristic could guess wrong in the case of of an
1015 enumeration with no members or a union with one (or zero)
1016 members, or when all except the last field of a struct have
1017 width zero. These are uncommon and/or illegal situations,
1018 and in any case guessing wrong probably doesn't matter
1021 But if we later do find out we were wrong, we fixup the tag
1022 kind. Members of an enumeration must be handled
1023 differently from struct/union fields, and that is harder to
1024 patch up, but luckily we shouldn't need to. (If there are
1025 any enumeration members, we can tell for sure it's an enum
1028 if (type_code
== TYPE_CODE_UNDEF
)
1030 if (nfields
> 1 && max_value
== 0)
1031 type_code
= TYPE_CODE_UNION
;
1033 type_code
= TYPE_CODE_STRUCT
;
1036 /* Create a new type or use the pending type. */
1037 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1038 if (pend
== (struct mdebug_pending
*) NULL
)
1040 t
= new_type (NULL
);
1041 add_pending (cur_fdr
, ext_sh
, t
);
1046 /* Do not set the tag name if it is a compiler generated tag name
1047 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1048 Alpha cc puts out an sh->iss of zero for those. */
1049 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1050 TYPE_TAG_NAME (t
) = NULL
;
1052 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1055 TYPE_CODE (t
) = type_code
;
1056 TYPE_LENGTH (t
) = sh
->value
;
1057 TYPE_NFIELDS (t
) = nfields
;
1058 TYPE_FIELDS (t
) = f
= ((struct field
*)
1060 nfields
* sizeof (struct field
)));
1062 if (type_code
== TYPE_CODE_ENUM
)
1064 int unsigned_enum
= 1;
1066 /* This is a non-empty enum. */
1068 /* DEC c89 has the number of enumerators in the sh.value field,
1069 not the type length, so we have to compensate for that
1070 incompatibility quirk.
1071 This might do the wrong thing for an enum with one or two
1072 enumerators and gcc -gcoff -fshort-enums, but these cases
1073 are hopefully rare enough.
1074 Alpha cc -migrate has a sh.value field of zero, we adjust
1076 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
)
1077 || TYPE_LENGTH (t
) == 0)
1078 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1079 for (ext_tsym
= ext_sh
+ external_sym_size
;
1081 ext_tsym
+= external_sym_size
)
1084 struct symbol
*enum_sym
;
1086 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1088 if (tsym
.st
!= stMember
)
1091 FIELD_BITPOS (*f
) = tsym
.value
;
1092 FIELD_TYPE (*f
) = t
;
1093 FIELD_NAME (*f
) = debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1094 FIELD_BITSIZE (*f
) = 0;
1096 enum_sym
= ((struct symbol
*)
1097 obstack_alloc (¤t_objfile
->symbol_obstack
,
1098 sizeof (struct symbol
)));
1099 memset (enum_sym
, 0, sizeof (struct symbol
));
1100 SYMBOL_NAME (enum_sym
) =
1101 obsavestring (f
->name
, strlen (f
->name
),
1102 ¤t_objfile
->symbol_obstack
);
1103 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1104 SYMBOL_TYPE (enum_sym
) = t
;
1105 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1106 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1107 if (SYMBOL_VALUE (enum_sym
) < 0)
1109 add_symbol (enum_sym
, top_stack
->cur_block
);
1111 /* Skip the stMembers that we've handled. */
1116 TYPE_FLAGS (t
) |= TYPE_FLAG_UNSIGNED
;
1118 /* make this the current type */
1119 top_stack
->cur_type
= t
;
1120 top_stack
->cur_field
= 0;
1122 /* Do not create a symbol for alpha cc unnamed structs. */
1126 /* gcc puts out an empty struct for an opaque struct definitions,
1127 do not create a symbol for it either. */
1128 if (TYPE_NFIELDS (t
) == 0)
1130 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1134 s
= new_symbol (name
);
1135 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1136 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1137 SYMBOL_VALUE (s
) = 0;
1138 SYMBOL_TYPE (s
) = t
;
1139 add_symbol (s
, top_stack
->cur_block
);
1142 /* End of local variables shared by struct, union, enum, and
1143 block (as yet unknown struct/union/enum) processing. */
1147 found_ecoff_debugging_info
= 1;
1148 /* beginnning of (code) block. Value of symbol
1149 is the displacement from procedure start */
1150 push_parse_stack ();
1152 /* Do not start a new block if this is the outermost block of a
1153 procedure. This allows the LOC_BLOCK symbol to point to the
1154 block with the local variables, so funcname::var works. */
1155 if (top_stack
->blocktype
== stProc
1156 || top_stack
->blocktype
== stStaticProc
)
1158 top_stack
->blocktype
= stNil
;
1162 top_stack
->blocktype
= stBlock
;
1163 b
= new_block (top_stack
->maxsyms
);
1164 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1165 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1166 top_stack
->cur_block
= b
;
1167 add_block (b
, top_stack
->cur_st
);
1170 case stEnd
: /* end (of anything) */
1171 if (sh
->sc
== scInfo
|| SC_IS_COMMON (sh
->sc
))
1173 /* Finished with type */
1174 top_stack
->cur_type
= 0;
1176 else if (sh
->sc
== scText
&&
1177 (top_stack
->blocktype
== stProc
||
1178 top_stack
->blocktype
== stStaticProc
))
1180 /* Finished with procedure */
1181 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1182 struct mips_extra_func_info
*e
;
1184 struct type
*ftype
= top_stack
->cur_type
;
1187 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1189 /* Make up special symbol to contain procedure specific info */
1190 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1191 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1192 SYMBOL_CLASS (s
) = LOC_CONST
;
1193 SYMBOL_TYPE (s
) = mdebug_type_void
;
1194 e
= ((struct mips_extra_func_info
*)
1195 obstack_alloc (¤t_objfile
->symbol_obstack
,
1196 sizeof (struct mips_extra_func_info
)));
1197 memset (e
, 0, sizeof (struct mips_extra_func_info
));
1198 SYMBOL_VALUE (s
) = (long) e
;
1199 e
->numargs
= top_stack
->numargs
;
1200 e
->pdr
.framereg
= -1;
1201 add_symbol (s
, top_stack
->cur_block
);
1203 /* Reallocate symbols, saving memory */
1204 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1206 /* f77 emits proc-level with address bounds==[0,0],
1207 So look for such child blocks, and patch them. */
1208 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1210 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1211 if (BLOCK_SUPERBLOCK (b_bad
) == b
1212 && BLOCK_START (b_bad
) == top_stack
->procadr
1213 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1215 BLOCK_START (b_bad
) = BLOCK_START (b
);
1216 BLOCK_END (b_bad
) = BLOCK_END (b
);
1220 if (TYPE_NFIELDS (ftype
) <= 0)
1222 /* No parameter type information is recorded with the function's
1223 type. Set that from the type of the parameter symbols. */
1224 int nparams
= top_stack
->numargs
;
1230 TYPE_NFIELDS (ftype
) = nparams
;
1231 TYPE_FIELDS (ftype
) = (struct field
*)
1232 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1234 for (i
= iparams
= 0; iparams
< nparams
; i
++)
1236 sym
= BLOCK_SYM (b
, i
);
1237 switch (SYMBOL_CLASS (sym
))
1242 case LOC_REGPARM_ADDR
:
1243 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1244 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
1254 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1256 /* End of (code) block. The value of the symbol is the
1257 displacement from the procedure`s start address of the
1258 end of this block. */
1259 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1260 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1262 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1264 /* End of outermost block. Pop parse stack and ignore. The
1265 following stEnd of stProc will take care of the block. */
1268 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1270 /* End of file. Pop parse stack and ignore. Higher
1271 level code deals with this. */
1275 complain (&stEnd_complaint
, sh
->sc
);
1277 pop_parse_stack (); /* restore previous lexical context */
1280 case stMember
: /* member of struct or union */
1281 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1282 FIELD_NAME (*f
) = name
;
1283 FIELD_BITPOS (*f
) = sh
->value
;
1285 FIELD_TYPE (*f
) = parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1286 FIELD_BITSIZE (*f
) = bitsize
;
1289 case stIndirect
: /* forward declaration on Irix5 */
1290 /* Forward declarations from Irix5 cc are handled by cross_ref,
1294 case stTypedef
: /* type definition */
1295 found_ecoff_debugging_info
= 1;
1297 /* Typedefs for forward declarations and opaque structs from alpha cc
1298 are handled by cross_ref, skip them. */
1302 /* Parse the type or use the pending type. */
1303 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1304 if (pend
== (struct mdebug_pending
*) NULL
)
1306 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *) NULL
, bigend
, name
);
1307 add_pending (cur_fdr
, ext_sh
, t
);
1312 /* mips cc puts out a typedef with the name of the struct for forward
1313 declarations. These should not go into the symbol table and
1314 TYPE_NAME should not be set for them.
1315 They can't be distinguished from an intentional typedef to
1316 the same name however:
1318 struct x { int ix; int jx; };
1322 struct xx {int ixx; int jxx; };
1323 generates a cross referencing stTypedef for x and xx.
1324 The user visible effect of this is that the type of a pointer
1325 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1326 The problem is fixed with alpha cc and Irix5 cc. */
1328 /* However if the typedef cross references to an opaque aggregate, it
1329 is safe to omit it from the symbol table. */
1331 if (has_opaque_xref (cur_fdr
, sh
))
1333 s
= new_symbol (name
);
1334 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1335 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1336 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1337 SYMBOL_TYPE (s
) = t
;
1338 add_symbol (s
, top_stack
->cur_block
);
1340 /* Incomplete definitions of structs should not get a name. */
1341 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1342 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1343 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1344 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1346 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1347 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1349 /* If we are giving a name to a type such as "pointer to
1350 foo" or "function returning foo", we better not set
1351 the TYPE_NAME. If the program contains "typedef char
1352 *caddr_t;", we don't want all variables of type char
1353 * to print as caddr_t. This is not just a
1354 consequence of GDB's type management; CC and GCC (at
1355 least through version 2.4) both output variables of
1356 either type char * or caddr_t with the type
1357 refering to the stTypedef symbol for caddr_t. If a future
1358 compiler cleans this up it GDB is not ready for it
1359 yet, but if it becomes ready we somehow need to
1360 disable this check (without breaking the PCC/GCC2.4
1365 Fortunately, this check seems not to be necessary
1366 for anything except pointers or functions. */
1369 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1373 case stFile
: /* file name */
1374 push_parse_stack ();
1375 top_stack
->blocktype
= sh
->st
;
1378 /* I`ve never seen these for C */
1380 break; /* register relocation */
1382 break; /* forwarding address */
1384 break; /* constant */
1386 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1393 /* Parse the type information provided in the raw AX entries for
1394 the symbol SH. Return the bitfield size in BS, in case.
1395 We must byte-swap the AX entries before we use them; BIGEND says whether
1396 they are big-endian or little-endian (from fh->fBigendian). */
1398 static struct type
*
1399 parse_type (int fd
, union aux_ext
*ax
, unsigned int aux_index
, int *bs
,
1400 int bigend
, char *sym_name
)
1402 /* Null entries in this map are treated specially */
1403 static struct type
**map_bt
[] =
1405 &mdebug_type_void
, /* btNil */
1406 &mdebug_type_adr_32
, /* btAdr */
1407 &mdebug_type_char
, /* btChar */
1408 &mdebug_type_unsigned_char
, /* btUChar */
1409 &mdebug_type_short
, /* btShort */
1410 &mdebug_type_unsigned_short
, /* btUShort */
1411 &mdebug_type_int_32
, /* btInt */
1412 &mdebug_type_unsigned_int_32
, /* btUInt */
1413 &mdebug_type_long_32
, /* btLong */
1414 &mdebug_type_unsigned_long_32
, /* btULong */
1415 &mdebug_type_float
, /* btFloat */
1416 &mdebug_type_double
, /* btDouble */
1423 &mdebug_type_complex
, /* btComplex */
1424 &mdebug_type_double_complex
, /* btDComplex */
1426 &mdebug_type_fixed_dec
, /* btFixedDec */
1427 &mdebug_type_float_dec
, /* btFloatDec */
1428 &mdebug_type_string
, /* btString */
1431 &mdebug_type_void
, /* btVoid */
1432 0, /* DEC C++: Pointer to member */
1433 0, /* DEC C++: Virtual function table */
1434 0, /* DEC C++: Class (Record) */
1435 &mdebug_type_long_64
, /* btLong64 */
1436 &mdebug_type_unsigned_long_64
, /* btULong64 */
1437 &mdebug_type_long_long_64
, /* btLongLong64 */
1438 &mdebug_type_unsigned_long_long_64
, /* btULongLong64 */
1439 &mdebug_type_adr_64
, /* btAdr64 */
1440 &mdebug_type_int_64
, /* btInt64 */
1441 &mdebug_type_unsigned_int_64
, /* btUInt64 */
1445 struct type
*tp
= 0;
1446 enum type_code type_code
= TYPE_CODE_UNDEF
;
1448 /* Handle undefined types, they have indexNil. */
1449 if (aux_index
== indexNil
)
1450 return mdebug_type_int
;
1452 /* Handle corrupt aux indices. */
1453 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1455 complain (&index_complaint
, sym_name
);
1456 return mdebug_type_int
;
1460 /* Use aux as a type information record, map its basic type. */
1461 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1462 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1464 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1465 return mdebug_type_int
;
1469 tp
= *map_bt
[t
->bt
];
1474 /* Cannot use builtin types -- build our own */
1478 type_code
= TYPE_CODE_STRUCT
;
1481 type_code
= TYPE_CODE_UNION
;
1484 type_code
= TYPE_CODE_ENUM
;
1487 type_code
= TYPE_CODE_RANGE
;
1490 type_code
= TYPE_CODE_SET
;
1493 /* alpha cc -migrate uses this for typedefs. The true type will
1494 be obtained by crossreferencing below. */
1495 type_code
= TYPE_CODE_ERROR
;
1498 /* alpha cc uses this for typedefs. The true type will be
1499 obtained by crossreferencing below. */
1500 type_code
= TYPE_CODE_ERROR
;
1503 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1504 return mdebug_type_int
;
1508 /* Move on to next aux */
1513 int width
= AUX_GET_WIDTH (bigend
, ax
);
1515 /* Inhibit core dumps with some cfront generated objects that
1517 if (bs
== (int *) NULL
)
1519 /* Alpha cc -migrate encodes char and unsigned char types
1520 as short and unsigned short types with a field width of 8.
1521 Enum types also have a field width which we ignore for now. */
1522 if (t
->bt
== btShort
&& width
== 8)
1523 tp
= mdebug_type_char
;
1524 else if (t
->bt
== btUShort
&& width
== 8)
1525 tp
= mdebug_type_unsigned_char
;
1526 else if (t
->bt
== btEnum
)
1529 complain (&bad_fbitfield_complaint
, sym_name
);
1536 /* A btIndirect entry cross references to an aux entry containing
1538 if (t
->bt
== btIndirect
)
1545 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1547 if (rn
->rfd
== 0xfff)
1549 rf
= AUX_GET_ISYM (bigend
, ax
);
1557 complain (&bad_indirect_xref_complaint
, sym_name
);
1558 return mdebug_type_int
;
1560 xref_fh
= get_rfd (fd
, rf
);
1561 xref_fd
= xref_fh
- debug_info
->fdr
;
1562 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1563 rn
->index
, (int *) NULL
, xref_fh
->fBigendian
, sym_name
);
1566 /* All these types really point to some (common) MIPS type
1567 definition, and only the type-qualifiers fully identify
1568 them. We'll make the same effort at sharing. */
1569 if (t
->bt
== btStruct
||
1573 /* btSet (I think) implies that the name is a tag name, not a typedef
1574 name. This apparently is a MIPS extension for C sets. */
1579 /* Try to cross reference this type, build new type on failure. */
1580 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1581 if (tp
== (struct type
*) NULL
)
1582 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1584 /* DEC c89 produces cross references to qualified aggregate types,
1585 dereference them. */
1586 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1587 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1588 tp
= TYPE_TARGET_TYPE (tp
);
1590 /* Make sure that TYPE_CODE(tp) has an expected type code.
1591 Any type may be returned from cross_ref if file indirect entries
1593 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1594 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1595 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1597 complain (&unexpected_type_code_complaint
, sym_name
);
1602 /* Usually, TYPE_CODE(tp) is already type_code. The main
1603 exception is if we guessed wrong re struct/union/enum.
1604 But for struct vs. union a wrong guess is harmless, so
1605 don't complain(). */
1606 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1607 && type_code
!= TYPE_CODE_ENUM
)
1608 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1609 && type_code
== TYPE_CODE_ENUM
))
1611 complain (&bad_tag_guess_complaint
, sym_name
);
1614 if (TYPE_CODE (tp
) != type_code
)
1616 TYPE_CODE (tp
) = type_code
;
1619 /* Do not set the tag name if it is a compiler generated tag name
1620 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1621 if (name
[0] == '.' || name
[0] == '\0')
1622 TYPE_TAG_NAME (tp
) = NULL
;
1623 else if (TYPE_TAG_NAME (tp
) == NULL
1624 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1625 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1626 ¤t_objfile
->type_obstack
);
1630 /* All these types really point to some (common) MIPS type
1631 definition, and only the type-qualifiers fully identify
1632 them. We'll make the same effort at sharing.
1633 FIXME: We are not doing any guessing on range types. */
1634 if (t
->bt
== btRange
)
1638 /* Try to cross reference this type, build new type on failure. */
1639 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1640 if (tp
== (struct type
*) NULL
)
1641 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1643 /* Make sure that TYPE_CODE(tp) has an expected type code.
1644 Any type may be returned from cross_ref if file indirect entries
1646 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1648 complain (&unexpected_type_code_complaint
, sym_name
);
1652 /* Usually, TYPE_CODE(tp) is already type_code. The main
1653 exception is if we guessed wrong re struct/union/enum. */
1654 if (TYPE_CODE (tp
) != type_code
)
1656 complain (&bad_tag_guess_complaint
, sym_name
);
1657 TYPE_CODE (tp
) = type_code
;
1659 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1660 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1661 ¤t_objfile
->type_obstack
);
1664 if (t
->bt
== btTypedef
)
1668 /* Try to cross reference this type, it should succeed. */
1669 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1670 if (tp
== (struct type
*) NULL
)
1672 complain (&unable_to_cross_ref_complaint
, sym_name
);
1673 tp
= mdebug_type_int
;
1677 /* Deal with range types */
1678 if (t
->bt
== btRange
)
1680 TYPE_NFIELDS (tp
) = 2;
1681 TYPE_FIELDS (tp
) = ((struct field
*)
1682 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1683 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1684 ¤t_objfile
->type_obstack
);
1685 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1687 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1688 ¤t_objfile
->type_obstack
);
1689 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1693 /* Parse all the type qualifiers now. If there are more
1694 than 6 the game will continue in the next aux */
1698 #define PARSE_TQ(tq) \
1699 if (t->tq != tqNil) \
1700 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1712 /* mips cc 2.x and gcc never put out continued aux entries. */
1716 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1720 /* Complain for illegal continuations due to corrupt aux entries. */
1722 complain (&bad_continued_complaint
, sym_name
);
1727 /* Make up a complex type from a basic one. Type is passed by
1728 reference in TPP and side-effected as necessary. The type
1729 qualifier TQ says how to handle the aux symbols at AX for
1730 the symbol SX we are currently analyzing. BIGEND says whether
1731 aux symbols are big-endian or little-endian.
1732 Returns the number of aux symbols we parsed. */
1735 upgrade_type (int fd
, struct type
**tpp
, int tq
, union aux_ext
*ax
, int bigend
,
1741 /* Used in array processing */
1752 t
= lookup_pointer_type (*tpp
);
1757 t
= lookup_function_type (*tpp
);
1764 /* Determine and record the domain type (type of index) */
1765 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1771 rf
= AUX_GET_ISYM (bigend
, ax
);
1774 fh
= get_rfd (fd
, rf
);
1776 indx
= parse_type (fh
- debug_info
->fdr
,
1777 debug_info
->external_aux
+ fh
->iauxBase
,
1778 id
, (int *) NULL
, bigend
, sym_name
);
1780 /* The bounds type should be an integer type, but might be anything
1781 else due to corrupt aux entries. */
1782 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1784 complain (&array_index_type_complaint
, sym_name
);
1785 indx
= mdebug_type_int
;
1788 /* Get the bounds, and create the array type. */
1790 lower
= AUX_GET_DNLOW (bigend
, ax
);
1792 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1794 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1796 range
= create_range_type ((struct type
*) NULL
, indx
,
1799 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1801 /* We used to fill in the supplied array element bitsize
1802 here if the TYPE_LENGTH of the target type was zero.
1803 This happens for a `pointer to an array of anonymous structs',
1804 but in this case the array element bitsize is also zero,
1805 so nothing is gained.
1806 And we used to check the TYPE_LENGTH of the target type against
1807 the supplied array element bitsize.
1808 gcc causes a mismatch for `pointer to array of object',
1809 since the sdb directives it uses do not have a way of
1810 specifying the bitsize, but it does no harm (the
1811 TYPE_LENGTH should be correct) and we should be able to
1812 ignore the erroneous bitsize from the auxiliary entry safely.
1813 dbx seems to ignore it too. */
1815 /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
1817 if (TYPE_LENGTH (*tpp
) == 0)
1819 TYPE_FLAGS (t
) |= TYPE_FLAG_TARGET_STUB
;
1826 /* Volatile -- currently ignored */
1830 /* Const -- currently ignored */
1834 complain (&unknown_type_qual_complaint
, tq
);
1840 /* Parse a procedure descriptor record PR. Note that the procedure is
1841 parsed _after_ the local symbols, now we just insert the extra
1842 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1843 already been placed in the procedure's main block. Note also that
1844 images that have been partially stripped (ld -x) have been deprived
1845 of local symbols, and we have to cope with them here. FIRST_OFF is
1846 the offset of the first procedure for this FDR; we adjust the
1847 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1848 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1849 in question, or NULL to use top_stack->cur_block. */
1851 static void parse_procedure (PDR
*, struct symtab
*, struct partial_symtab
*);
1854 parse_procedure (PDR
*pr
, struct symtab
*search_symtab
,
1855 struct partial_symtab
*pst
)
1857 struct symbol
*s
, *i
;
1859 struct mips_extra_func_info
*e
;
1862 /* Simple rule to find files linked "-x" */
1863 if (cur_fdr
->rss
== -1)
1867 /* Static procedure at address pr->adr. Sigh. */
1868 /* FIXME-32x64. assuming pr->adr fits in long. */
1869 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1877 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1878 ((char *) debug_info
->external_ext
1880 * debug_swap
->external_ext_size
)),
1882 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1890 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1891 ((char *) debug_info
->external_sym
1892 + ((cur_fdr
->isymBase
+ pr
->isym
)
1893 * debug_swap
->external_sym_size
)),
1895 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1898 if (search_symtab
!= NULL
)
1901 /* This loses both in the case mentioned (want a static, find a global),
1902 but also if we are looking up a non-mangled name which happens to
1903 match the name of a mangled function. */
1904 /* We have to save the cur_fdr across the call to lookup_symbol.
1905 If the pdr is for a static function and if a global function with
1906 the same name exists, lookup_symbol will eventually read in the symtab
1907 for the global function and clobber cur_fdr. */
1908 FDR
*save_cur_fdr
= cur_fdr
;
1909 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1910 cur_fdr
= save_cur_fdr
;
1914 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1920 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1921 VAR_NAMESPACE
, LOC_BLOCK
);
1925 b
= SYMBOL_BLOCK_VALUE (s
);
1929 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1933 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1934 s
= new_symbol (sh_name
);
1935 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1936 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1937 /* Donno its type, hope int is ok */
1938 SYMBOL_TYPE (s
) = lookup_function_type (mdebug_type_int
);
1939 add_symbol (s
, top_stack
->cur_block
);
1940 /* Wont have symbols for this one */
1942 SYMBOL_BLOCK_VALUE (s
) = b
;
1943 BLOCK_FUNCTION (b
) = s
;
1944 BLOCK_START (b
) = pr
->adr
;
1945 /* BOUND used to be the end of procedure's text, but the
1946 argument is no longer passed in. */
1947 BLOCK_END (b
) = bound
;
1948 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1949 add_block (b
, top_stack
->cur_st
);
1953 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1957 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1959 e
->pdr
.isym
= (long) s
;
1961 /* GDB expects the absolute function start address for the
1962 procedure descriptor in e->pdr.adr.
1963 As the address in the procedure descriptor is usually relative,
1964 we would have to relocate e->pdr.adr with cur_fdr->adr and
1965 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
1966 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
1967 in shared libraries on some systems, and on other systems
1968 e->pdr.adr is sometimes offset by a bogus value.
1969 To work around these problems, we replace e->pdr.adr with
1970 the start address of the function. */
1971 e
->pdr
.adr
= BLOCK_START (b
);
1973 /* Correct incorrect setjmp procedure descriptor from the library
1974 to make backtrace through setjmp work. */
1975 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1977 complain (&bad_setjmp_pdr_complaint
, 0);
1978 e
->pdr
.pcreg
= RA_REGNUM
;
1979 e
->pdr
.regmask
= 0x80000000;
1980 e
->pdr
.regoffset
= -4;
1984 /* It would be reasonable that functions that have been compiled
1985 without debugging info have a btNil type for their return value,
1986 and functions that are void and are compiled with debugging info
1988 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
1989 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
1991 The glevel field in cur_fdr could be used to determine the presence
1992 of debugging info, but GCC doesn't always pass the -g switch settings
1993 to the assembler and GAS doesn't set the glevel field from the -g switch
1995 To work around these problems, the return value type of a TYPE_CODE_VOID
1996 function is adjusted accordingly if no debugging info was found in the
1997 compilation unit. */
1999 if (processing_gcc_compilation
== 0
2000 && found_ecoff_debugging_info
== 0
2001 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
2002 SYMBOL_TYPE (s
) = nodebug_func_symbol_type
;
2005 /* Relocate the extra function info pointed to by the symbol table. */
2008 ecoff_relocate_efi (struct symbol
*sym
, CORE_ADDR delta
)
2010 struct mips_extra_func_info
*e
;
2012 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (sym
);
2014 e
->pdr
.adr
+= delta
;
2017 /* Parse the external symbol ES. Just call parse_symbol() after
2018 making sure we know where the aux are for it.
2019 BIGEND says whether aux entries are big-endian or little-endian.
2021 This routine clobbers top_stack->cur_block and ->cur_st. */
2023 static void parse_external (EXTR
*, int, struct section_offsets
*,
2027 parse_external (EXTR
*es
, int bigend
, struct section_offsets
*section_offsets
,
2028 struct objfile
*objfile
)
2032 if (es
->ifd
!= ifdNil
)
2035 cur_fdr
= debug_info
->fdr
+ cur_fd
;
2036 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
2040 cur_fdr
= debug_info
->fdr
;
2044 /* Reading .o files */
2045 if (SC_IS_UNDEF (es
->asym
.sc
) || es
->asym
.sc
== scNil
)
2048 switch (es
->asym
.st
)
2051 /* These are generated for static symbols in .o files,
2072 /* FIXME: Turn this into a complaint? */
2074 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
2075 what
, debug_info
->ssext
+ es
->asym
.iss
,
2076 fdr_name (cur_fdr
));
2080 switch (es
->asym
.st
)
2084 /* There is no need to parse the external procedure symbols.
2085 If they are from objects compiled without -g, their index will
2086 be indexNil, and the symbol definition from the minimal symbol
2087 is preferrable (yielding a function returning int instead of int).
2088 If the index points to a local procedure symbol, the local
2089 symbol already provides the correct type.
2090 Note that the index of the external procedure symbol points
2091 to the local procedure symbol in the local symbol table, and
2092 _not_ to the auxiliary symbol info. */
2096 /* Global common symbols are resolved by the runtime loader,
2098 if (SC_IS_COMMON (es
->asym
.sc
))
2101 /* Note that the case of a symbol with indexNil must be handled
2102 anyways by parse_symbol(). */
2103 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
, objfile
);
2110 /* Parse the line number info for file descriptor FH into
2111 GDB's linetable LT. MIPS' encoding requires a little bit
2112 of magic to get things out. Note also that MIPS' line
2113 numbers can go back and forth, apparently we can live
2114 with that and do not need to reorder our linetables */
2116 static void parse_lines (FDR
*, PDR
*, struct linetable
*, int,
2117 struct partial_symtab
*, CORE_ADDR
);
2120 parse_lines (FDR
*fh
, PDR
*pr
, struct linetable
*lt
, int maxlines
,
2121 struct partial_symtab
*pst
, CORE_ADDR lowest_pdr_addr
)
2123 unsigned char *base
;
2125 int delta
, count
, lineno
= 0;
2127 if (fh
->cbLine
== 0)
2130 /* Scan by procedure descriptors */
2132 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2136 unsigned char *halt
;
2138 /* No code for this one */
2139 if (pr
->iline
== ilineNil
||
2140 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2143 /* Determine start and end address of compressed line bytes for
2145 base
= debug_info
->line
+ fh
->cbLineOffset
;
2146 if (j
!= (fh
->cpd
- 1))
2147 halt
= base
+ pr
[1].cbLineOffset
;
2149 halt
= base
+ fh
->cbLine
;
2150 base
+= pr
->cbLineOffset
;
2152 adr
= pst
->textlow
+ pr
->adr
- lowest_pdr_addr
;
2154 l
= adr
>> 2; /* in words */
2155 for (lineno
= pr
->lnLow
; base
< halt
;)
2157 count
= *base
& 0x0f;
2158 delta
= *base
++ >> 4;
2163 delta
= (base
[0] << 8) | base
[1];
2164 if (delta
>= 0x8000)
2168 lineno
+= delta
; /* first delta is 0 */
2170 /* Complain if the line table overflows. Could happen
2171 with corrupt binaries. */
2172 if (lt
->nitems
>= maxlines
)
2174 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
2177 k
= add_line (lt
, lineno
, l
, k
);
2183 /* Master parsing procedure for first-pass reading of file symbols
2184 into a partial_symtab. */
2187 parse_partial_symbols (struct objfile
*objfile
)
2189 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2190 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2191 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2192 void (*const swap_ext_in
) (bfd
*, void *, EXTR
*) = debug_swap
->swap_ext_in
;
2193 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
2194 void (*const swap_rfd_in
) (bfd
*, void *, RFDT
*) = debug_swap
->swap_rfd_in
;
2196 HDRR
*hdr
= &debug_info
->symbolic_header
;
2197 /* Running pointers */
2202 register EXTR
*ext_in
;
2205 struct partial_symtab
*pst
;
2206 int textlow_not_set
= 1;
2207 int past_first_source_file
= 0;
2209 /* List of current psymtab's include files */
2210 char **psymtab_include_list
;
2211 int includes_allocated
;
2214 struct pst_map
*fdr_to_pst
;
2215 /* Index within current psymtab dependency list */
2216 struct partial_symtab
**dependency_list
;
2217 int dependencies_used
, dependencies_allocated
;
2218 struct cleanup
*old_chain
;
2220 enum language prev_language
;
2221 asection
*text_sect
;
2222 int relocatable
= 0;
2224 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2225 the shared libraries are prelinked at a high memory address.
2226 We have to adjust the start address of the object file for this case,
2227 by setting it to the start address of the first procedure in the file.
2228 But we should do no adjustments if we are debugging a .o file, where
2229 the text section (and fh->adr) really starts at zero. */
2230 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2231 if (text_sect
!= NULL
2232 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2235 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2236 sizeof (EXTR
) * hdr
->iextMax
);
2238 includes_allocated
= 30;
2240 psymtab_include_list
= (char **) alloca (includes_allocated
*
2242 next_symbol_text_func
= mdebug_next_symbol_text
;
2244 dependencies_allocated
= 30;
2245 dependencies_used
= 0;
2247 (struct partial_symtab
**) alloca (dependencies_allocated
*
2248 sizeof (struct partial_symtab
*));
2250 last_source_file
= NULL
;
2255 * Only parse the Local and External symbols, and the Relative FDR.
2256 * Fixup enough of the loader symtab to be able to use it.
2257 * Allocate space only for the file's portions we need to
2262 max_glevel
= MIN_GLEVEL
;
2264 /* Allocate the map FDR -> PST.
2265 Minor hack: -O3 images might claim some global data belongs
2266 to FDR -1. We`ll go along with that */
2267 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2268 old_chain
= make_cleanup (xfree
, fdr_to_pst
);
2271 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2272 fdr_to_pst
[-1].pst
= pst
;
2276 /* Allocate the global pending list. */
2278 ((struct mdebug_pending
**)
2279 obstack_alloc (&objfile
->psymbol_obstack
,
2280 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2281 memset (pending_list
, 0,
2282 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2284 /* Pass 0 over external syms: swap them in. */
2285 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2286 make_cleanup (xfree
, ext_block
);
2288 ext_out
= (char *) debug_info
->external_ext
;
2289 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2291 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2292 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2294 /* Pass 1 over external syms: Presize and partition the list */
2296 ext_in_end
= ext_in
+ hdr
->iextMax
;
2297 for (; ext_in
< ext_in_end
; ext_in
++)
2299 /* See calls to complain below. */
2300 if (ext_in
->ifd
>= -1
2301 && ext_in
->ifd
< hdr
->ifdMax
2302 && ext_in
->asym
.iss
>= 0
2303 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2304 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2307 /* Pass 1.5 over files: partition out global symbol space */
2309 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2311 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2312 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2313 fdr_to_pst
[f_idx
].n_globals
= 0;
2318 For ECOFF in ELF, we skip the creation of the minimal symbols.
2319 The ECOFF symbols should be a subset of the Elf symbols, and the
2320 section information of the elf symbols will be more accurate.
2321 FIXME! What about Irix 5's native linker?
2323 By default, Elf sections which don't exist in ECOFF
2324 get put in ECOFF's absolute section by the gnu linker.
2325 Since absolute sections don't get relocated, we
2326 end up calculating an address different from that of
2327 the symbol's minimal symbol (created earlier from the
2330 To fix this, either :
2331 1) don't create the duplicate symbol
2332 (assumes ECOFF symtab is a subset of the ELF symtab;
2333 assumes no side-effects result from ignoring ECOFF symbol)
2334 2) create it, only if lookup for existing symbol in ELF's minimal
2337 assumes no side-effects result from ignoring ECOFF symbol)
2338 3) create it, but lookup ELF's minimal symbol and use it's section
2339 during relocation, then modify "uniqify" phase to merge and
2340 eliminate the duplicate symbol
2341 (highly inefficient)
2343 I've implemented #1 here...
2344 Skip the creation of the minimal symbols based on the ECOFF
2347 /* Pass 2 over external syms: fill in external symbols */
2349 ext_in_end
= ext_in
+ hdr
->iextMax
;
2350 for (; ext_in
< ext_in_end
; ext_in
++)
2352 enum minimal_symbol_type ms_type
= mst_text
;
2353 CORE_ADDR svalue
= ext_in
->asym
.value
;
2355 /* The Irix 5 native tools seem to sometimes generate bogus
2356 external symbols. */
2357 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2359 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2362 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2364 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2369 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2370 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2373 if (SC_IS_UNDEF (ext_in
->asym
.sc
) || ext_in
->asym
.sc
== scNil
)
2377 /* Pass 3 over files, over local syms: fill in static symbols */
2378 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2380 /* Process ECOFF Symbol Types and Storage Classes */
2381 switch (ext_in
->asym
.st
)
2384 /* Beginnning of Procedure */
2385 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2388 /* Load time only static procs */
2389 ms_type
= mst_file_text
;
2390 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2393 /* External symbol */
2394 if (SC_IS_COMMON (ext_in
->asym
.sc
))
2396 /* The value of a common symbol is its size, not its address.
2400 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2403 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2405 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2408 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2410 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2413 svalue
+= ANOFFSET (objfile
->section_offsets
,
2414 get_section_index (objfile
, ".sbss"));
2422 /* On certain platforms, some extra label symbols can be
2423 generated by the linker. One possible usage for this kind
2424 of symbols is to represent the address of the begining of a
2425 given section. For instance, on Tru64 5.1, the address of
2426 the _ftext label is the start address of the .text section.
2428 The storage class of these symbols is usually directly
2429 related to the section to which the symbol refers. For
2430 instance, on Tru64 5.1, the storage class for the _fdata
2431 label is scData, refering to the .data section.
2433 It is actually possible that the section associated to the
2434 storage class of the label does not exist. On True64 5.1
2435 for instance, the libm.so shared library does not contain
2436 any .data section, although it contains a _fpdata label
2437 which storage class is scData... Since these symbols are
2438 usually useless for the debugger user anyway, we just
2439 discard these symbols.
2442 if (SC_IS_TEXT (ext_in
->asym
.sc
))
2444 if (objfile
->sect_index_text
== -1)
2447 ms_type
= mst_file_text
;
2448 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2450 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2452 if (objfile
->sect_index_data
== -1)
2455 ms_type
= mst_file_data
;
2456 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2458 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2460 if (objfile
->sect_index_bss
== -1)
2463 ms_type
= mst_file_bss
;
2464 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2466 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2468 const int sbss_sect_index
= get_section_index (objfile
, ".sbss");
2470 if (sbss_sect_index
== -1)
2473 ms_type
= mst_file_bss
;
2474 svalue
+= ANOFFSET (objfile
->section_offsets
, sbss_sect_index
);
2481 /* The alpha has the section start addresses in stLocal symbols
2482 whose name starts with a `.'. Skip those but complain for all
2483 other stLocal symbols.
2484 Irix6 puts the section start addresses in stNil symbols, skip
2490 ms_type
= mst_unknown
;
2491 complain (&unknown_ext_complaint
, name
);
2493 if (!ECOFF_IN_ELF (cur_bfd
))
2494 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2497 /* Pass 3 over files, over local syms: fill in static symbols */
2498 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2500 struct partial_symtab
*save_pst
;
2504 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2508 fdr_to_pst
[f_idx
].pst
= NULL
;
2512 /* Determine the start address for this object file from the
2513 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2517 if (relocatable
|| textlow
!= 0)
2518 textlow
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2522 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
2525 objfile
->global_psymbols
.next
,
2526 objfile
->static_psymbols
.next
);
2527 pst
->read_symtab_private
= ((char *)
2528 obstack_alloc (&objfile
->psymbol_obstack
,
2529 sizeof (struct symloc
)));
2530 memset (pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2533 FDR_IDX (pst
) = f_idx
;
2534 CUR_BFD (pst
) = cur_bfd
;
2535 DEBUG_SWAP (pst
) = debug_swap
;
2536 DEBUG_INFO (pst
) = debug_info
;
2537 PENDING_LIST (pst
) = pending_list
;
2539 /* The way to turn this into a symtab is to call... */
2540 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2542 /* Set up language for the pst.
2543 The language from the FDR is used if it is unambigious (e.g. cfront
2544 with native cc and g++ will set the language to C).
2545 Otherwise we have to deduce the language from the filename.
2546 Native ecoff has every header file in a separate FDR, so
2547 deduce_language_from_filename will return language_unknown for
2548 a header file, which is not what we want.
2549 But the FDRs for the header files are after the FDR for the source
2550 file, so we can assign the language of the source file to the
2551 following header files. Then we save the language in the private
2552 pst data so that we can reuse it when building symtabs. */
2553 prev_language
= psymtab_language
;
2557 case langCplusplusV2
:
2558 psymtab_language
= language_cplus
;
2561 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2564 if (psymtab_language
== language_unknown
)
2565 psymtab_language
= prev_language
;
2566 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2568 pst
->texthigh
= pst
->textlow
;
2570 /* For stabs-in-ecoff files, the second symbol must be @stab.
2571 This symbol is emitted by mips-tfile to signal that the
2572 current object file uses encapsulated stabs instead of mips
2573 ecoff for local symbols. (It is the second symbol because
2574 the first symbol is the stFile used to signal the start of a
2576 processing_gcc_compilation
= 0;
2579 (*swap_sym_in
) (cur_bfd
,
2580 ((char *) debug_info
->external_sym
2581 + (fh
->isymBase
+ 1) * external_sym_size
),
2583 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2584 processing_gcc_compilation
= 2;
2587 if (processing_gcc_compilation
!= 0)
2589 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2594 (*swap_sym_in
) (cur_bfd
,
2595 (((char *) debug_info
->external_sym
)
2596 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2598 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2599 if (!ECOFF_IS_STAB (&sh
))
2601 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2606 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2607 if (sh
.st
== stStaticProc
)
2609 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2610 prim_record_minimal_symbol_and_info (namestring
,
2614 SECT_OFF_TEXT (objfile
),
2618 procaddr
= sh
.value
;
2620 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2621 (debug_info
->external_aux
2624 (*swap_sym_in
) (cur_bfd
,
2625 ((char *) debug_info
->external_sym
2626 + ((fh
->isymBase
+ isym
- 1)
2627 * external_sym_size
)),
2631 CORE_ADDR high
= procaddr
+ sh
.value
;
2633 /* Kludge for Irix 5.2 zero fh->adr. */
2635 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2636 pst
->textlow
= procaddr
;
2637 if (high
> pst
->texthigh
)
2638 pst
->texthigh
= high
;
2641 else if (sh
.st
== stStatic
)
2656 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2657 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2658 prim_record_minimal_symbol_and_info (namestring
,
2662 SECT_OFF_DATA (objfile
),
2668 /* FIXME! Shouldn't this use cases for bss,
2669 then have the default be abs? */
2670 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2671 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2672 prim_record_minimal_symbol_and_info (namestring
,
2676 SECT_OFF_BSS (objfile
),
2684 /* Handle stabs continuation */
2686 char *stabstring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2687 int len
= strlen (stabstring
);
2688 while (stabstring
[len
- 1] == '\\')
2691 char *stabstring1
= stabstring
;
2695 /* Ignore continuation char from 1st string */
2698 /* Read next stabstring */
2700 (*swap_sym_in
) (cur_bfd
,
2701 (((char *) debug_info
->external_sym
)
2702 + (fh
->isymBase
+ cur_sdx
)
2703 * external_sym_size
),
2705 stabstring2
= debug_info
->ss
+ fh
->issBase
+ sh2
.iss
;
2706 len2
= strlen (stabstring2
);
2708 /* Concatinate stabstring2 with stabstring1 */
2710 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
2711 stabstring
= xrealloc (stabstring
, len
+ len2
+ 1);
2714 stabstring
= xmalloc (len
+ len2
+ 1);
2715 strcpy (stabstring
, stabstring1
);
2717 strcpy (stabstring
+ len
, stabstring2
);
2723 static struct complaint function_outside_compilation_unit
= {
2724 "function `%s' appears to be defined outside of all compilation units", 0, 0
2728 * Standard, external, non-debugger, symbols
2731 case N_TEXT
| N_EXT
:
2732 case N_NBTEXT
| N_EXT
:
2733 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2736 case N_DATA
| N_EXT
:
2737 case N_NBDATA
| N_EXT
:
2738 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2743 case N_NBBSS
| N_EXT
:
2744 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
2745 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2752 /* Standard, local, non-debugger, symbols */
2756 /* We need to be able to deal with both N_FN or N_TEXT,
2757 because we have no way of knowing whether the sys-supplied ld
2758 or GNU ld was used to make the executable. Sequents throw
2759 in another wrinkle -- they renumbered N_FN. */
2767 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2770 case N_UNDF
| N_EXT
:
2771 continue; /* Just undefined, not COMMON */
2776 /* Lots of symbol types we can just ignore. */
2783 /* Keep going . . . */
2786 * Special symbol types for GNU
2789 case N_INDR
| N_EXT
:
2791 case N_SETA
| N_EXT
:
2793 case N_SETT
| N_EXT
:
2795 case N_SETD
| N_EXT
:
2797 case N_SETB
| N_EXT
:
2808 static int prev_so_symnum
= -10;
2809 static int first_so_symnum
;
2811 int prev_textlow_not_set
;
2813 valu
= sh
.value
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2815 prev_textlow_not_set
= textlow_not_set
;
2817 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2818 /* A zero value is probably an indication for the SunPRO 3.0
2819 compiler. end_psymtab explicitly tests for zero, so
2820 don't relocate it. */
2824 textlow_not_set
= 1;
2828 textlow_not_set
= 0;
2830 textlow_not_set
= 0;
2832 past_first_source_file
= 1;
2834 if (prev_so_symnum
!= symnum
- 1)
2835 { /* Here if prev stab wasn't N_SO */
2836 first_so_symnum
= symnum
;
2840 pst
= (struct partial_symtab
*) 0;
2842 dependencies_used
= 0;
2846 prev_so_symnum
= symnum
;
2848 /* End the current partial symtab and start a new one */
2850 /* SET_NAMESTRING ();*/
2851 namestring
= stabstring
;
2853 /* Null name means end of .o file. Don't start a new one. */
2854 if (*namestring
== '\000')
2857 /* Some compilers (including gcc) emit a pair of initial N_SOs.
2858 The first one is a directory name; the second the file name.
2859 If pst exists, is empty, and has a filename ending in '/',
2860 we assume the previous N_SO was a directory name. */
2862 p
= strrchr (namestring
, '/');
2863 if (p
&& *(p
+ 1) == '\000')
2864 continue; /* Simply ignore directory name SOs */
2866 /* Some other compilers (C++ ones in particular) emit useless
2867 SOs for non-existant .c files. We ignore all subsequent SOs that
2868 immediately follow the first. */
2880 enum language tmp_language
;
2881 /* Mark down an include file in the current psymtab */
2883 /* SET_NAMESTRING ();*/
2884 namestring
= stabstring
;
2886 tmp_language
= deduce_language_from_filename (namestring
);
2888 /* Only change the psymtab's language if we've learned
2889 something useful (eg. tmp_language is not language_unknown).
2890 In addition, to match what start_subfile does, never change
2892 if (tmp_language
!= language_unknown
2893 && (tmp_language
!= language_c
2894 || psymtab_language
!= language_cplus
))
2895 psymtab_language
= tmp_language
;
2897 /* In C++, one may expect the same filename to come round many
2898 times, when code is coming alternately from the main file
2899 and from inline functions in other files. So I check to see
2900 if this is a file we've seen before -- either the main
2901 source file, or a previously included file.
2903 This seems to be a lot of time to be spending on N_SOL, but
2904 things like "break c-exp.y:435" need to work (I
2905 suppose the psymtab_include_list could be hashed or put
2906 in a binary tree, if profiling shows this is a major hog). */
2907 if (pst
&& STREQ (namestring
, pst
->filename
))
2911 for (i
= 0; i
< includes_used
; i
++)
2912 if (STREQ (namestring
, psymtab_include_list
[i
]))
2921 psymtab_include_list
[includes_used
++] = namestring
;
2922 if (includes_used
>= includes_allocated
)
2924 char **orig
= psymtab_include_list
;
2926 psymtab_include_list
= (char **)
2927 alloca ((includes_allocated
*= 2) *
2929 memcpy ((PTR
) psymtab_include_list
, (PTR
) orig
,
2930 includes_used
* sizeof (char *));
2934 case N_LSYM
: /* Typedef or automatic variable. */
2935 case N_STSYM
: /* Data seg var -- static */
2936 case N_LCSYM
: /* BSS " */
2937 case N_ROSYM
: /* Read-only data seg var -- static. */
2938 case N_NBSTS
: /* Gould nobase. */
2939 case N_NBLCS
: /* symbols. */
2941 case N_GSYM
: /* Global (extern) variable; can be
2942 data or bss (sigh FIXME). */
2944 /* Following may probably be ignored; I'll leave them here
2945 for now (until I do Pascal and Modula 2 extensions). */
2947 case N_PC
: /* I may or may not need this; I
2949 case N_M2C
: /* I suspect that I can ignore this here. */
2950 case N_SCOPE
: /* Same. */
2952 /* SET_NAMESTRING ();*/
2953 namestring
= stabstring
;
2954 p
= (char *) strchr (namestring
, ':');
2956 continue; /* Not a debugging symbol. */
2960 /* Main processing section for debugging symbols which
2961 the initial read through the symbol tables needs to worry
2962 about. If we reach this point, the symbol which we are
2963 considering is definitely one we are interested in.
2964 p must also contain the (valid) index into the namestring
2965 which indicates the debugging type symbol. */
2970 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2971 #ifdef STATIC_TRANSFORM_NAME
2972 namestring
= STATIC_TRANSFORM_NAME (namestring
);
2974 add_psymbol_to_list (namestring
, p
- namestring
,
2975 VAR_NAMESPACE
, LOC_STATIC
,
2976 &objfile
->static_psymbols
,
2978 psymtab_language
, objfile
);
2981 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2982 /* The addresses in these entries are reported to be
2983 wrong. See the code that reads 'G's for symtabs. */
2984 add_psymbol_to_list (namestring
, p
- namestring
,
2985 VAR_NAMESPACE
, LOC_STATIC
,
2986 &objfile
->global_psymbols
,
2988 psymtab_language
, objfile
);
2992 /* When a 'T' entry is defining an anonymous enum, it
2993 may have a name which is the empty string, or a
2994 single space. Since they're not really defining a
2995 symbol, those shouldn't go in the partial symbol
2996 table. We do pick up the elements of such enums at
2997 'check_enum:', below. */
2998 if (p
>= namestring
+ 2
2999 || (p
== namestring
+ 1
3000 && namestring
[0] != ' '))
3002 add_psymbol_to_list (namestring
, p
- namestring
,
3003 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
3004 &objfile
->static_psymbols
,
3006 psymtab_language
, objfile
);
3009 /* Also a typedef with the same name. */
3010 add_psymbol_to_list (namestring
, p
- namestring
,
3011 VAR_NAMESPACE
, LOC_TYPEDEF
,
3012 &objfile
->static_psymbols
,
3014 psymtab_language
, objfile
);
3017 /* The semantics of C++ state that "struct foo { ... }"
3018 also defines a typedef for "foo". Unfortuantely, cfront
3019 never makes the typedef when translating from C++ to C.
3020 We make the typedef here so that "ptype foo" works as
3021 expected for cfront translated code. */
3022 else if (psymtab_language
== language_cplus
)
3024 /* Also a typedef with the same name. */
3025 add_psymbol_to_list (namestring
, p
- namestring
,
3026 VAR_NAMESPACE
, LOC_TYPEDEF
,
3027 &objfile
->static_psymbols
,
3029 psymtab_language
, objfile
);
3034 if (p
!= namestring
) /* a name is there, not just :T... */
3036 add_psymbol_to_list (namestring
, p
- namestring
,
3037 VAR_NAMESPACE
, LOC_TYPEDEF
,
3038 &objfile
->static_psymbols
,
3040 psymtab_language
, objfile
);
3043 /* If this is an enumerated type, we need to
3044 add all the enum constants to the partial symbol
3045 table. This does not cover enums without names, e.g.
3046 "enum {a, b} c;" in C, but fortunately those are
3047 rare. There is no way for GDB to find those from the
3048 enum type without spending too much time on it. Thus
3049 to solve this problem, the compiler needs to put out the
3050 enum in a nameless type. GCC2 does this. */
3052 /* We are looking for something of the form
3053 <name> ":" ("t" | "T") [<number> "="] "e"
3054 {<constant> ":" <value> ","} ";". */
3056 /* Skip over the colon and the 't' or 'T'. */
3058 /* This type may be given a number. Also, numbers can come
3059 in pairs like (0,26). Skip over it. */
3060 while ((*p
>= '0' && *p
<= '9')
3061 || *p
== '(' || *p
== ',' || *p
== ')'
3067 /* The aix4 compiler emits extra crud before the members. */
3070 /* Skip over the type (?). */
3074 /* Skip over the colon. */
3078 /* We have found an enumerated type. */
3079 /* According to comments in read_enum_type
3080 a comma could end it instead of a semicolon.
3081 I don't know where that happens.
3083 while (*p
&& *p
!= ';' && *p
!= ',')
3087 /* Check for and handle cretinous dbx symbol name
3089 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
3090 p
= next_symbol_text (objfile
);
3092 /* Point to the character after the name
3093 of the enum constant. */
3094 for (q
= p
; *q
&& *q
!= ':'; q
++)
3096 /* Note that the value doesn't matter for
3097 enum constants in psymtabs, just in symtabs. */
3098 add_psymbol_to_list (p
, q
- p
,
3099 VAR_NAMESPACE
, LOC_CONST
,
3100 &objfile
->static_psymbols
, 0,
3101 0, psymtab_language
, objfile
);
3102 /* Point past the name. */
3104 /* Skip over the value. */
3105 while (*p
&& *p
!= ',')
3107 /* Advance past the comma. */
3114 /* Constant, e.g. from "const" in Pascal. */
3115 add_psymbol_to_list (namestring
, p
- namestring
,
3116 VAR_NAMESPACE
, LOC_CONST
,
3117 &objfile
->static_psymbols
, sh
.value
,
3118 0, psymtab_language
, objfile
);
3124 int name_len
= p
- namestring
;
3125 char *name
= xmalloc (name_len
+ 1);
3126 memcpy (name
, namestring
, name_len
);
3127 name
[name_len
] = '\0';
3128 complain (&function_outside_compilation_unit
, name
);
3131 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3132 add_psymbol_to_list (namestring
, p
- namestring
,
3133 VAR_NAMESPACE
, LOC_BLOCK
,
3134 &objfile
->static_psymbols
,
3136 psymtab_language
, objfile
);
3139 /* Global functions were ignored here, but now they
3140 are put into the global psymtab like one would expect.
3141 They're also in the minimal symbol table. */
3145 int name_len
= p
- namestring
;
3146 char *name
= xmalloc (name_len
+ 1);
3147 memcpy (name
, namestring
, name_len
);
3148 name
[name_len
] = '\0';
3149 complain (&function_outside_compilation_unit
, name
);
3152 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3153 add_psymbol_to_list (namestring
, p
- namestring
,
3154 VAR_NAMESPACE
, LOC_BLOCK
,
3155 &objfile
->global_psymbols
,
3157 psymtab_language
, objfile
);
3160 /* Two things show up here (hopefully); static symbols of
3161 local scope (static used inside braces) or extensions
3162 of structure symbols. We can ignore both. */
3176 case '#': /* for symbol identification (used in live ranges) */
3177 /* added to support cfront stabs strings */
3178 case 'Z': /* for definition continuations */
3179 case 'P': /* for prototypes */
3183 /* It is a C++ nested symbol. We don't need to record it
3184 (I don't think); if we try to look up foo::bar::baz,
3185 then symbols for the symtab containing foo should get
3186 read in, I think. */
3187 /* Someone says sun cc puts out symbols like
3188 /foo/baz/maclib::/usr/local/bin/maclib,
3189 which would get here with a symbol type of ':'. */
3193 /* Unexpected symbol descriptor. The second and subsequent stabs
3194 of a continued stab can show up here. The question is
3195 whether they ever can mimic a normal stab--it would be
3196 nice if not, since we certainly don't want to spend the
3197 time searching to the end of every string looking for
3200 complain (&unknown_symchar_complaint
, p
[1]);
3202 /* Ignore it; perhaps it is an extension that we don't
3211 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
3212 /* Solaris 2 end of module, finish current partial
3213 symbol table. END_PSYMTAB will set
3214 pst->texthigh to the proper value, which is
3215 necessary if a module compiled without
3216 debugging info follows this module. */
3219 pst
= (struct partial_symtab
*) 0;
3221 dependencies_used
= 0;
3227 if (sh
.value
> save_pst
->texthigh
)
3228 save_pst
->texthigh
= sh
.value
;
3233 case N_SSYM
: /* Claim: Structure or union element.
3234 Hopefully, I can ignore this. */
3235 case N_ENTRY
: /* Alternate entry point; can ignore. */
3236 case N_MAIN
: /* Can definitely ignore this. */
3237 case N_CATCH
: /* These are GNU C++ extensions */
3238 case N_EHDECL
: /* that can safely be ignored here. */
3248 case N_NSYMS
: /* Ultrix 4.0: symbol count */
3249 case N_DEFD
: /* GNU Modula-2 */
3250 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
3252 case N_OBJ
: /* useless types from Solaris */
3254 /* These symbols aren't interesting; don't worry about them */
3259 /* If we haven't found it yet, ignore it. It's probably some
3260 new type we don't know about yet. */
3261 complain (&unknown_symtype_complaint
,
3262 local_hex_string (type_code
)); /*CUR_SYMBOL_TYPE*/
3266 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
3269 /* end - Handle continuation */
3274 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
3277 enum address_class
class;
3279 (*swap_sym_in
) (cur_bfd
,
3280 ((char *) debug_info
->external_sym
3281 + ((fh
->isymBase
+ cur_sdx
)
3282 * external_sym_size
)),
3285 if (ECOFF_IS_STAB (&sh
))
3291 /* Non absolute static symbols go into the minimal table. */
3292 if (SC_IS_UNDEF (sh
.sc
) || sh
.sc
== scNil
3293 || (sh
.index
== indexNil
3294 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
3296 /* FIXME, premature? */
3301 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3307 /* The value of a stEnd symbol is the displacement from the
3308 corresponding start symbol value, do not relocate it. */
3310 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3317 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3321 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3332 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3333 mst_file_text
, NULL
,
3334 SECT_OFF_TEXT (objfile
), NULL
,
3340 /* Usually there is a local and a global stProc symbol
3341 for a function. This means that the function name
3342 has already been entered into the mimimal symbol table
3343 while processing the global symbols in pass 2 above.
3344 One notable exception is the PROGRAM name from
3345 f77 compiled executables, it is only put out as
3346 local stProc symbol, and a global MAIN__ stProc symbol
3347 points to it. It doesn't matter though, as gdb is
3348 still able to find the PROGRAM name via the partial
3349 symbol table, and the MAIN__ symbol via the minimal
3351 if (sh
.st
== stProc
)
3352 add_psymbol_to_list (name
, strlen (name
),
3353 VAR_NAMESPACE
, LOC_BLOCK
,
3354 &objfile
->global_psymbols
,
3355 0, sh
.value
, psymtab_language
, objfile
);
3357 add_psymbol_to_list (name
, strlen (name
),
3358 VAR_NAMESPACE
, LOC_BLOCK
,
3359 &objfile
->static_psymbols
,
3360 0, sh
.value
, psymtab_language
, objfile
);
3362 /* Skip over procedure to next one. */
3363 if (sh
.index
>= hdr
->iauxMax
)
3365 /* Should not happen, but does when cross-compiling
3366 with the MIPS compiler. FIXME -- pull later. */
3367 complain (&index_complaint
, name
);
3368 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
3371 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
3372 (debug_info
->external_aux
3375 procaddr
= sh
.value
;
3377 if (new_sdx
<= cur_sdx
)
3379 /* This should not happen either... FIXME. */
3380 complain (&aux_index_complaint
, name
);
3381 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3385 (*swap_sym_in
) (cur_bfd
,
3386 ((char *) debug_info
->external_sym
3387 + ((fh
->isymBase
+ cur_sdx
- 1)
3388 * external_sym_size
)),
3393 /* Kludge for Irix 5.2 zero fh->adr. */
3395 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
3396 pst
->textlow
= procaddr
;
3398 high
= procaddr
+ sh
.value
;
3399 if (high
> pst
->texthigh
)
3400 pst
->texthigh
= high
;
3403 case stStatic
: /* Variable */
3404 if (SC_IS_DATA (sh
.sc
))
3405 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3406 mst_file_data
, NULL
,
3407 SECT_OFF_DATA (objfile
),
3411 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3413 SECT_OFF_BSS (objfile
),
3419 case stIndirect
: /* Irix5 forward declaration */
3420 /* Skip forward declarations from Irix5 cc */
3423 case stTypedef
: /* Typedef */
3424 /* Skip typedefs for forward declarations and opaque
3425 structs from alpha and mips cc. */
3426 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
3428 class = LOC_TYPEDEF
;
3431 case stConstant
: /* Constant decl */
3438 case stBlock
: /* { }, str, un, enum */
3439 /* Do not create a partial symbol for cc unnamed aggregates
3440 and gcc empty aggregates. */
3441 if ((sh
.sc
== scInfo
3442 || SC_IS_COMMON (sh
.sc
))
3444 && sh
.index
!= cur_sdx
+ 2)
3446 add_psymbol_to_list (name
, strlen (name
),
3447 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
3448 &objfile
->static_psymbols
,
3450 psymtab_language
, objfile
);
3452 handle_psymbol_enumerators (objfile
, fh
, sh
.st
, sh
.value
);
3454 /* Skip over the block */
3456 if (new_sdx
<= cur_sdx
)
3458 /* This happens with the Ultrix kernel. */
3459 complain (&block_index_complaint
, name
);
3460 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3465 case stFile
: /* File headers */
3466 case stLabel
: /* Labels */
3467 case stEnd
: /* Ends of files */
3470 case stLocal
: /* Local variables */
3471 /* Normally these are skipped because we skip over
3472 all blocks we see. However, these can occur
3473 as visible symbols in a .h file that contains code. */
3477 /* Both complaints are valid: one gives symbol name,
3478 the other the offending symbol type. */
3479 complain (&unknown_sym_complaint
, name
);
3480 complain (&unknown_st_complaint
, sh
.st
);
3484 /* Use this gdb symbol */
3485 add_psymbol_to_list (name
, strlen (name
),
3486 VAR_NAMESPACE
, class,
3487 &objfile
->static_psymbols
,
3488 0, sh
.value
, psymtab_language
, objfile
);
3490 cur_sdx
++; /* Go to next file symbol */
3493 /* Now do enter the external symbols. */
3494 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
3495 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
3496 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
3497 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
3498 for (; --cur_sdx
>= 0; ext_ptr
++)
3500 enum address_class
class;
3505 if (ext_ptr
->ifd
!= f_idx
)
3506 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
3507 psh
= &ext_ptr
->asym
;
3509 /* Do not add undefined symbols to the partial symbol table. */
3510 if (SC_IS_UNDEF (psh
->sc
) || psh
->sc
== scNil
)
3513 svalue
= psh
->value
;
3518 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3525 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3529 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3536 /* These are generated for static symbols in .o files,
3541 /* External procedure symbols have been entered
3542 into the minimal symbol table in pass 2 above.
3543 Ignore them, as parse_external will ignore them too. */
3549 complain (&unknown_ext_complaint
,
3550 debug_info
->ssext
+ psh
->iss
);
3551 /* Fall through, pretend it's global. */
3553 /* Global common symbols are resolved by the runtime loader,
3555 if (SC_IS_COMMON (psh
->sc
))
3561 name
= debug_info
->ssext
+ psh
->iss
;
3562 add_psymbol_to_list (name
, strlen (name
),
3563 VAR_NAMESPACE
, class,
3564 &objfile
->global_psymbols
,
3566 psymtab_language
, objfile
);
3570 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3571 empty and put on the free list. */
3572 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
3573 psymtab_include_list
, includes_used
,
3574 -1, save_pst
->texthigh
,
3575 dependency_list
, dependencies_used
, textlow_not_set
);
3577 dependencies_used
= 0;
3579 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
3580 objfile
->ei
.entry_point
< save_pst
->texthigh
)
3582 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
3583 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
3586 /* The objfile has its functions reordered if this partial symbol
3587 table overlaps any other partial symbol table.
3588 We cannot assume a reordered objfile if a partial symbol table
3589 is contained within another partial symbol table, as partial symbol
3590 tables for include files with executable code are contained
3591 within the partial symbol table for the including source file,
3592 and we do not want to flag the objfile reordered for these cases.
3594 This strategy works well for Irix-5.2 shared libraries, but we
3595 might have to use a more elaborate (and slower) algorithm for
3597 save_pst
= fdr_to_pst
[f_idx
].pst
;
3598 if (save_pst
!= NULL
3599 && save_pst
->textlow
!= 0
3600 && !(objfile
->flags
& OBJF_REORDERED
))
3602 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
3605 && save_pst
->textlow
>= pst
->textlow
3606 && save_pst
->textlow
< pst
->texthigh
3607 && save_pst
->texthigh
> pst
->texthigh
)
3609 objfile
->flags
|= OBJF_REORDERED
;
3616 /* Now scan the FDRs for dependencies */
3617 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3619 fh
= f_idx
+ debug_info
->fdr
;
3620 pst
= fdr_to_pst
[f_idx
].pst
;
3622 if (pst
== (struct partial_symtab
*) NULL
)
3625 /* This should catch stabs-in-ecoff. */
3629 /* Skip the first file indirect entry as it is a self dependency
3630 for source files or a reverse .h -> .c dependency for header files. */
3631 pst
->number_of_dependencies
= 0;
3633 ((struct partial_symtab
**)
3634 obstack_alloc (&objfile
->psymbol_obstack
,
3636 * sizeof (struct partial_symtab
*))));
3637 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3641 (*swap_rfd_in
) (cur_bfd
,
3642 ((char *) debug_info
->external_rfd
3643 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3645 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3647 complain (&bad_file_number_complaint
, rh
);
3651 /* Skip self dependencies of header files. */
3655 /* Do not add to dependeny list if psymtab was empty. */
3656 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*) NULL
)
3658 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
3662 /* Remove the dummy psymtab created for -O3 images above, if it is
3663 still empty, to enable the detection of stripped executables. */
3664 if (objfile
->psymtabs
->next
== NULL
3665 && objfile
->psymtabs
->number_of_dependencies
== 0
3666 && objfile
->psymtabs
->n_global_syms
== 0
3667 && objfile
->psymtabs
->n_static_syms
== 0)
3668 objfile
->psymtabs
= NULL
;
3669 do_cleanups (old_chain
);
3672 /* If the current psymbol has an enumerated type, we need to add
3673 all the the enum constants to the partial symbol table. */
3676 handle_psymbol_enumerators (struct objfile
*objfile
, FDR
*fh
, int stype
,
3679 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3680 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
3681 char *ext_sym
= ((char *) debug_info
->external_sym
3682 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3692 /* It is an enumerated type if the next symbol entry is a stMember
3693 and its auxiliary index is indexNil or its auxiliary entry
3694 is a plain btNil or btVoid.
3695 Alpha cc -migrate enums are recognized by a zero index and
3696 a zero symbol value.
3697 DU 4.0 cc enums are recognized by a member type of btEnum without
3698 qualifiers and a zero symbol value. */
3699 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3700 if (sh
.st
!= stMember
)
3703 if (sh
.index
== indexNil
3704 || (sh
.index
== 0 && svalue
== 0))
3706 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3707 &(debug_info
->external_aux
3708 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3710 if ((tir
.bt
!= btNil
3712 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3713 || tir
.tq0
!= tqNil
)
3725 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3726 if (sh
.st
!= stMember
)
3728 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3730 /* Note that the value doesn't matter for enum constants
3731 in psymtabs, just in symtabs. */
3732 add_psymbol_to_list (name
, strlen (name
),
3733 VAR_NAMESPACE
, LOC_CONST
,
3734 &objfile
->static_psymbols
, 0,
3735 (CORE_ADDR
) 0, psymtab_language
, objfile
);
3736 ext_sym
+= external_sym_size
;
3740 /* Get the next symbol. OBJFILE is unused. */
3743 mdebug_next_symbol_text (struct objfile
*objfile
)
3748 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3749 ((char *) debug_info
->external_sym
3750 + ((cur_fdr
->isymBase
+ cur_sdx
)
3751 * debug_swap
->external_sym_size
)),
3753 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3756 /* Ancillary function to psymtab_to_symtab(). Does all the work
3757 for turning the partial symtab PST into a symtab, recurring
3758 first on all dependent psymtabs. The argument FILENAME is
3759 only passed so we can see in debug stack traces what file
3762 This function has a split personality, based on whether the
3763 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3764 The flow of control and even the memory allocation differs. FIXME. */
3767 psymtab_to_symtab_1 (struct partial_symtab
*pst
, char *filename
)
3769 bfd_size_type external_sym_size
;
3770 bfd_size_type external_pdr_size
;
3771 void (*swap_sym_in
) (bfd
*, void *, SYMR
*);
3772 void (*swap_pdr_in
) (bfd
*, void *, PDR
*);
3774 struct symtab
*st
= NULL
;
3776 struct linetable
*lines
;
3777 CORE_ADDR lowest_pdr_addr
= 0;
3778 int last_symtab_ended
= 0;
3784 /* Read in all partial symbtabs on which this one is dependent.
3785 NOTE that we do have circular dependencies, sigh. We solved
3786 that by setting pst->readin before this point. */
3788 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3789 if (!pst
->dependencies
[i
]->readin
)
3791 /* Inform about additional files to be read in. */
3794 fputs_filtered (" ", gdb_stdout
);
3796 fputs_filtered ("and ", gdb_stdout
);
3798 printf_filtered ("%s...",
3799 pst
->dependencies
[i
]->filename
);
3800 wrap_here (""); /* Flush output */
3801 gdb_flush (gdb_stdout
);
3803 /* We only pass the filename for debug purposes */
3804 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3805 pst
->dependencies
[i
]->filename
);
3808 /* Do nothing if this is a dummy psymtab. */
3810 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3811 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3814 /* Now read the symbols for this symtab */
3816 cur_bfd
= CUR_BFD (pst
);
3817 debug_swap
= DEBUG_SWAP (pst
);
3818 debug_info
= DEBUG_INFO (pst
);
3819 pending_list
= PENDING_LIST (pst
);
3820 external_sym_size
= debug_swap
->external_sym_size
;
3821 external_pdr_size
= debug_swap
->external_pdr_size
;
3822 swap_sym_in
= debug_swap
->swap_sym_in
;
3823 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3824 current_objfile
= pst
->objfile
;
3825 cur_fd
= FDR_IDX (pst
);
3826 fh
= ((cur_fd
== -1)
3828 : debug_info
->fdr
+ cur_fd
);
3831 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3832 processing_gcc_compilation
= 0;
3833 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3837 (*swap_sym_in
) (cur_bfd
,
3838 ((char *) debug_info
->external_sym
3839 + (fh
->isymBase
+ 1) * external_sym_size
),
3841 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3844 /* We indicate that this is a GCC compilation so that certain
3845 features will be enabled in stabsread/dbxread. */
3846 processing_gcc_compilation
= 2;
3850 if (processing_gcc_compilation
!= 0)
3853 /* This symbol table contains stabs-in-ecoff entries. */
3855 /* Parse local symbols first */
3857 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3859 current_objfile
= NULL
;
3862 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3868 (*swap_sym_in
) (cur_bfd
,
3869 (((char *) debug_info
->external_sym
)
3870 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3872 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3874 /* XXX This is a hack. It will go away! */
3875 if (ECOFF_IS_STAB (&sh
) || (name
[0] == '#'))
3877 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3879 /* We should never get non N_STAB symbols here, but they
3880 should be harmless, so keep process_one_symbol from
3881 complaining about them. */
3882 if (type_code
& N_STAB
)
3884 /* If we found a trailing N_SO with no name, process
3885 it here instead of in process_one_symbol, so we
3886 can keep a handle to its symtab. The symtab
3887 would otherwise be ended twice, once in
3888 process_one_symbol, and once after this loop. */
3889 if (type_code
== N_SO
3891 && previous_stab_code
!= (unsigned char) N_SO
3894 valu
+= ANOFFSET (pst
->section_offsets
,
3895 SECT_OFF_TEXT (pst
->objfile
));
3896 previous_stab_code
= N_SO
;
3897 st
= end_symtab (valu
, pst
->objfile
,
3898 SECT_OFF_TEXT (pst
->objfile
));
3900 last_symtab_ended
= 1;
3904 last_symtab_ended
= 0;
3905 process_one_symbol (type_code
, 0, valu
, name
,
3906 pst
->section_offsets
, pst
->objfile
);
3909 /* Similarly a hack. */
3910 else if (name
[0] == '#')
3912 process_one_symbol (N_SLINE
, 0, valu
, name
,
3913 pst
->section_offsets
, pst
->objfile
);
3915 if (type_code
== N_FUN
)
3917 /* Make up special symbol to contain
3918 procedure specific info */
3919 struct mips_extra_func_info
*e
=
3920 ((struct mips_extra_func_info
*)
3921 obstack_alloc (¤t_objfile
->symbol_obstack
,
3922 sizeof (struct mips_extra_func_info
)));
3923 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3925 memset (e
, 0, sizeof (struct mips_extra_func_info
));
3926 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3927 SYMBOL_CLASS (s
) = LOC_CONST
;
3928 SYMBOL_TYPE (s
) = mdebug_type_void
;
3929 SYMBOL_VALUE (s
) = (long) e
;
3930 e
->pdr
.framereg
= -1;
3931 add_symbol_to_list (s
, &local_symbols
);
3934 else if (sh
.st
== stLabel
)
3936 if (sh
.index
== indexNil
)
3938 /* This is what the gcc2_compiled and __gnu_compiled_*
3939 show up as. So don't complain. */
3944 /* Handle encoded stab line number. */
3945 valu
+= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (pst
->objfile
));
3946 record_line (current_subfile
, sh
.index
, valu
);
3949 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3950 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3951 /* These are generated by gcc-2.x, do not complain */
3954 complain (&stab_unknown_complaint
, name
);
3957 if (! last_symtab_ended
)
3959 st
= end_symtab (pst
->texthigh
, pst
->objfile
, SECT_OFF_TEXT (pst
->objfile
));
3963 /* Sort the symbol table now, we are done adding symbols to it.
3964 We must do this before parse_procedure calls lookup_symbol. */
3965 sort_symtab_syms (st
);
3967 /* There used to be a call to sort_blocks here, but this should not
3968 be necessary for stabs symtabs. And as sort_blocks modifies the
3969 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3970 it did the wrong thing if the first procedure in a file was
3971 generated via asm statements. */
3973 /* Fill in procedure info next. */
3977 struct cleanup
*old_chain
;
3983 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
3984 old_chain
= make_cleanup (xfree
, pr_block
);
3986 pdr_ptr
= ((char *) debug_info
->external_pdr
3987 + fh
->ipdFirst
* external_pdr_size
);
3988 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3992 pdr_ptr
+= external_pdr_size
, pdr_in
++)
3994 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
3996 /* Determine lowest PDR address, the PDRs are not always
3998 if (pdr_in
== pr_block
)
3999 lowest_pdr_addr
= pdr_in
->adr
;
4000 else if (pdr_in
->adr
< lowest_pdr_addr
)
4001 lowest_pdr_addr
= pdr_in
->adr
;
4005 pdr_in_end
= pdr_in
+ fh
->cpd
;
4006 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4007 parse_procedure (pdr_in
, st
, pst
);
4009 do_cleanups (old_chain
);
4014 /* This symbol table contains ordinary ecoff entries. */
4020 /* How many symbols will we need */
4021 /* FIXME, this does not count enum values. */
4022 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
4026 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
4030 f_max
+= fh
->csym
+ fh
->cpd
;
4031 maxlines
= 2 * fh
->cline
;
4032 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
4034 /* The proper language was already determined when building
4035 the psymtab, use it. */
4036 st
->language
= PST_PRIVATE (pst
)->pst_language
;
4039 psymtab_language
= st
->language
;
4041 lines
= LINETABLE (st
);
4043 /* Get a new lexical context */
4045 push_parse_stack ();
4046 top_stack
->cur_st
= st
;
4047 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
4049 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
4050 BLOCK_END (top_stack
->cur_block
) = 0;
4051 top_stack
->blocktype
= stFile
;
4052 top_stack
->maxsyms
= 2 * f_max
;
4053 top_stack
->cur_type
= 0;
4054 top_stack
->procadr
= 0;
4055 top_stack
->numargs
= 0;
4056 found_ecoff_debugging_info
= 0;
4063 /* Parse local symbols first */
4064 sym_ptr
= ((char *) debug_info
->external_sym
4065 + fh
->isymBase
* external_sym_size
);
4066 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
4067 while (sym_ptr
< sym_end
)
4072 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
4073 c
= parse_symbol (&sh
,
4074 debug_info
->external_aux
+ fh
->iauxBase
,
4075 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4076 sym_ptr
+= c
* external_sym_size
;
4079 /* Linenumbers. At the end, check if we can save memory.
4080 parse_lines has to look ahead an arbitrary number of PDR
4081 structures, so we swap them all first. */
4085 struct cleanup
*old_chain
;
4091 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4093 old_chain
= make_cleanup (xfree
, pr_block
);
4095 pdr_ptr
= ((char *) debug_info
->external_pdr
4096 + fh
->ipdFirst
* external_pdr_size
);
4097 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4101 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4103 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4105 /* Determine lowest PDR address, the PDRs are not always
4107 if (pdr_in
== pr_block
)
4108 lowest_pdr_addr
= pdr_in
->adr
;
4109 else if (pdr_in
->adr
< lowest_pdr_addr
)
4110 lowest_pdr_addr
= pdr_in
->adr
;
4113 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
, lowest_pdr_addr
);
4114 if (lines
->nitems
< fh
->cline
)
4115 lines
= shrink_linetable (lines
);
4117 /* Fill in procedure info next. */
4119 pdr_in_end
= pdr_in
+ fh
->cpd
;
4120 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4121 parse_procedure (pdr_in
, 0, pst
);
4123 do_cleanups (old_chain
);
4127 LINETABLE (st
) = lines
;
4129 /* .. and our share of externals.
4130 XXX use the global list to speed up things here. how?
4131 FIXME, Maybe quit once we have found the right number of ext's? */
4132 top_stack
->cur_st
= st
;
4133 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
4135 top_stack
->blocktype
= stFile
;
4137 = (debug_info
->symbolic_header
.isymMax
4138 + debug_info
->symbolic_header
.ipdMax
4139 + debug_info
->symbolic_header
.iextMax
);
4141 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
4142 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
4143 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4145 /* If there are undefined symbols, tell the user.
4146 The alpha has an undefined symbol for every symbol that is
4147 from a shared library, so tell the user only if verbose is on. */
4148 if (info_verbose
&& n_undef_symbols
)
4150 printf_filtered ("File %s contains %d unresolved references:",
4151 st
->filename
, n_undef_symbols
);
4152 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
4153 n_undef_vars
, n_undef_procs
, n_undef_labels
);
4154 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
4161 /* Sort the symbol table now, we are done adding symbols to it. */
4162 sort_symtab_syms (st
);
4167 /* Now link the psymtab and the symtab. */
4170 current_objfile
= NULL
;
4173 /* Ancillary parsing procedures. */
4175 /* Return 1 if the symbol pointed to by SH has a cross reference
4176 to an opaque aggregate type, else 0. */
4179 has_opaque_xref (FDR
*fh
, SYMR
*sh
)
4186 if (sh
->index
== indexNil
)
4189 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
4190 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
4191 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
4195 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
4196 if (rn
->rfd
== 0xfff)
4197 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
4205 /* Lookup the type at relative index RN. Return it in TPP
4206 if found and in any event come up with its name PNAME.
4207 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4208 Return value says how many aux symbols we ate. */
4211 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. */
4212 char **pname
, int bigend
, char *sym_name
)
4221 struct mdebug_pending
*pend
;
4223 *tpp
= (struct type
*) NULL
;
4225 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
4227 /* Escape index means 'the next one' */
4228 if (rn
->rfd
== 0xfff)
4231 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
4238 /* mips cc uses a rf of -1 for opaque struct definitions.
4239 Set TYPE_FLAG_STUB for these types so that check_typedef will
4240 resolve them if the struct gets defined in another compilation unit. */
4243 *pname
= "<undefined>";
4244 *tpp
= init_type (type_code
, 0, TYPE_FLAG_STUB
, (char *) NULL
, current_objfile
);
4248 /* mips cc uses an escaped rn->index of 0 for struct return types
4249 of procedures that were compiled without -g. These will always remain
4251 if (rn
->rfd
== 0xfff && rn
->index
== 0)
4253 *pname
= "<undefined>";
4257 /* Find the relative file descriptor and the symbol in it. */
4258 fh
= get_rfd (fd
, rf
);
4259 xref_fd
= fh
- debug_info
->fdr
;
4261 if (rn
->index
>= fh
->csym
)
4263 /* File indirect entry is corrupt. */
4264 *pname
= "<illegal>";
4265 complain (&bad_rfd_entry_complaint
,
4266 sym_name
, xref_fd
, rn
->index
);
4270 /* If we have processed this symbol then we left a forwarding
4271 pointer to the type in the pending list. If not, we`ll put
4272 it in a list of pending types, to be processed later when
4273 the file will be. In any event, we collect the name for the
4276 esh
= ((char *) debug_info
->external_sym
4277 + ((fh
->isymBase
+ rn
->index
)
4278 * debug_swap
->external_sym_size
));
4279 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
4281 /* Make sure that this type of cross reference can be handled. */
4282 if ((sh
.sc
!= scInfo
4283 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
4284 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
4285 && sh
.st
!= stEnum
))
4286 && (sh
.st
!= stBlock
|| !SC_IS_COMMON (sh
.sc
)))
4288 /* File indirect entry is corrupt. */
4289 *pname
= "<illegal>";
4290 complain (&bad_rfd_entry_complaint
,
4291 sym_name
, xref_fd
, rn
->index
);
4295 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4297 pend
= is_pending_symbol (fh
, esh
);
4302 /* We have not yet seen this type. */
4304 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
4308 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4310 a) forward declarations of structs/unions/enums which are not
4311 defined in this compilation unit.
4312 For these the type will be void. This is a bad design decision
4313 as cross referencing across compilation units is impossible
4314 due to the missing name.
4315 b) forward declarations of structs/unions/enums/typedefs which
4316 are defined later in this file or in another file in the same
4317 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4318 Simply cross reference those again to get the true type.
4319 The forward references are not entered in the pending list and
4320 in the symbol table. */
4322 (*debug_swap
->swap_tir_in
) (bigend
,
4323 &(debug_info
->external_aux
4324 + fh
->iauxBase
+ sh
.index
)->a_ti
,
4326 if (tir
.tq0
!= tqNil
)
4327 complain (&illegal_forward_tq0_complaint
, sym_name
);
4331 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4333 *pname
= "<undefined>";
4340 (debug_info
->external_aux
4341 + fh
->iauxBase
+ sh
.index
+ 1),
4342 tpp
, type_code
, pname
,
4343 fh
->fBigendian
, sym_name
);
4347 /* Follow a forward typedef. This might recursively
4348 call cross_ref till we get a non typedef'ed type.
4349 FIXME: This is not correct behaviour, but gdb currently
4350 cannot handle typedefs without type copying. Type
4351 copying is impossible as we might have mutual forward
4352 references between two files and the copied type would not
4353 get filled in when we later parse its definition. */
4354 *tpp
= parse_type (xref_fd
,
4355 debug_info
->external_aux
+ fh
->iauxBase
,
4359 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4360 add_pending (fh
, esh
, *tpp
);
4364 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
4365 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4371 else if (sh
.st
== stTypedef
)
4373 /* Parse the type for a normal typedef. This might recursively call
4374 cross_ref till we get a non typedef'ed type.
4375 FIXME: This is not correct behaviour, but gdb currently
4376 cannot handle typedefs without type copying. But type copying is
4377 impossible as we might have mutual forward references between
4378 two files and the copied type would not get filled in when
4379 we later parse its definition. */
4380 *tpp
= parse_type (xref_fd
,
4381 debug_info
->external_aux
+ fh
->iauxBase
,
4385 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4389 /* Cross reference to a struct/union/enum which is defined
4390 in another file in the same compilation unit but that file
4391 has not been parsed yet.
4392 Initialize the type only, it will be filled in when
4393 it's definition is parsed. */
4394 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
4396 add_pending (fh
, esh
, *tpp
);
4399 /* We used one auxent normally, two if we got a "next one" rf. */
4404 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4405 keeping the symtab sorted */
4407 static struct symbol
*
4408 mylookup_symbol (char *name
, register struct block
*block
,
4409 namespace_enum
namespace, enum address_class
class)
4415 ALL_BLOCK_SYMBOLS (block
, i
, sym
)
4417 if (SYMBOL_NAME (sym
)[0] == inc
4418 && SYMBOL_NAMESPACE (sym
) == namespace
4419 && SYMBOL_CLASS (sym
) == class
4420 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
4424 block
= BLOCK_SUPERBLOCK (block
);
4426 return mylookup_symbol (name
, block
, namespace, class);
4431 /* Add a new symbol S to a block B.
4432 Infrequently, we will need to reallocate the block to make it bigger.
4433 We only detect this case when adding to top_stack->cur_block, since
4434 that's the only time we know how big the block is. FIXME. */
4437 add_symbol (struct symbol
*s
, struct block
*b
)
4439 int nsyms
= BLOCK_NSYMS (b
)++;
4440 struct block
*origb
;
4441 struct parse_stack
*stackp
;
4443 if (b
== top_stack
->cur_block
&&
4444 nsyms
>= top_stack
->maxsyms
)
4446 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
4447 /* In this case shrink_block is actually grow_block, since
4448 BLOCK_NSYMS(b) is larger than its current size. */
4450 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
4452 /* Now run through the stack replacing pointers to the
4453 original block. shrink_block has already done this
4454 for the blockvector and BLOCK_FUNCTION. */
4455 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
4457 if (stackp
->cur_block
== origb
)
4459 stackp
->cur_block
= b
;
4460 stackp
->maxsyms
= BLOCK_NSYMS (b
);
4464 BLOCK_SYM (b
, nsyms
) = s
;
4467 /* Add a new block B to a symtab S */
4470 add_block (struct block
*b
, struct symtab
*s
)
4472 struct blockvector
*bv
= BLOCKVECTOR (s
);
4474 bv
= (struct blockvector
*) xrealloc ((void *) bv
,
4475 (sizeof (struct blockvector
)
4476 + BLOCKVECTOR_NBLOCKS (bv
)
4477 * sizeof (bv
->block
)));
4478 if (bv
!= BLOCKVECTOR (s
))
4479 BLOCKVECTOR (s
) = bv
;
4481 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
4484 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4485 MIPS' linenumber encoding might need more than one byte
4486 to describe it, LAST is used to detect these continuation lines.
4488 Combining lines with the same line number seems like a bad idea.
4489 E.g: There could be a line number entry with the same line number after the
4490 prologue and GDB should not ignore it (this is a better way to find
4491 a prologue than mips_skip_prologue).
4492 But due to the compressed line table format there are line number entries
4493 for the same line which are needed to bridge the gap to the next
4494 line number entry. These entries have a bogus address info with them
4495 and we are unable to tell them from intended duplicate line number
4497 This is another reason why -ggdb debugging format is preferable. */
4500 add_line (struct linetable
*lt
, int lineno
, CORE_ADDR adr
, int last
)
4502 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4503 Change them to something sensible. */
4507 last
= -2; /* make sure we record first line */
4509 if (last
== lineno
) /* skip continuation lines */
4512 lt
->item
[lt
->nitems
].line
= lineno
;
4513 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
4517 /* Sorting and reordering procedures */
4519 /* Blocks with a smaller low bound should come first */
4522 compare_blocks (const void *arg1
, const void *arg2
)
4524 register int addr_diff
;
4525 struct block
**b1
= (struct block
**) arg1
;
4526 struct block
**b2
= (struct block
**) arg2
;
4528 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
4530 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
4534 /* Sort the blocks of a symtab S.
4535 Reorder the blocks in the blockvector by code-address,
4536 as required by some MI search routines */
4539 sort_blocks (struct symtab
*s
)
4541 struct blockvector
*bv
= BLOCKVECTOR (s
);
4543 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
4546 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
4547 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
4548 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
4549 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
4553 * This is very unfortunate: normally all functions are compiled in
4554 * the order they are found, but if the file is compiled -O3 things
4555 * are very different. It would be nice to find a reliable test
4556 * to detect -O3 images in advance.
4558 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
4559 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
4560 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
4561 sizeof (struct block
*),
4565 register CORE_ADDR high
= 0;
4566 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
4568 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
4569 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
4570 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
4571 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
4574 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
4575 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
4577 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4578 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4579 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4580 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4584 /* Constructor/restructor/destructor procedures */
4586 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
4587 MAXSYMS and linenumbers MAXLINES we'll put in it */
4589 static struct symtab
*
4590 new_symtab (char *name
, int maxsyms
, int maxlines
, struct objfile
*objfile
)
4592 struct symtab
*s
= allocate_symtab (name
, objfile
);
4594 LINETABLE (s
) = new_linetable (maxlines
);
4596 /* All symtabs must have at least two blocks */
4597 BLOCKVECTOR (s
) = new_bvect (2);
4598 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
4599 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
4600 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
4601 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4603 s
->free_code
= free_linetable
;
4604 s
->debugformat
= obsavestring ("ECOFF", 5,
4605 &objfile
->symbol_obstack
);
4609 /* Allocate a new partial_symtab NAME */
4611 static struct partial_symtab
*
4612 new_psymtab (char *name
, struct objfile
*objfile
)
4614 struct partial_symtab
*psymtab
;
4616 psymtab
= allocate_psymtab (name
, objfile
);
4617 psymtab
->section_offsets
= objfile
->section_offsets
;
4619 /* Keep a backpointer to the file's symbols */
4621 psymtab
->read_symtab_private
= ((char *)
4622 obstack_alloc (&objfile
->psymbol_obstack
,
4623 sizeof (struct symloc
)));
4624 memset (psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
4625 CUR_BFD (psymtab
) = cur_bfd
;
4626 DEBUG_SWAP (psymtab
) = debug_swap
;
4627 DEBUG_INFO (psymtab
) = debug_info
;
4628 PENDING_LIST (psymtab
) = pending_list
;
4630 /* The way to turn this into a symtab is to call... */
4631 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
4636 /* Allocate a linetable array of the given SIZE. Since the struct
4637 already includes one item, we subtract one when calculating the
4638 proper size to allocate. */
4640 static struct linetable
*
4641 new_linetable (int size
)
4643 struct linetable
*l
;
4645 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
4646 l
= (struct linetable
*) xmalloc (size
);
4651 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4652 I am not so sure about the 3.4 ones.
4654 Since the struct linetable already includes one item, we subtract one when
4655 calculating the proper size to allocate. */
4657 static struct linetable
*
4658 shrink_linetable (struct linetable
*lt
)
4661 return (struct linetable
*) xrealloc ((void *) lt
,
4662 (sizeof (struct linetable
)
4664 * sizeof (lt
->item
))));
4667 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4669 static struct blockvector
*
4670 new_bvect (int nblocks
)
4672 struct blockvector
*bv
;
4675 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4676 bv
= (struct blockvector
*) xzalloc (size
);
4678 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4683 /* Allocate and zero a new block of MAXSYMS symbols */
4685 static struct block
*
4686 new_block (int maxsyms
)
4688 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
4690 return (struct block
*) xzalloc (size
);
4693 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
4694 Shrink_block can also be used by add_symbol to grow a block. */
4696 static struct block
*
4697 shrink_block (struct block
*b
, struct symtab
*s
)
4700 struct blockvector
*bv
= BLOCKVECTOR (s
);
4703 /* Just reallocate it and fix references to the old one */
4705 new = (struct block
*) xrealloc ((void *) b
,
4706 (sizeof (struct block
)
4707 + ((BLOCK_NSYMS (b
) - 1)
4708 * sizeof (struct symbol
*))));
4710 /* FIXME: Not worth hashing this block as it's built. */
4711 /* All callers should have created the block with new_block (), which
4712 would mean it was not previously hashed. Make sure. */
4713 gdb_assert (BLOCK_HASHTABLE (new) == 0);
4715 /* Should chase pointers to old one. Fortunately, that`s just
4716 the block`s function and inferior blocks */
4717 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
4718 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
4719 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
4720 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
4721 BLOCKVECTOR_BLOCK (bv
, i
) = new;
4722 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
4723 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
4727 /* Create a new symbol with printname NAME */
4729 static struct symbol
*
4730 new_symbol (char *name
)
4732 struct symbol
*s
= ((struct symbol
*)
4733 obstack_alloc (¤t_objfile
->symbol_obstack
,
4734 sizeof (struct symbol
)));
4736 memset (s
, 0, sizeof (*s
));
4737 SYMBOL_NAME (s
) = obsavestring (name
, strlen (name
),
4738 ¤t_objfile
->symbol_obstack
);
4739 SYMBOL_LANGUAGE (s
) = psymtab_language
;
4740 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
4744 /* Create a new type with printname NAME */
4746 static struct type
*
4747 new_type (char *name
)
4751 t
= alloc_type (current_objfile
);
4752 TYPE_NAME (t
) = name
;
4753 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
4757 /* Read ECOFF debugging information from a BFD section. This is
4758 called from elfread.c. It parses the section into a
4759 ecoff_debug_info struct, and then lets the rest of the file handle
4763 elfmdebug_build_psymtabs (struct objfile
*objfile
,
4764 const struct ecoff_debug_swap
*swap
, asection
*sec
)
4766 bfd
*abfd
= objfile
->obfd
;
4767 struct ecoff_debug_info
*info
;
4769 info
= ((struct ecoff_debug_info
*)
4770 obstack_alloc (&objfile
->psymbol_obstack
,
4771 sizeof (struct ecoff_debug_info
)));
4773 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4774 error ("Error reading ECOFF debugging information: %s",
4775 bfd_errmsg (bfd_get_error ()));
4777 mdebug_build_psymtabs (objfile
, swap
, info
);
4781 /* Things used for calling functions in the inferior.
4782 These functions are exported to our companion
4783 mips-tdep.c file and are here because they play
4784 with the symbol-table explicitly. */
4786 /* Sigtramp: make sure we have all the necessary information
4787 about the signal trampoline code. Since the official code
4788 from MIPS does not do so, we make up that information ourselves.
4789 If they fix the library (unlikely) this code will neutralize itself. */
4791 /* FIXME: This function is called only by mips-tdep.c. It needs to be
4792 here because it calls functions defined in this file, but perhaps
4793 this could be handled in a better way. Only compile it in when
4794 tm-mips.h is included. */
4799 fixup_sigtramp (void)
4803 struct block
*b
, *b0
= NULL
;
4805 sigtramp_address
= -1;
4807 /* We have to handle the following cases here:
4808 a) The Mips library has a sigtramp label within sigvec.
4809 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
4810 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
4813 b0
= SYMBOL_BLOCK_VALUE (s
);
4814 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
4818 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
4819 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
4822 /* But maybe this program uses its own version of sigvec */
4826 /* Did we or MIPSco fix the library ? */
4827 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
4829 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
4830 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
4834 sigtramp_address
= SYMBOL_VALUE (s
);
4835 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
4837 /* But what symtab does it live in ? */
4838 st
= find_pc_symtab (SYMBOL_VALUE (s
));
4841 * Ok, there goes the fix: turn it into a procedure, with all the
4842 * needed info. Note we make it a nested procedure of sigvec,
4843 * which is the way the (assembly) code is actually written.
4845 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
4846 SYMBOL_CLASS (s
) = LOC_BLOCK
;
4847 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
4849 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = mdebug_type_void
;
4851 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4853 SYMBOL_BLOCK_VALUE (s
) = b
;
4854 BLOCK_START (b
) = sigtramp_address
;
4855 BLOCK_END (b
) = sigtramp_end
;
4856 BLOCK_FUNCTION (b
) = s
;
4857 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
4861 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4863 struct mips_extra_func_info
*e
=
4864 ((struct mips_extra_func_info
*)
4865 xzalloc (sizeof (struct mips_extra_func_info
)));
4867 e
->numargs
= 0; /* the kernel thinks otherwise */
4868 e
->pdr
.frameoffset
= 32;
4869 e
->pdr
.framereg
= SP_REGNUM
;
4870 /* Note that setting pcreg is no longer strictly necessary as
4871 mips_frame_saved_pc is now aware of signal handler frames. */
4872 e
->pdr
.pcreg
= PC_REGNUM
;
4873 e
->pdr
.regmask
= -2;
4874 /* Offset to saved r31, in the sigtramp case the saved registers
4875 are above the frame in the sigcontext.
4876 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4877 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4878 and 32 * 4 bytes for the floating point registers. */
4879 e
->pdr
.regoffset
= 4 + 12 + 31 * 4;
4880 e
->pdr
.fregmask
= -1;
4881 /* Offset to saved f30 (first saved *double* register). */
4882 e
->pdr
.fregoffset
= 4 + 12 + 32 * 4 + 12 + 30 * 4;
4883 e
->pdr
.isym
= (long) s
;
4884 e
->pdr
.adr
= sigtramp_address
;
4886 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
4887 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
4888 SYMBOL_VALUE (s
) = (long) e
;
4889 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
4890 SYMBOL_CLASS (s
) = LOC_CONST
;
4891 SYMBOL_TYPE (s
) = mdebug_type_void
;
4892 current_objfile
= NULL
;
4895 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
4898 #endif /* TM_MIPS_H */
4901 _initialize_mdebugread (void)
4904 init_type (TYPE_CODE_VOID
, 1,
4906 "void", (struct objfile
*) NULL
);
4908 init_type (TYPE_CODE_INT
, 1,
4910 "char", (struct objfile
*) NULL
);
4911 mdebug_type_unsigned_char
=
4912 init_type (TYPE_CODE_INT
, 1,
4914 "unsigned char", (struct objfile
*) NULL
);
4916 init_type (TYPE_CODE_INT
, 2,
4918 "short", (struct objfile
*) NULL
);
4919 mdebug_type_unsigned_short
=
4920 init_type (TYPE_CODE_INT
, 2,
4922 "unsigned short", (struct objfile
*) NULL
);
4923 mdebug_type_int_32
=
4924 init_type (TYPE_CODE_INT
, 4,
4926 "int", (struct objfile
*) NULL
);
4927 mdebug_type_unsigned_int_32
=
4928 init_type (TYPE_CODE_INT
, 4,
4930 "unsigned int", (struct objfile
*) NULL
);
4931 mdebug_type_int_64
=
4932 init_type (TYPE_CODE_INT
, 8,
4934 "int", (struct objfile
*) NULL
);
4935 mdebug_type_unsigned_int_64
=
4936 init_type (TYPE_CODE_INT
, 8,
4938 "unsigned int", (struct objfile
*) NULL
);
4939 mdebug_type_long_32
=
4940 init_type (TYPE_CODE_INT
, 4,
4942 "long", (struct objfile
*) NULL
);
4943 mdebug_type_unsigned_long_32
=
4944 init_type (TYPE_CODE_INT
, 4,
4946 "unsigned long", (struct objfile
*) NULL
);
4947 mdebug_type_long_64
=
4948 init_type (TYPE_CODE_INT
, 8,
4950 "long", (struct objfile
*) NULL
);
4951 mdebug_type_unsigned_long_64
=
4952 init_type (TYPE_CODE_INT
, 8,
4954 "unsigned long", (struct objfile
*) NULL
);
4955 mdebug_type_long_long_64
=
4956 init_type (TYPE_CODE_INT
, 8,
4958 "long long", (struct objfile
*) NULL
);
4959 mdebug_type_unsigned_long_long_64
=
4960 init_type (TYPE_CODE_INT
, 8,
4962 "unsigned long long", (struct objfile
*) NULL
);
4963 mdebug_type_adr_32
=
4964 init_type (TYPE_CODE_PTR
, 4,
4966 "adr_32", (struct objfile
*) NULL
);
4967 TYPE_TARGET_TYPE (mdebug_type_adr_32
) = mdebug_type_void
;
4968 mdebug_type_adr_64
=
4969 init_type (TYPE_CODE_PTR
, 8,
4971 "adr_64", (struct objfile
*) NULL
);
4972 TYPE_TARGET_TYPE (mdebug_type_adr_64
) = mdebug_type_void
;
4974 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4976 "float", (struct objfile
*) NULL
);
4977 mdebug_type_double
=
4978 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4980 "double", (struct objfile
*) NULL
);
4981 mdebug_type_complex
=
4982 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4984 "complex", (struct objfile
*) NULL
);
4985 TYPE_TARGET_TYPE (mdebug_type_complex
) = mdebug_type_float
;
4986 mdebug_type_double_complex
=
4987 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4989 "double complex", (struct objfile
*) NULL
);
4990 TYPE_TARGET_TYPE (mdebug_type_double_complex
) = mdebug_type_double
;
4992 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4994 mdebug_type_string
=
4995 init_type (TYPE_CODE_STRING
,
4996 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4998 (struct objfile
*) NULL
);
5000 /* We use TYPE_CODE_INT to print these as integers. Does this do any
5001 good? Would we be better off with TYPE_CODE_ERROR? Should
5002 TYPE_CODE_ERROR print things in hex if it knows the size? */
5003 mdebug_type_fixed_dec
=
5004 init_type (TYPE_CODE_INT
,
5005 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
5007 (struct objfile
*) NULL
);
5009 mdebug_type_float_dec
=
5010 init_type (TYPE_CODE_ERROR
,
5011 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
5012 0, "floating decimal",
5013 (struct objfile
*) NULL
);
5015 nodebug_func_symbol_type
= init_type (TYPE_CODE_FUNC
, 1, 0,
5016 "<function, no debug info>", NULL
);
5017 TYPE_TARGET_TYPE (nodebug_func_symbol_type
) = mdebug_type_int
;
5018 nodebug_var_symbol_type
=
5019 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
5020 "<variable, no debug info>", NULL
);