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
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. */
52 #include "stabsread.h"
53 #include "complaints.h"
56 /* These are needed if the tm.h file does not contain the necessary
57 mips specific definitions. */
59 #ifndef MIPS_EFI_SYMBOL_NAME
60 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
61 extern void ecoff_relocate_efi (struct symbol *, CORE_ADDR);
63 #include "coff/symconst.h"
64 typedef struct mips_extra_func_info
69 *mips_extra_func_info_t;
76 #include <sys/types.h>
80 #include "gdb_string.h"
84 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
86 #include "libaout.h" /* Private BFD a.out information. */
87 #include "aout/aout64.h"
88 #include "aout/stab_gnu.h" /* STABS information */
90 #include "expression.h"
91 #include "language.h" /* Needed inside partial-stab.h */
93 extern void _initialize_mdebugread (void);
95 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
96 We use this define in order to know whether we should override a
97 symbol's ECOFF section with its ELF section. This is necessary in
98 case the symbol's ELF section could not be represented in ECOFF. */
99 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
100 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
103 /* We put a pointer to this structure in the read_symtab_private field
108 /* Index of the FDR that this psymtab represents. */
110 /* The BFD that the psymtab was created from. */
112 const struct ecoff_debug_swap *debug_swap;
113 struct ecoff_debug_info *debug_info;
114 struct mdebug_pending **pending_list;
115 /* Pointer to external symbols for this file. */
117 /* Size of extern_tab. */
119 enum language pst_language;
122 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
123 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
124 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
125 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
126 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
127 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
129 #define SC_IS_TEXT(sc) ((sc) == scText \
130 || (sc) == scRConst \
133 #define SC_IS_DATA(sc) ((sc) == scData \
138 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
139 #define SC_IS_BSS(sc) ((sc) == scBss || (sc) == scSBss)
140 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
143 /* Things we import explicitly from other modules */
145 extern int info_verbose;
147 /* Various complaints about symbol reading that don't abort the process */
149 static struct complaint bad_file_number_complaint =
150 {"bad file number %d", 0, 0};
152 static struct complaint index_complaint =
153 {"bad aux index at symbol %s", 0, 0};
155 static struct complaint aux_index_complaint =
156 {"bad proc end in aux found from symbol %s", 0, 0};
158 static struct complaint block_index_complaint =
159 {"bad aux index at block symbol %s", 0, 0};
161 static struct complaint unknown_ext_complaint =
162 {"unknown external symbol %s", 0, 0};
164 static struct complaint unknown_sym_complaint =
165 {"unknown local symbol %s", 0, 0};
167 static struct complaint unknown_st_complaint =
168 {"with type %d", 0, 0};
170 static struct complaint block_overflow_complaint =
171 {"block containing %s overfilled", 0, 0};
173 static struct complaint basic_type_complaint =
174 {"cannot map ECOFF basic type 0x%x for %s", 0, 0};
176 static struct complaint unknown_type_qual_complaint =
177 {"unknown type qualifier 0x%x", 0, 0};
179 static struct complaint array_index_type_complaint =
180 {"illegal array index type for %s, assuming int", 0, 0};
182 static struct complaint bad_tag_guess_complaint =
183 {"guessed tag type of %s incorrectly", 0, 0};
185 static struct complaint block_member_complaint =
186 {"declaration block contains unhandled symbol type %d", 0, 0};
188 static struct complaint stEnd_complaint =
189 {"stEnd with storage class %d not handled", 0, 0};
191 static struct complaint unknown_mdebug_symtype_complaint =
192 {"unknown symbol type 0x%x", 0, 0};
194 static struct complaint stab_unknown_complaint =
195 {"unknown stabs symbol %s", 0, 0};
197 static struct complaint pdr_for_nonsymbol_complaint =
198 {"PDR for %s, but no symbol", 0, 0};
200 static struct complaint pdr_static_symbol_complaint =
201 {"can't handle PDR for static proc at 0x%lx", 0, 0};
203 static struct complaint bad_setjmp_pdr_complaint =
204 {"fixing bad setjmp PDR from libc", 0, 0};
206 static struct complaint bad_fbitfield_complaint =
207 {"can't handle TIR fBitfield for %s", 0, 0};
209 static struct complaint bad_continued_complaint =
210 {"illegal TIR continued for %s", 0, 0};
212 static struct complaint bad_rfd_entry_complaint =
213 {"bad rfd entry for %s: file %d, index %d", 0, 0};
215 static struct complaint unexpected_type_code_complaint =
216 {"unexpected type code for %s", 0, 0};
218 static struct complaint unable_to_cross_ref_complaint =
219 {"unable to cross ref btTypedef for %s", 0, 0};
221 static struct complaint bad_indirect_xref_complaint =
222 {"unable to cross ref btIndirect for %s", 0, 0};
224 static struct complaint illegal_forward_tq0_complaint =
225 {"illegal tq0 in forward typedef for %s", 0, 0};
227 static struct complaint illegal_forward_bt_complaint =
228 {"illegal bt %d in forward typedef for %s", 0, 0};
230 static struct complaint bad_linetable_guess_complaint =
231 {"guessed size of linetable for %s incorrectly", 0, 0};
233 static struct complaint bad_ext_ifd_complaint =
234 {"bad ifd for external symbol: %d (max %d)", 0, 0};
236 static struct complaint bad_ext_iss_complaint =
237 {"bad iss for external symbol: %ld (max %ld)", 0, 0};
239 /* Macros and extra defs */
241 /* Puns: hard to find whether -g was used and how */
243 #define MIN_GLEVEL GLEVEL_0
244 #define compare_glevel(a,b) \
245 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
246 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
248 /* Things that really are local to this module */
250 /* Remember what we deduced to be the source language of this psymtab. */
252 static enum language psymtab_language = language_unknown;
258 /* How to parse debugging information for CUR_BFD. */
260 static const struct ecoff_debug_swap *debug_swap;
262 /* Pointers to debugging information for CUR_BFD. */
264 static struct ecoff_debug_info *debug_info;
266 /* Pointer to current file decriptor record, and its index */
271 /* Index of current symbol */
275 /* Note how much "debuggable" this image is. We would like
276 to see at least one FDR with full symbols */
278 static int max_gdbinfo;
279 static int max_glevel;
281 /* When examining .o files, report on undefined symbols */
283 static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
285 /* Pseudo symbol to use when putting stabs into the symbol table. */
287 static char stabs_symbol[] = STABS_SYMBOL;
289 /* Types corresponding to mdebug format bt* basic types. */
291 static struct type *mdebug_type_void;
292 static struct type *mdebug_type_char;
293 static struct type *mdebug_type_short;
294 static struct type *mdebug_type_int_32;
295 #define mdebug_type_int mdebug_type_int_32
296 static struct type *mdebug_type_int_64;
297 static struct type *mdebug_type_long_32;
298 static struct type *mdebug_type_long_64;
299 static struct type *mdebug_type_long_long_64;
300 static struct type *mdebug_type_unsigned_char;
301 static struct type *mdebug_type_unsigned_short;
302 static struct type *mdebug_type_unsigned_int_32;
303 static struct type *mdebug_type_unsigned_int_64;
304 static struct type *mdebug_type_unsigned_long_32;
305 static struct type *mdebug_type_unsigned_long_64;
306 static struct type *mdebug_type_unsigned_long_long_64;
307 static struct type *mdebug_type_adr_32;
308 static struct type *mdebug_type_adr_64;
309 static struct type *mdebug_type_float;
310 static struct type *mdebug_type_double;
311 static struct type *mdebug_type_complex;
312 static struct type *mdebug_type_double_complex;
313 static struct type *mdebug_type_fixed_dec;
314 static struct type *mdebug_type_float_dec;
315 static struct type *mdebug_type_string;
317 /* Types for symbols from files compiled without debugging info. */
319 static struct type *nodebug_func_symbol_type;
320 static struct type *nodebug_var_symbol_type;
322 /* Nonzero if we have seen ecoff debugging info for a file. */
324 static int found_ecoff_debugging_info;
326 /* Forward declarations */
328 static void add_pending (FDR *, char *, struct type *);
330 static struct mdebug_pending *is_pending_symbol (FDR *, char *);
332 static void pop_parse_stack (void);
334 static void push_parse_stack (void);
336 static char *fdr_name (FDR *);
338 static void mdebug_psymtab_to_symtab (struct partial_symtab *);
341 upgrade_type (int, struct type **, int, union aux_ext *, int, char *);
343 static void parse_partial_symbols (struct objfile *);
345 static FDR * get_rfd (int, int);
347 static int has_opaque_xref (FDR *, SYMR *);
350 cross_ref (int, union aux_ext *, struct type **, enum type_code,
351 char **, int, char *);
353 static struct symbol *new_symbol (char *);
355 static struct type *new_type (char *);
357 static struct block *new_block (int);
359 static struct symtab *new_symtab (char *, int, int, struct objfile *);
361 static struct linetable *new_linetable (int);
363 static struct blockvector *new_bvect (int);
366 parse_symbol (SYMR *, union aux_ext *, char *, int, struct section_offsets *,
369 static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
372 static struct symbol *mylookup_symbol (char *, struct block *, namespace_enum,
375 static struct block *shrink_block (struct block *, struct symtab *);
377 static PTR xzalloc (unsigned int);
379 static void sort_blocks (struct symtab *);
381 static int compare_blocks (const PTR, const PTR);
383 static struct partial_symtab *new_psymtab (char *, struct objfile *);
385 static void psymtab_to_symtab_1 (struct partial_symtab *, char *);
387 static void add_block (struct block *, struct symtab *);
389 static void add_symbol (struct symbol *, struct block *);
391 static int add_line (struct linetable *, int, CORE_ADDR, int);
393 static struct linetable *shrink_linetable (struct linetable *);
396 handle_psymbol_enumerators (struct objfile *, FDR *, int, CORE_ADDR);
398 static char *mdebug_next_symbol_text (struct objfile *);
400 /* Address bounds for the signal trampoline in inferior, if any */
402 CORE_ADDR sigtramp_address, sigtramp_end;
404 /* Allocate zeroed memory */
407 xzalloc (unsigned int size)
409 PTR p = xmalloc (size);
415 /* Exported procedure: Builds a symtab from the PST partial one.
416 Restores the environment in effect when PST was created, delegates
417 most of the work to an ancillary procedure, and sorts
418 and reorders the symtab list at the end */
421 mdebug_psymtab_to_symtab (struct partial_symtab *pst)
429 printf_filtered ("Reading in symbols for %s...", pst->filename);
430 gdb_flush (gdb_stdout);
433 next_symbol_text_func = mdebug_next_symbol_text;
435 psymtab_to_symtab_1 (pst, pst->filename);
437 /* Match with global symbols. This only needs to be done once,
438 after all of the symtabs and dependencies have been read in. */
439 scan_file_globals (pst->objfile);
442 printf_filtered ("done.\n");
445 /* File-level interface functions */
447 /* Find a file descriptor given its index RF relative to a file CF */
450 get_rfd (int cf, int rf)
456 fdrs = debug_info->fdr;
458 /* Object files do not have the RFD table, all refs are absolute */
461 (*debug_swap->swap_rfd_in) (cur_bfd,
462 ((char *) debug_info->external_rfd
464 * debug_swap->external_rfd_size)),
469 /* Return a safer print NAME for a file descriptor */
475 return "<stripped file>";
478 return debug_info->ss + f->issBase + f->rss;
482 /* Read in and parse the symtab of the file OBJFILE. Symbols from
483 different sections are relocated via the SECTION_OFFSETS. */
486 mdebug_build_psymtabs (struct objfile *objfile,
487 const struct ecoff_debug_swap *swap,
488 struct ecoff_debug_info *info)
490 cur_bfd = objfile->obfd;
494 stabsread_new_init ();
495 buildsym_new_init ();
496 free_header_files ();
497 init_header_files ();
499 /* Make sure all the FDR information is swapped in. */
500 if (info->fdr == (FDR *) NULL)
506 info->fdr = (FDR *) obstack_alloc (&objfile->psymbol_obstack,
507 (info->symbolic_header.ifdMax
509 fdr_src = info->external_fdr;
511 + info->symbolic_header.ifdMax * swap->external_fdr_size);
513 for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++)
514 (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);
517 parse_partial_symbols (objfile);
520 /* Check to make sure file was compiled with -g. If not, warn the
521 user of this limitation. */
522 if (compare_glevel (max_glevel, GLEVEL_2) < 0)
524 if (max_gdbinfo == 0)
525 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
527 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
528 gdb_flush (gdb_stdout);
533 /* Local utilities */
535 /* Map of FDR indexes to partial symtabs */
539 struct partial_symtab *pst; /* the psymtab proper */
540 long n_globals; /* exported globals (external symbols) */
541 long globals_offset; /* cumulative */
545 /* Utility stack, used to nest procedures and blocks properly.
546 It is a doubly linked list, to avoid too many alloc/free.
547 Since we might need it quite a few times it is NOT deallocated
550 static struct parse_stack
552 struct parse_stack *next, *prev;
553 struct symtab *cur_st; /* Current symtab. */
554 struct block *cur_block; /* Block in it. */
556 /* What are we parsing. stFile, or stBlock are for files and
557 blocks. stProc or stStaticProc means we have seen the start of a
558 procedure, but not the start of the block within in. When we see
559 the start of that block, we change it to stNil, without pushing a
560 new block, i.e. stNil means both a procedure and a block. */
564 int maxsyms; /* Max symbols in this block. */
565 struct type *cur_type; /* Type we parse fields for. */
566 int cur_field; /* Field number in cur_type. */
567 CORE_ADDR procadr; /* Start addres of this procedure */
568 int numargs; /* Its argument count */
571 *top_stack; /* Top stack ptr */
574 /* Enter a new lexical context */
577 push_parse_stack (void)
579 struct parse_stack *new;
581 /* Reuse frames if possible */
582 if (top_stack && top_stack->prev)
583 new = top_stack->prev;
585 new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
586 /* Initialize new frame with previous content */
589 register struct parse_stack *prev = new->prev;
592 top_stack->prev = new;
594 new->next = top_stack;
599 /* Exit a lexical context */
602 pop_parse_stack (void)
607 top_stack = top_stack->next;
611 /* Cross-references might be to things we haven't looked at
612 yet, e.g. type references. To avoid too many type
613 duplications we keep a quick fixup table, an array
614 of lists of references indexed by file descriptor */
616 struct mdebug_pending
618 struct mdebug_pending *next; /* link */
619 char *s; /* the unswapped symbol */
620 struct type *t; /* its partial type descriptor */
624 /* The pending information is kept for an entire object file, and used
625 to be in the sym_private field. I took it out when I split
626 mdebugread from mipsread, because this might not be the only type
627 of symbols read from an object file. Instead, we allocate the
628 pending information table when we create the partial symbols, and
629 we store a pointer to the single table in each psymtab. */
631 static struct mdebug_pending **pending_list;
633 /* Check whether we already saw symbol SH in file FH */
635 static struct mdebug_pending *
636 is_pending_symbol (FDR *fh, char *sh)
638 int f_idx = fh - debug_info->fdr;
639 register struct mdebug_pending *p;
641 /* Linear search is ok, list is typically no more than 10 deep */
642 for (p = pending_list[f_idx]; p; p = p->next)
648 /* Add a new symbol SH of type T */
651 add_pending (FDR *fh, char *sh, struct type *t)
653 int f_idx = fh - debug_info->fdr;
654 struct mdebug_pending *p = is_pending_symbol (fh, sh);
656 /* Make sure we do not make duplicates */
659 p = ((struct mdebug_pending *)
660 obstack_alloc (¤t_objfile->psymbol_obstack,
661 sizeof (struct mdebug_pending)));
664 p->next = pending_list[f_idx];
665 pending_list[f_idx] = p;
670 /* Parsing Routines proper. */
672 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
673 For blocks, procedures and types we open a new lexical context.
674 This is basically just a big switch on the symbol's type. Argument
675 AX is the base pointer of aux symbols for this file (fh->iauxBase).
676 EXT_SH points to the unswapped symbol, which is needed for struct,
677 union, etc., types; it is NULL for an EXTR. BIGEND says whether
678 aux symbols are big-endian or little-endian. Return count of
679 SYMR's handled (normally one). */
682 parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
683 struct section_offsets *section_offsets, struct objfile *objfile)
685 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
686 void (*const swap_sym_in) (bfd *, PTR, SYMR *) = debug_swap->swap_sym_in;
690 struct mdebug_pending *pend;
694 enum address_class class;
696 long svalue = sh->value;
699 if (ext_sh == (char *) NULL)
700 name = debug_info->ssext + sh->iss;
702 name = debug_info->ss + cur_fdr->issBase + sh->iss;
708 /* Do not relocate relative values.
709 The value of a stEnd symbol is the displacement from the
710 corresponding start symbol value.
711 The value of a stBlock symbol is the displacement from the
712 procedure address. */
713 if (sh->st != stEnd && sh->st != stBlock)
714 sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
721 sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
725 sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
734 case stGlobal: /* external symbol, goes into global block */
736 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
738 s = new_symbol (name);
739 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
742 case stStatic: /* static data, goes into current block. */
744 b = top_stack->cur_block;
745 s = new_symbol (name);
746 if (SC_IS_COMMON (sh->sc))
748 /* It is a FORTRAN common block. At least for SGI Fortran the
749 address is not in the symbol; we need to fix it later in
750 scan_file_globals. */
751 int bucket = hashname (SYMBOL_NAME (s));
752 SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
753 global_sym_chain[bucket] = s;
756 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
759 case stLocal: /* local variable, goes into current block */
760 if (sh->sc == scRegister)
762 class = LOC_REGISTER;
763 svalue = ECOFF_REG_TO_REGNUM (svalue);
767 b = top_stack->cur_block;
768 s = new_symbol (name);
769 SYMBOL_VALUE (s) = svalue;
771 data: /* Common code for symbols describing data */
772 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
773 SYMBOL_CLASS (s) = class;
776 /* Type could be missing if file is compiled without debugging info. */
777 if (SC_IS_UNDEF (sh->sc)
778 || sh->sc == scNil || sh->index == indexNil)
779 SYMBOL_TYPE (s) = nodebug_var_symbol_type;
781 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
782 /* Value of a data symbol is its memory address */
785 case stParam: /* arg to procedure, goes into current block */
787 found_ecoff_debugging_info = 1;
788 top_stack->numargs++;
790 /* Special GNU C++ name. */
791 if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0)
792 name = "this"; /* FIXME, not alloc'd in obstack */
793 s = new_symbol (name);
795 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
799 /* Pass by value in register. */
800 SYMBOL_CLASS (s) = LOC_REGPARM;
801 svalue = ECOFF_REG_TO_REGNUM (svalue);
804 /* Pass by reference on stack. */
805 SYMBOL_CLASS (s) = LOC_REF_ARG;
808 /* Pass by reference in register. */
809 SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
810 svalue = ECOFF_REG_TO_REGNUM (svalue);
813 /* Pass by value on stack. */
814 SYMBOL_CLASS (s) = LOC_ARG;
817 SYMBOL_VALUE (s) = svalue;
818 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
819 add_symbol (s, top_stack->cur_block);
822 case stLabel: /* label, goes into current block */
823 s = new_symbol (name);
824 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; /* so that it can be used */
825 SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused */
826 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
827 SYMBOL_TYPE (s) = mdebug_type_int;
828 add_symbol (s, top_stack->cur_block);
831 case stProc: /* Procedure, usually goes into global block */
832 case stStaticProc: /* Static procedure, goes into current block */
833 s = new_symbol (name);
834 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
835 SYMBOL_CLASS (s) = LOC_BLOCK;
836 /* Type of the return value */
837 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
841 t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
842 if (STREQ (name, "malloc") && t->code == TYPE_CODE_VOID)
844 /* I don't know why, but, at least under Alpha GNU/Linux,
845 when linking against a malloc without debugging
846 symbols, its read as a function returning void---this
847 is bad because it means we cannot call functions with
848 string arguments interactively; i.e., "call
849 printf("howdy\n")" would fail with the error message
850 "program has no memory available". To avoid this, we
851 patch up the type and make it void*
852 instead. (davidm@azstarnet.com)
854 t = make_pointer_type (t, NULL);
857 b = top_stack->cur_block;
858 if (sh->st == stProc)
860 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
861 /* The next test should normally be true, but provides a
862 hook for nested functions (which we don't want to make
864 if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
865 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
866 /* Irix 5 sometimes has duplicate names for the same
867 function. We want to add such names up at the global
868 level, not as a nested function. */
869 else if (sh->value == top_stack->procadr)
870 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
874 /* Make a type for the procedure itself */
875 SYMBOL_TYPE (s) = lookup_function_type (t);
877 /* Create and enter a new lexical context */
878 b = new_block (top_stack->maxsyms);
879 SYMBOL_BLOCK_VALUE (s) = b;
880 BLOCK_FUNCTION (b) = s;
881 BLOCK_START (b) = BLOCK_END (b) = sh->value;
882 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
883 add_block (b, top_stack->cur_st);
885 /* Not if we only have partial info */
886 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
890 top_stack->cur_block = b;
891 top_stack->blocktype = sh->st;
892 top_stack->cur_type = SYMBOL_TYPE (s);
893 top_stack->cur_field = -1;
894 top_stack->procadr = sh->value;
895 top_stack->numargs = 0;
898 /* Beginning of code for structure, union, and enum definitions.
899 They all share a common set of local variables, defined here. */
901 enum type_code type_code;
907 case stStruct: /* Start a block defining a struct type */
908 type_code = TYPE_CODE_STRUCT;
909 goto structured_common;
911 case stUnion: /* Start a block defining a union type */
912 type_code = TYPE_CODE_UNION;
913 goto structured_common;
915 case stEnum: /* Start a block defining an enum type */
916 type_code = TYPE_CODE_ENUM;
917 goto structured_common;
919 case stBlock: /* Either a lexical block, or some type */
920 if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc))
921 goto case_stBlock_code; /* Lexical block */
923 type_code = TYPE_CODE_UNDEF; /* We have a type. */
925 /* Common code for handling struct, union, enum, and/or as-yet-
926 unknown-type blocks of info about structured data. `type_code'
927 has been set to the proper TYPE_CODE, if we know it. */
929 found_ecoff_debugging_info = 1;
931 top_stack->blocktype = stBlock;
933 /* First count the number of fields and the highest value. */
936 for (ext_tsym = ext_sh + external_sym_size;
938 ext_tsym += external_sym_size)
942 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
950 if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
952 /* If the type of the member is Nil (or Void),
953 without qualifiers, assume the tag is an
955 Alpha cc -migrate enums are recognized by a zero
956 index and a zero symbol value.
957 DU 4.0 cc enums are recognized by a member type of
958 btEnum without qualifiers and a zero symbol value. */
959 if (tsym.index == indexNil
960 || (tsym.index == 0 && sh->value == 0))
961 type_code = TYPE_CODE_ENUM;
964 (*debug_swap->swap_tir_in) (bigend,
965 &ax[tsym.index].a_ti,
967 if ((tir.bt == btNil || tir.bt == btVoid
968 || (tir.bt == btEnum && sh->value == 0))
970 type_code = TYPE_CODE_ENUM;
974 if (tsym.value > max_value)
975 max_value = tsym.value;
984 /* This is a no-op; is it trying to tell us something
985 we should be checking? */
986 if (tsym.sc == scVariant); /*UNIMPLEMENTED */
990 /* This is something like a struct within a
991 struct. Skip over the fields of the inner
992 struct. The -1 is because the for loop will
993 increment ext_tsym. */
994 ext_tsym = ((char *) debug_info->external_sym
995 + ((cur_fdr->isymBase + tsym.index - 1)
996 * external_sym_size));
1002 /* mips cc puts out a typedef for struct x if it is not yet
1003 defined when it encounters
1004 struct y { struct x *xp; };
1009 /* Irix5 cc puts out a stIndirect for struct x if it is not
1010 yet defined when it encounters
1011 struct y { struct x *xp; };
1016 complain (&block_member_complaint, tsym.st);
1021 /* In an stBlock, there is no way to distinguish structs,
1022 unions, and enums at this point. This is a bug in the
1023 original design (that has been fixed with the recent
1024 addition of the stStruct, stUnion, and stEnum symbol
1025 types.) The way you can tell is if/when you see a variable
1026 or field of that type. In that case the variable's type
1027 (in the AUX table) says if the type is struct, union, or
1028 enum, and points back to the stBlock here. So you can
1029 patch the tag kind up later - but only if there actually is
1030 a variable or field of that type.
1032 So until we know for sure, we will guess at this point.
1034 If the first member has index==indexNil or a void type,
1035 assume we have an enumeration.
1036 Otherwise, if there is more than one member, and all
1037 the members have offset 0, assume we have a union.
1038 Otherwise, assume we have a struct.
1040 The heuristic could guess wrong in the case of of an
1041 enumeration with no members or a union with one (or zero)
1042 members, or when all except the last field of a struct have
1043 width zero. These are uncommon and/or illegal situations,
1044 and in any case guessing wrong probably doesn't matter
1047 But if we later do find out we were wrong, we fixup the tag
1048 kind. Members of an enumeration must be handled
1049 differently from struct/union fields, and that is harder to
1050 patch up, but luckily we shouldn't need to. (If there are
1051 any enumeration members, we can tell for sure it's an enum
1054 if (type_code == TYPE_CODE_UNDEF)
1056 if (nfields > 1 && max_value == 0)
1057 type_code = TYPE_CODE_UNION;
1059 type_code = TYPE_CODE_STRUCT;
1062 /* Create a new type or use the pending type. */
1063 pend = is_pending_symbol (cur_fdr, ext_sh);
1064 if (pend == (struct mdebug_pending *) NULL)
1066 t = new_type (NULL);
1067 add_pending (cur_fdr, ext_sh, t);
1072 /* Do not set the tag name if it is a compiler generated tag name
1073 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1074 Alpha cc puts out an sh->iss of zero for those. */
1075 if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
1076 TYPE_TAG_NAME (t) = NULL;
1078 TYPE_TAG_NAME (t) = obconcat (¤t_objfile->symbol_obstack,
1081 TYPE_CODE (t) = type_code;
1082 TYPE_LENGTH (t) = sh->value;
1083 TYPE_NFIELDS (t) = nfields;
1084 TYPE_FIELDS (t) = f = ((struct field *)
1086 nfields * sizeof (struct field)));
1088 if (type_code == TYPE_CODE_ENUM)
1090 int unsigned_enum = 1;
1092 /* This is a non-empty enum. */
1094 /* DEC c89 has the number of enumerators in the sh.value field,
1095 not the type length, so we have to compensate for that
1096 incompatibility quirk.
1097 This might do the wrong thing for an enum with one or two
1098 enumerators and gcc -gcoff -fshort-enums, but these cases
1099 are hopefully rare enough.
1100 Alpha cc -migrate has a sh.value field of zero, we adjust
1102 if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
1103 || TYPE_LENGTH (t) == 0)
1104 TYPE_LENGTH (t) = TARGET_INT_BIT / HOST_CHAR_BIT;
1105 for (ext_tsym = ext_sh + external_sym_size;
1107 ext_tsym += external_sym_size)
1110 struct symbol *enum_sym;
1112 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
1114 if (tsym.st != stMember)
1117 FIELD_BITPOS (*f) = tsym.value;
1118 FIELD_TYPE (*f) = t;
1119 FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
1120 FIELD_BITSIZE (*f) = 0;
1122 enum_sym = ((struct symbol *)
1123 obstack_alloc (¤t_objfile->symbol_obstack,
1124 sizeof (struct symbol)));
1125 memset ((PTR) enum_sym, 0, sizeof (struct symbol));
1126 SYMBOL_NAME (enum_sym) =
1127 obsavestring (f->name, strlen (f->name),
1128 ¤t_objfile->symbol_obstack);
1129 SYMBOL_CLASS (enum_sym) = LOC_CONST;
1130 SYMBOL_TYPE (enum_sym) = t;
1131 SYMBOL_NAMESPACE (enum_sym) = VAR_NAMESPACE;
1132 SYMBOL_VALUE (enum_sym) = tsym.value;
1133 if (SYMBOL_VALUE (enum_sym) < 0)
1135 add_symbol (enum_sym, top_stack->cur_block);
1137 /* Skip the stMembers that we've handled. */
1142 TYPE_FLAGS (t) |= TYPE_FLAG_UNSIGNED;
1144 /* make this the current type */
1145 top_stack->cur_type = t;
1146 top_stack->cur_field = 0;
1148 /* Do not create a symbol for alpha cc unnamed structs. */
1152 /* gcc puts out an empty struct for an opaque struct definitions,
1153 do not create a symbol for it either. */
1154 if (TYPE_NFIELDS (t) == 0)
1156 TYPE_FLAGS (t) |= TYPE_FLAG_STUB;
1160 s = new_symbol (name);
1161 SYMBOL_NAMESPACE (s) = STRUCT_NAMESPACE;
1162 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1163 SYMBOL_VALUE (s) = 0;
1164 SYMBOL_TYPE (s) = t;
1165 add_symbol (s, top_stack->cur_block);
1168 /* End of local variables shared by struct, union, enum, and
1169 block (as yet unknown struct/union/enum) processing. */
1173 found_ecoff_debugging_info = 1;
1174 /* beginnning of (code) block. Value of symbol
1175 is the displacement from procedure start */
1176 push_parse_stack ();
1178 /* Do not start a new block if this is the outermost block of a
1179 procedure. This allows the LOC_BLOCK symbol to point to the
1180 block with the local variables, so funcname::var works. */
1181 if (top_stack->blocktype == stProc
1182 || top_stack->blocktype == stStaticProc)
1184 top_stack->blocktype = stNil;
1188 top_stack->blocktype = stBlock;
1189 b = new_block (top_stack->maxsyms);
1190 BLOCK_START (b) = sh->value + top_stack->procadr;
1191 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1192 top_stack->cur_block = b;
1193 add_block (b, top_stack->cur_st);
1196 case stEnd: /* end (of anything) */
1197 if (sh->sc == scInfo || SC_IS_COMMON (sh->sc))
1199 /* Finished with type */
1200 top_stack->cur_type = 0;
1202 else if (sh->sc == scText &&
1203 (top_stack->blocktype == stProc ||
1204 top_stack->blocktype == stStaticProc))
1206 /* Finished with procedure */
1207 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
1208 struct mips_extra_func_info *e;
1210 struct type *ftype = top_stack->cur_type;
1213 BLOCK_END (top_stack->cur_block) += sh->value; /* size */
1215 /* Make up special symbol to contain procedure specific info */
1216 s = new_symbol (MIPS_EFI_SYMBOL_NAME);
1217 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
1218 SYMBOL_CLASS (s) = LOC_CONST;
1219 SYMBOL_TYPE (s) = mdebug_type_void;
1220 e = ((struct mips_extra_func_info *)
1221 obstack_alloc (¤t_objfile->symbol_obstack,
1222 sizeof (struct mips_extra_func_info)));
1223 memset ((PTR) e, 0, sizeof (struct mips_extra_func_info));
1224 SYMBOL_VALUE (s) = (long) e;
1225 e->numargs = top_stack->numargs;
1226 e->pdr.framereg = -1;
1227 add_symbol (s, top_stack->cur_block);
1229 /* Reallocate symbols, saving memory */
1230 b = shrink_block (top_stack->cur_block, top_stack->cur_st);
1232 /* f77 emits proc-level with address bounds==[0,0],
1233 So look for such child blocks, and patch them. */
1234 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
1236 struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
1237 if (BLOCK_SUPERBLOCK (b_bad) == b
1238 && BLOCK_START (b_bad) == top_stack->procadr
1239 && BLOCK_END (b_bad) == top_stack->procadr)
1241 BLOCK_START (b_bad) = BLOCK_START (b);
1242 BLOCK_END (b_bad) = BLOCK_END (b);
1246 if (TYPE_NFIELDS (ftype) <= 0)
1248 /* No parameter type information is recorded with the function's
1249 type. Set that from the type of the parameter symbols. */
1250 int nparams = top_stack->numargs;
1256 TYPE_NFIELDS (ftype) = nparams;
1257 TYPE_FIELDS (ftype) = (struct field *)
1258 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
1260 for (i = iparams = 0; iparams < nparams; i++)
1262 sym = BLOCK_SYM (b, i);
1263 switch (SYMBOL_CLASS (sym))
1268 case LOC_REGPARM_ADDR:
1269 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
1279 else if (sh->sc == scText && top_stack->blocktype == stBlock)
1281 /* End of (code) block. The value of the symbol is the
1282 displacement from the procedure`s start address of the
1283 end of this block. */
1284 BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
1285 shrink_block (top_stack->cur_block, top_stack->cur_st);
1287 else if (sh->sc == scText && top_stack->blocktype == stNil)
1289 /* End of outermost block. Pop parse stack and ignore. The
1290 following stEnd of stProc will take care of the block. */
1293 else if (sh->sc == scText && top_stack->blocktype == stFile)
1295 /* End of file. Pop parse stack and ignore. Higher
1296 level code deals with this. */
1300 complain (&stEnd_complaint, sh->sc);
1302 pop_parse_stack (); /* restore previous lexical context */
1305 case stMember: /* member of struct or union */
1306 f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
1307 FIELD_NAME (*f) = name;
1308 FIELD_BITPOS (*f) = sh->value;
1310 FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name);
1311 FIELD_BITSIZE (*f) = bitsize;
1314 case stIndirect: /* forward declaration on Irix5 */
1315 /* Forward declarations from Irix5 cc are handled by cross_ref,
1319 case stTypedef: /* type definition */
1320 found_ecoff_debugging_info = 1;
1322 /* Typedefs for forward declarations and opaque structs from alpha cc
1323 are handled by cross_ref, skip them. */
1327 /* Parse the type or use the pending type. */
1328 pend = is_pending_symbol (cur_fdr, ext_sh);
1329 if (pend == (struct mdebug_pending *) NULL)
1331 t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name);
1332 add_pending (cur_fdr, ext_sh, t);
1337 /* mips cc puts out a typedef with the name of the struct for forward
1338 declarations. These should not go into the symbol table and
1339 TYPE_NAME should not be set for them.
1340 They can't be distinguished from an intentional typedef to
1341 the same name however:
1343 struct x { int ix; int jx; };
1347 struct xx {int ixx; int jxx; };
1348 generates a cross referencing stTypedef for x and xx.
1349 The user visible effect of this is that the type of a pointer
1350 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1351 The problem is fixed with alpha cc and Irix5 cc. */
1353 /* However if the typedef cross references to an opaque aggregate, it
1354 is safe to omit it from the symbol table. */
1356 if (has_opaque_xref (cur_fdr, sh))
1358 s = new_symbol (name);
1359 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
1360 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1361 SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
1362 SYMBOL_TYPE (s) = t;
1363 add_symbol (s, top_stack->cur_block);
1365 /* Incomplete definitions of structs should not get a name. */
1366 if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
1367 && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0
1368 || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT
1369 && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION)))
1371 if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR
1372 || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC)
1374 /* If we are giving a name to a type such as "pointer to
1375 foo" or "function returning foo", we better not set
1376 the TYPE_NAME. If the program contains "typedef char
1377 *caddr_t;", we don't want all variables of type char
1378 * to print as caddr_t. This is not just a
1379 consequence of GDB's type management; CC and GCC (at
1380 least through version 2.4) both output variables of
1381 either type char * or caddr_t with the type
1382 refering to the stTypedef symbol for caddr_t. If a future
1383 compiler cleans this up it GDB is not ready for it
1384 yet, but if it becomes ready we somehow need to
1385 disable this check (without breaking the PCC/GCC2.4
1390 Fortunately, this check seems not to be necessary
1391 for anything except pointers or functions. */
1394 TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_NAME (s);
1398 case stFile: /* file name */
1399 push_parse_stack ();
1400 top_stack->blocktype = sh->st;
1403 /* I`ve never seen these for C */
1405 break; /* register relocation */
1407 break; /* forwarding address */
1409 break; /* constant */
1411 complain (&unknown_mdebug_symtype_complaint, sh->st);
1418 /* Parse the type information provided in the raw AX entries for
1419 the symbol SH. Return the bitfield size in BS, in case.
1420 We must byte-swap the AX entries before we use them; BIGEND says whether
1421 they are big-endian or little-endian (from fh->fBigendian). */
1423 static struct type *
1424 parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
1425 int bigend, char *sym_name)
1427 /* Null entries in this map are treated specially */
1428 static struct type **map_bt[] =
1430 &mdebug_type_void, /* btNil */
1431 &mdebug_type_adr_32, /* btAdr */
1432 &mdebug_type_char, /* btChar */
1433 &mdebug_type_unsigned_char, /* btUChar */
1434 &mdebug_type_short, /* btShort */
1435 &mdebug_type_unsigned_short, /* btUShort */
1436 &mdebug_type_int_32, /* btInt */
1437 &mdebug_type_unsigned_int_32, /* btUInt */
1438 &mdebug_type_long_32, /* btLong */
1439 &mdebug_type_unsigned_long_32, /* btULong */
1440 &mdebug_type_float, /* btFloat */
1441 &mdebug_type_double, /* btDouble */
1448 &mdebug_type_complex, /* btComplex */
1449 &mdebug_type_double_complex, /* btDComplex */
1451 &mdebug_type_fixed_dec, /* btFixedDec */
1452 &mdebug_type_float_dec, /* btFloatDec */
1453 &mdebug_type_string, /* btString */
1456 &mdebug_type_void, /* btVoid */
1457 0, /* DEC C++: Pointer to member */
1458 0, /* DEC C++: Virtual function table */
1459 0, /* DEC C++: Class (Record) */
1460 &mdebug_type_long_64, /* btLong64 */
1461 &mdebug_type_unsigned_long_64, /* btULong64 */
1462 &mdebug_type_long_long_64, /* btLongLong64 */
1463 &mdebug_type_unsigned_long_long_64, /* btULongLong64 */
1464 &mdebug_type_adr_64, /* btAdr64 */
1465 &mdebug_type_int_64, /* btInt64 */
1466 &mdebug_type_unsigned_int_64, /* btUInt64 */
1470 struct type *tp = 0;
1471 enum type_code type_code = TYPE_CODE_UNDEF;
1473 /* Handle undefined types, they have indexNil. */
1474 if (aux_index == indexNil)
1475 return mdebug_type_int;
1477 /* Handle corrupt aux indices. */
1478 if (aux_index >= (debug_info->fdr + fd)->caux)
1480 complain (&index_complaint, sym_name);
1481 return mdebug_type_int;
1485 /* Use aux as a type information record, map its basic type. */
1486 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1487 if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt)))
1489 complain (&basic_type_complaint, t->bt, sym_name);
1490 return mdebug_type_int;
1494 tp = *map_bt[t->bt];
1499 /* Cannot use builtin types -- build our own */
1503 type_code = TYPE_CODE_STRUCT;
1506 type_code = TYPE_CODE_UNION;
1509 type_code = TYPE_CODE_ENUM;
1512 type_code = TYPE_CODE_RANGE;
1515 type_code = TYPE_CODE_SET;
1518 /* alpha cc -migrate uses this for typedefs. The true type will
1519 be obtained by crossreferencing below. */
1520 type_code = TYPE_CODE_ERROR;
1523 /* alpha cc uses this for typedefs. The true type will be
1524 obtained by crossreferencing below. */
1525 type_code = TYPE_CODE_ERROR;
1528 complain (&basic_type_complaint, t->bt, sym_name);
1529 return mdebug_type_int;
1533 /* Move on to next aux */
1538 int width = AUX_GET_WIDTH (bigend, ax);
1540 /* Inhibit core dumps with some cfront generated objects that
1542 if (bs == (int *) NULL)
1544 /* Alpha cc -migrate encodes char and unsigned char types
1545 as short and unsigned short types with a field width of 8.
1546 Enum types also have a field width which we ignore for now. */
1547 if (t->bt == btShort && width == 8)
1548 tp = mdebug_type_char;
1549 else if (t->bt == btUShort && width == 8)
1550 tp = mdebug_type_unsigned_char;
1551 else if (t->bt == btEnum)
1554 complain (&bad_fbitfield_complaint, sym_name);
1561 /* A btIndirect entry cross references to an aux entry containing
1563 if (t->bt == btIndirect)
1570 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
1572 if (rn->rfd == 0xfff)
1574 rf = AUX_GET_ISYM (bigend, ax);
1582 complain (&bad_indirect_xref_complaint, sym_name);
1583 return mdebug_type_int;
1585 xref_fh = get_rfd (fd, rf);
1586 xref_fd = xref_fh - debug_info->fdr;
1587 tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase,
1588 rn->index, (int *) NULL, xref_fh->fBigendian, sym_name);
1591 /* All these types really point to some (common) MIPS type
1592 definition, and only the type-qualifiers fully identify
1593 them. We'll make the same effort at sharing. */
1594 if (t->bt == btStruct ||
1598 /* btSet (I think) implies that the name is a tag name, not a typedef
1599 name. This apparently is a MIPS extension for C sets. */
1604 /* Try to cross reference this type, build new type on failure. */
1605 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1606 if (tp == (struct type *) NULL)
1607 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1609 /* DEC c89 produces cross references to qualified aggregate types,
1610 dereference them. */
1611 while (TYPE_CODE (tp) == TYPE_CODE_PTR
1612 || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
1613 tp = tp->target_type;
1615 /* Make sure that TYPE_CODE(tp) has an expected type code.
1616 Any type may be returned from cross_ref if file indirect entries
1618 if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
1619 && TYPE_CODE (tp) != TYPE_CODE_UNION
1620 && TYPE_CODE (tp) != TYPE_CODE_ENUM)
1622 complain (&unexpected_type_code_complaint, sym_name);
1627 /* Usually, TYPE_CODE(tp) is already type_code. The main
1628 exception is if we guessed wrong re struct/union/enum.
1629 But for struct vs. union a wrong guess is harmless, so
1630 don't complain(). */
1631 if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
1632 && type_code != TYPE_CODE_ENUM)
1633 || (TYPE_CODE (tp) != TYPE_CODE_ENUM
1634 && type_code == TYPE_CODE_ENUM))
1636 complain (&bad_tag_guess_complaint, sym_name);
1639 if (TYPE_CODE (tp) != type_code)
1641 TYPE_CODE (tp) = type_code;
1644 /* Do not set the tag name if it is a compiler generated tag name
1645 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1646 if (name[0] == '.' || name[0] == '\0')
1647 TYPE_TAG_NAME (tp) = NULL;
1648 else if (TYPE_TAG_NAME (tp) == NULL
1649 || !STREQ (TYPE_TAG_NAME (tp), name))
1650 TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name),
1651 ¤t_objfile->type_obstack);
1655 /* All these types really point to some (common) MIPS type
1656 definition, and only the type-qualifiers fully identify
1657 them. We'll make the same effort at sharing.
1658 FIXME: We are not doing any guessing on range types. */
1659 if (t->bt == btRange)
1663 /* Try to cross reference this type, build new type on failure. */
1664 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1665 if (tp == (struct type *) NULL)
1666 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1668 /* Make sure that TYPE_CODE(tp) has an expected type code.
1669 Any type may be returned from cross_ref if file indirect entries
1671 if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
1673 complain (&unexpected_type_code_complaint, sym_name);
1677 /* Usually, TYPE_CODE(tp) is already type_code. The main
1678 exception is if we guessed wrong re struct/union/enum. */
1679 if (TYPE_CODE (tp) != type_code)
1681 complain (&bad_tag_guess_complaint, sym_name);
1682 TYPE_CODE (tp) = type_code;
1684 if (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name))
1685 TYPE_NAME (tp) = obsavestring (name, strlen (name),
1686 ¤t_objfile->type_obstack);
1689 if (t->bt == btTypedef)
1693 /* Try to cross reference this type, it should succeed. */
1694 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1695 if (tp == (struct type *) NULL)
1697 complain (&unable_to_cross_ref_complaint, sym_name);
1698 tp = mdebug_type_int;
1702 /* Deal with range types */
1703 if (t->bt == btRange)
1705 TYPE_NFIELDS (tp) = 2;
1706 TYPE_FIELDS (tp) = ((struct field *)
1707 TYPE_ALLOC (tp, 2 * sizeof (struct field)));
1708 TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
1709 ¤t_objfile->type_obstack);
1710 TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
1712 TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
1713 ¤t_objfile->type_obstack);
1714 TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
1718 /* Parse all the type qualifiers now. If there are more
1719 than 6 the game will continue in the next aux */
1723 #define PARSE_TQ(tq) \
1724 if (t->tq != tqNil) \
1725 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1737 /* mips cc 2.x and gcc never put out continued aux entries. */
1741 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1745 /* Complain for illegal continuations due to corrupt aux entries. */
1747 complain (&bad_continued_complaint, sym_name);
1752 /* Make up a complex type from a basic one. Type is passed by
1753 reference in TPP and side-effected as necessary. The type
1754 qualifier TQ says how to handle the aux symbols at AX for
1755 the symbol SX we are currently analyzing. BIGEND says whether
1756 aux symbols are big-endian or little-endian.
1757 Returns the number of aux symbols we parsed. */
1760 upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
1766 /* Used in array processing */
1777 t = lookup_pointer_type (*tpp);
1782 t = lookup_function_type (*tpp);
1789 /* Determine and record the domain type (type of index) */
1790 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx);
1796 rf = AUX_GET_ISYM (bigend, ax);
1799 fh = get_rfd (fd, rf);
1801 indx = parse_type (fh - debug_info->fdr,
1802 debug_info->external_aux + fh->iauxBase,
1803 id, (int *) NULL, bigend, sym_name);
1805 /* The bounds type should be an integer type, but might be anything
1806 else due to corrupt aux entries. */
1807 if (TYPE_CODE (indx) != TYPE_CODE_INT)
1809 complain (&array_index_type_complaint, sym_name);
1810 indx = mdebug_type_int;
1813 /* Get the bounds, and create the array type. */
1815 lower = AUX_GET_DNLOW (bigend, ax);
1817 upper = AUX_GET_DNHIGH (bigend, ax);
1819 rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */
1821 range = create_range_type ((struct type *) NULL, indx,
1824 t = create_array_type ((struct type *) NULL, *tpp, range);
1826 /* We used to fill in the supplied array element bitsize
1827 here if the TYPE_LENGTH of the target type was zero.
1828 This happens for a `pointer to an array of anonymous structs',
1829 but in this case the array element bitsize is also zero,
1830 so nothing is gained.
1831 And we used to check the TYPE_LENGTH of the target type against
1832 the supplied array element bitsize.
1833 gcc causes a mismatch for `pointer to array of object',
1834 since the sdb directives it uses do not have a way of
1835 specifying the bitsize, but it does no harm (the
1836 TYPE_LENGTH should be correct) and we should be able to
1837 ignore the erroneous bitsize from the auxiliary entry safely.
1838 dbx seems to ignore it too. */
1840 /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
1842 if (TYPE_LENGTH (*tpp) == 0)
1844 TYPE_FLAGS (t) |= TYPE_FLAG_TARGET_STUB;
1851 /* Volatile -- currently ignored */
1855 /* Const -- currently ignored */
1859 complain (&unknown_type_qual_complaint, tq);
1865 /* Parse a procedure descriptor record PR. Note that the procedure is
1866 parsed _after_ the local symbols, now we just insert the extra
1867 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1868 already been placed in the procedure's main block. Note also that
1869 images that have been partially stripped (ld -x) have been deprived
1870 of local symbols, and we have to cope with them here. FIRST_OFF is
1871 the offset of the first procedure for this FDR; we adjust the
1872 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1873 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1874 in question, or NULL to use top_stack->cur_block. */
1876 static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *);
1879 parse_procedure (PDR *pr, struct symtab *search_symtab,
1880 struct partial_symtab *pst)
1882 struct symbol *s, *i;
1884 struct mips_extra_func_info *e;
1887 /* Simple rule to find files linked "-x" */
1888 if (cur_fdr->rss == -1)
1892 /* Static procedure at address pr->adr. Sigh. */
1893 /* FIXME-32x64. assuming pr->adr fits in long. */
1894 complain (&pdr_static_symbol_complaint, (unsigned long) pr->adr);
1902 (*debug_swap->swap_ext_in) (cur_bfd,
1903 ((char *) debug_info->external_ext
1905 * debug_swap->external_ext_size)),
1907 sh_name = debug_info->ssext + she.asym.iss;
1915 (*debug_swap->swap_sym_in) (cur_bfd,
1916 ((char *) debug_info->external_sym
1917 + ((cur_fdr->isymBase + pr->isym)
1918 * debug_swap->external_sym_size)),
1920 sh_name = debug_info->ss + cur_fdr->issBase + sh.iss;
1923 if (search_symtab != NULL)
1926 /* This loses both in the case mentioned (want a static, find a global),
1927 but also if we are looking up a non-mangled name which happens to
1928 match the name of a mangled function. */
1929 /* We have to save the cur_fdr across the call to lookup_symbol.
1930 If the pdr is for a static function and if a global function with
1931 the same name exists, lookup_symbol will eventually read in the symtab
1932 for the global function and clobber cur_fdr. */
1933 FDR *save_cur_fdr = cur_fdr;
1934 s = lookup_symbol (sh_name, NULL, VAR_NAMESPACE, 0, NULL);
1935 cur_fdr = save_cur_fdr;
1939 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
1945 s = mylookup_symbol (sh_name, top_stack->cur_block,
1946 VAR_NAMESPACE, LOC_BLOCK);
1950 b = SYMBOL_BLOCK_VALUE (s);
1954 complain (&pdr_for_nonsymbol_complaint, sh_name);
1958 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1959 s = new_symbol (sh_name);
1960 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
1961 SYMBOL_CLASS (s) = LOC_BLOCK;
1962 /* Donno its type, hope int is ok */
1963 SYMBOL_TYPE (s) = lookup_function_type (mdebug_type_int);
1964 add_symbol (s, top_stack->cur_block);
1965 /* Wont have symbols for this one */
1967 SYMBOL_BLOCK_VALUE (s) = b;
1968 BLOCK_FUNCTION (b) = s;
1969 BLOCK_START (b) = pr->adr;
1970 /* BOUND used to be the end of procedure's text, but the
1971 argument is no longer passed in. */
1972 BLOCK_END (b) = bound;
1973 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1974 add_block (b, top_stack->cur_st);
1978 i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, LOC_CONST);
1982 e = (struct mips_extra_func_info *) SYMBOL_VALUE (i);
1984 e->pdr.isym = (long) s;
1986 /* GDB expects the absolute function start address for the
1987 procedure descriptor in e->pdr.adr.
1988 As the address in the procedure descriptor is usually relative,
1989 we would have to relocate e->pdr.adr with cur_fdr->adr and
1990 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
1991 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
1992 in shared libraries on some systems, and on other systems
1993 e->pdr.adr is sometimes offset by a bogus value.
1994 To work around these problems, we replace e->pdr.adr with
1995 the start address of the function. */
1996 e->pdr.adr = BLOCK_START (b);
1998 /* Correct incorrect setjmp procedure descriptor from the library
1999 to make backtrace through setjmp work. */
2000 if (e->pdr.pcreg == 0 && STREQ (sh_name, "setjmp"))
2002 complain (&bad_setjmp_pdr_complaint, 0);
2003 e->pdr.pcreg = RA_REGNUM;
2004 e->pdr.regmask = 0x80000000;
2005 e->pdr.regoffset = -4;
2009 /* It would be reasonable that functions that have been compiled
2010 without debugging info have a btNil type for their return value,
2011 and functions that are void and are compiled with debugging info
2013 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2014 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2016 The glevel field in cur_fdr could be used to determine the presence
2017 of debugging info, but GCC doesn't always pass the -g switch settings
2018 to the assembler and GAS doesn't set the glevel field from the -g switch
2020 To work around these problems, the return value type of a TYPE_CODE_VOID
2021 function is adjusted accordingly if no debugging info was found in the
2022 compilation unit. */
2024 if (processing_gcc_compilation == 0
2025 && found_ecoff_debugging_info == 0
2026 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
2027 SYMBOL_TYPE (s) = nodebug_func_symbol_type;
2030 /* Relocate the extra function info pointed to by the symbol table. */
2033 ecoff_relocate_efi (struct symbol *sym, CORE_ADDR delta)
2035 struct mips_extra_func_info *e;
2037 e = (struct mips_extra_func_info *) SYMBOL_VALUE (sym);
2039 e->pdr.adr += delta;
2042 /* Parse the external symbol ES. Just call parse_symbol() after
2043 making sure we know where the aux are for it.
2044 BIGEND says whether aux entries are big-endian or little-endian.
2046 This routine clobbers top_stack->cur_block and ->cur_st. */
2048 static void parse_external (EXTR *, int, struct section_offsets *,
2052 parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
2053 struct objfile *objfile)
2057 if (es->ifd != ifdNil)
2060 cur_fdr = debug_info->fdr + cur_fd;
2061 ax = debug_info->external_aux + cur_fdr->iauxBase;
2065 cur_fdr = debug_info->fdr;
2069 /* Reading .o files */
2070 if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil)
2073 switch (es->asym.st)
2076 /* These are generated for static symbols in .o files,
2097 /* FIXME: Turn this into a complaint? */
2099 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
2100 what, debug_info->ssext + es->asym.iss,
2101 fdr_name (cur_fdr));
2105 switch (es->asym.st)
2109 /* There is no need to parse the external procedure symbols.
2110 If they are from objects compiled without -g, their index will
2111 be indexNil, and the symbol definition from the minimal symbol
2112 is preferrable (yielding a function returning int instead of int).
2113 If the index points to a local procedure symbol, the local
2114 symbol already provides the correct type.
2115 Note that the index of the external procedure symbol points
2116 to the local procedure symbol in the local symbol table, and
2117 _not_ to the auxiliary symbol info. */
2121 /* Global common symbols are resolved by the runtime loader,
2123 if (SC_IS_COMMON (es->asym.sc))
2126 /* Note that the case of a symbol with indexNil must be handled
2127 anyways by parse_symbol(). */
2128 parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets, objfile);
2135 /* Parse the line number info for file descriptor FH into
2136 GDB's linetable LT. MIPS' encoding requires a little bit
2137 of magic to get things out. Note also that MIPS' line
2138 numbers can go back and forth, apparently we can live
2139 with that and do not need to reorder our linetables */
2141 static void parse_lines (FDR *, PDR *, struct linetable *, int,
2142 struct partial_symtab *, CORE_ADDR);
2145 parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
2146 struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr)
2148 unsigned char *base;
2150 int delta, count, lineno = 0;
2152 if (fh->cbLine == 0)
2155 /* Scan by procedure descriptors */
2157 for (j = 0; j < fh->cpd; j++, pr++)
2161 unsigned char *halt;
2163 /* No code for this one */
2164 if (pr->iline == ilineNil ||
2165 pr->lnLow == -1 || pr->lnHigh == -1)
2168 /* Determine start and end address of compressed line bytes for
2170 base = debug_info->line + fh->cbLineOffset;
2171 if (j != (fh->cpd - 1))
2172 halt = base + pr[1].cbLineOffset;
2174 halt = base + fh->cbLine;
2175 base += pr->cbLineOffset;
2177 adr = pst->textlow + pr->adr - lowest_pdr_addr;
2179 l = adr >> 2; /* in words */
2180 for (lineno = pr->lnLow; base < halt;)
2182 count = *base & 0x0f;
2183 delta = *base++ >> 4;
2188 delta = (base[0] << 8) | base[1];
2189 if (delta >= 0x8000)
2193 lineno += delta; /* first delta is 0 */
2195 /* Complain if the line table overflows. Could happen
2196 with corrupt binaries. */
2197 if (lt->nitems >= maxlines)
2199 complain (&bad_linetable_guess_complaint, fdr_name (fh));
2202 k = add_line (lt, lineno, l, k);
2208 /* Master parsing procedure for first-pass reading of file symbols
2209 into a partial_symtab. */
2212 parse_partial_symbols (struct objfile *objfile)
2214 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
2215 const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
2216 const bfd_size_type external_ext_size = debug_swap->external_ext_size;
2217 void (*const swap_ext_in) (bfd *, PTR, EXTR *) = debug_swap->swap_ext_in;
2218 void (*const swap_sym_in) (bfd *, PTR, SYMR *) = debug_swap->swap_sym_in;
2219 void (*const swap_rfd_in) (bfd *, PTR, RFDT *) = debug_swap->swap_rfd_in;
2221 HDRR *hdr = &debug_info->symbolic_header;
2222 /* Running pointers */
2227 register EXTR *ext_in;
2230 struct partial_symtab *pst;
2231 int textlow_not_set = 1;
2232 int past_first_source_file = 0;
2234 /* List of current psymtab's include files */
2235 char **psymtab_include_list;
2236 int includes_allocated;
2239 struct pst_map *fdr_to_pst;
2240 /* Index within current psymtab dependency list */
2241 struct partial_symtab **dependency_list;
2242 int dependencies_used, dependencies_allocated;
2243 struct cleanup *old_chain;
2245 enum language prev_language;
2246 asection *text_sect;
2247 int relocatable = 0;
2249 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2250 the shared libraries are prelinked at a high memory address.
2251 We have to adjust the start address of the object file for this case,
2252 by setting it to the start address of the first procedure in the file.
2253 But we should do no adjustments if we are debugging a .o file, where
2254 the text section (and fh->adr) really starts at zero. */
2255 text_sect = bfd_get_section_by_name (cur_bfd, ".text");
2256 if (text_sect != NULL
2257 && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
2260 extern_tab = (EXTR *) obstack_alloc (&objfile->psymbol_obstack,
2261 sizeof (EXTR) * hdr->iextMax);
2263 includes_allocated = 30;
2265 psymtab_include_list = (char **) alloca (includes_allocated *
2267 next_symbol_text_func = mdebug_next_symbol_text;
2269 dependencies_allocated = 30;
2270 dependencies_used = 0;
2272 (struct partial_symtab **) alloca (dependencies_allocated *
2273 sizeof (struct partial_symtab *));
2275 last_source_file = NULL;
2280 * Only parse the Local and External symbols, and the Relative FDR.
2281 * Fixup enough of the loader symtab to be able to use it.
2282 * Allocate space only for the file's portions we need to
2287 max_glevel = MIN_GLEVEL;
2289 /* Allocate the map FDR -> PST.
2290 Minor hack: -O3 images might claim some global data belongs
2291 to FDR -1. We`ll go along with that */
2292 fdr_to_pst = (struct pst_map *) xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
2293 old_chain = make_cleanup (xfree, fdr_to_pst);
2296 struct partial_symtab *pst = new_psymtab ("", objfile);
2297 fdr_to_pst[-1].pst = pst;
2301 /* Allocate the global pending list. */
2303 ((struct mdebug_pending **)
2304 obstack_alloc (&objfile->psymbol_obstack,
2305 hdr->ifdMax * sizeof (struct mdebug_pending *)));
2306 memset ((PTR) pending_list, 0,
2307 hdr->ifdMax * sizeof (struct mdebug_pending *));
2309 /* Pass 0 over external syms: swap them in. */
2310 ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
2311 make_cleanup (xfree, ext_block);
2313 ext_out = (char *) debug_info->external_ext;
2314 ext_out_end = ext_out + hdr->iextMax * external_ext_size;
2316 for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
2317 (*swap_ext_in) (cur_bfd, ext_out, ext_in);
2319 /* Pass 1 over external syms: Presize and partition the list */
2321 ext_in_end = ext_in + hdr->iextMax;
2322 for (; ext_in < ext_in_end; ext_in++)
2324 /* See calls to complain below. */
2325 if (ext_in->ifd >= -1
2326 && ext_in->ifd < hdr->ifdMax
2327 && ext_in->asym.iss >= 0
2328 && ext_in->asym.iss < hdr->issExtMax)
2329 fdr_to_pst[ext_in->ifd].n_globals++;
2332 /* Pass 1.5 over files: partition out global symbol space */
2334 for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++)
2336 fdr_to_pst[f_idx].globals_offset = s_idx;
2337 s_idx += fdr_to_pst[f_idx].n_globals;
2338 fdr_to_pst[f_idx].n_globals = 0;
2343 For ECOFF in ELF, we skip the creation of the minimal symbols.
2344 The ECOFF symbols should be a subset of the Elf symbols, and the
2345 section information of the elf symbols will be more accurate.
2346 FIXME! What about Irix 5's native linker?
2348 By default, Elf sections which don't exist in ECOFF
2349 get put in ECOFF's absolute section by the gnu linker.
2350 Since absolute sections don't get relocated, we
2351 end up calculating an address different from that of
2352 the symbol's minimal symbol (created earlier from the
2355 To fix this, either :
2356 1) don't create the duplicate symbol
2357 (assumes ECOFF symtab is a subset of the ELF symtab;
2358 assumes no side-effects result from ignoring ECOFF symbol)
2359 2) create it, only if lookup for existing symbol in ELF's minimal
2362 assumes no side-effects result from ignoring ECOFF symbol)
2363 3) create it, but lookup ELF's minimal symbol and use it's section
2364 during relocation, then modify "uniqify" phase to merge and
2365 eliminate the duplicate symbol
2366 (highly inefficient)
2368 I've implemented #1 here...
2369 Skip the creation of the minimal symbols based on the ECOFF
2372 /* Pass 2 over external syms: fill in external symbols */
2374 ext_in_end = ext_in + hdr->iextMax;
2375 for (; ext_in < ext_in_end; ext_in++)
2377 enum minimal_symbol_type ms_type = mst_text;
2378 CORE_ADDR svalue = ext_in->asym.value;
2380 /* The Irix 5 native tools seem to sometimes generate bogus
2381 external symbols. */
2382 if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
2384 complain (&bad_ext_ifd_complaint, ext_in->ifd, hdr->ifdMax);
2387 if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
2389 complain (&bad_ext_iss_complaint, ext_in->asym.iss,
2394 extern_tab[fdr_to_pst[ext_in->ifd].globals_offset
2395 + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in;
2398 if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil)
2402 /* Pass 3 over files, over local syms: fill in static symbols */
2403 name = debug_info->ssext + ext_in->asym.iss;
2405 /* Process ECOFF Symbol Types and Storage Classes */
2406 switch (ext_in->asym.st)
2409 /* Beginnning of Procedure */
2410 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2413 /* Load time only static procs */
2414 ms_type = mst_file_text;
2415 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2418 /* External symbol */
2419 if (SC_IS_COMMON (ext_in->asym.sc))
2421 /* The value of a common symbol is its size, not its address.
2425 else if (SC_IS_DATA (ext_in->asym.sc))
2428 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2430 else if (SC_IS_BSS (ext_in->asym.sc))
2433 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2440 if (SC_IS_TEXT (ext_in->asym.sc))
2442 ms_type = mst_file_text;
2443 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2445 else if (SC_IS_DATA (ext_in->asym.sc))
2447 ms_type = mst_file_data;
2448 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2450 else if (SC_IS_BSS (ext_in->asym.sc))
2452 ms_type = mst_file_bss;
2453 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2460 /* The alpha has the section start addresses in stLocal symbols
2461 whose name starts with a `.'. Skip those but complain for all
2462 other stLocal symbols.
2463 Irix6 puts the section start addresses in stNil symbols, skip
2469 ms_type = mst_unknown;
2470 complain (&unknown_ext_complaint, name);
2472 if (!ECOFF_IN_ELF (cur_bfd))
2473 prim_record_minimal_symbol (name, svalue, ms_type, objfile);
2476 /* Pass 3 over files, over local syms: fill in static symbols */
2477 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
2479 struct partial_symtab *save_pst;
2483 cur_fdr = fh = debug_info->fdr + f_idx;
2487 fdr_to_pst[f_idx].pst = NULL;
2491 /* Determine the start address for this object file from the
2492 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2496 if (relocatable || textlow != 0)
2497 textlow += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2501 pst = start_psymtab_common (objfile, objfile->section_offsets,
2504 objfile->global_psymbols.next,
2505 objfile->static_psymbols.next);
2506 pst->read_symtab_private = ((char *)
2507 obstack_alloc (&objfile->psymbol_obstack,
2508 sizeof (struct symloc)));
2509 memset ((PTR) pst->read_symtab_private, 0, sizeof (struct symloc));
2512 FDR_IDX (pst) = f_idx;
2513 CUR_BFD (pst) = cur_bfd;
2514 DEBUG_SWAP (pst) = debug_swap;
2515 DEBUG_INFO (pst) = debug_info;
2516 PENDING_LIST (pst) = pending_list;
2518 /* The way to turn this into a symtab is to call... */
2519 pst->read_symtab = mdebug_psymtab_to_symtab;
2521 /* Set up language for the pst.
2522 The language from the FDR is used if it is unambigious (e.g. cfront
2523 with native cc and g++ will set the language to C).
2524 Otherwise we have to deduce the language from the filename.
2525 Native ecoff has every header file in a separate FDR, so
2526 deduce_language_from_filename will return language_unknown for
2527 a header file, which is not what we want.
2528 But the FDRs for the header files are after the FDR for the source
2529 file, so we can assign the language of the source file to the
2530 following header files. Then we save the language in the private
2531 pst data so that we can reuse it when building symtabs. */
2532 prev_language = psymtab_language;
2536 case langCplusplusV2:
2537 psymtab_language = language_cplus;
2540 psymtab_language = deduce_language_from_filename (fdr_name (fh));
2543 if (psymtab_language == language_unknown)
2544 psymtab_language = prev_language;
2545 PST_PRIVATE (pst)->pst_language = psymtab_language;
2547 pst->texthigh = pst->textlow;
2549 /* For stabs-in-ecoff files, the second symbol must be @stab.
2550 This symbol is emitted by mips-tfile to signal that the
2551 current object file uses encapsulated stabs instead of mips
2552 ecoff for local symbols. (It is the second symbol because
2553 the first symbol is the stFile used to signal the start of a
2555 processing_gcc_compilation = 0;
2558 (*swap_sym_in) (cur_bfd,
2559 ((char *) debug_info->external_sym
2560 + (fh->isymBase + 1) * external_sym_size),
2562 if (STREQ (debug_info->ss + fh->issBase + sh.iss, stabs_symbol))
2563 processing_gcc_compilation = 2;
2566 if (processing_gcc_compilation != 0)
2568 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
2573 (*swap_sym_in) (cur_bfd,
2574 (((char *) debug_info->external_sym)
2575 + (fh->isymBase + cur_sdx) * external_sym_size),
2577 type_code = ECOFF_UNMARK_STAB (sh.index);
2578 if (!ECOFF_IS_STAB (&sh))
2580 if (sh.st == stProc || sh.st == stStaticProc)
2585 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2586 if (sh.st == stStaticProc)
2588 namestring = debug_info->ss + fh->issBase + sh.iss;
2589 prim_record_minimal_symbol_and_info (namestring,
2593 SECT_OFF_TEXT (objfile),
2597 procaddr = sh.value;
2599 isym = AUX_GET_ISYM (fh->fBigendian,
2600 (debug_info->external_aux
2603 (*swap_sym_in) (cur_bfd,
2604 ((char *) debug_info->external_sym
2605 + ((fh->isymBase + isym - 1)
2606 * external_sym_size)),
2610 CORE_ADDR high = procaddr + sh.value;
2612 /* Kludge for Irix 5.2 zero fh->adr. */
2614 && (pst->textlow == 0 || procaddr < pst->textlow))
2615 pst->textlow = procaddr;
2616 if (high > pst->texthigh)
2617 pst->texthigh = high;
2620 else if (sh.st == stStatic)
2635 namestring = debug_info->ss + fh->issBase + sh.iss;
2636 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2637 prim_record_minimal_symbol_and_info (namestring,
2641 SECT_OFF_DATA (objfile),
2647 /* FIXME! Shouldn't this use cases for bss,
2648 then have the default be abs? */
2649 namestring = debug_info->ss + fh->issBase + sh.iss;
2650 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2651 prim_record_minimal_symbol_and_info (namestring,
2655 SECT_OFF_BSS (objfile),
2663 /* Handle stabs continuation */
2665 char *stabstring = debug_info->ss + fh->issBase + sh.iss;
2666 int len = strlen (stabstring);
2667 while (stabstring[len - 1] == '\\')
2670 char *stabstring1 = stabstring;
2674 /* Ignore continuation char from 1st string */
2677 /* Read next stabstring */
2679 (*swap_sym_in) (cur_bfd,
2680 (((char *) debug_info->external_sym)
2681 + (fh->isymBase + cur_sdx)
2682 * external_sym_size),
2684 stabstring2 = debug_info->ss + fh->issBase + sh2.iss;
2685 len2 = strlen (stabstring2);
2687 /* Concatinate stabstring2 with stabstring1 */
2689 && stabstring != debug_info->ss + fh->issBase + sh.iss)
2690 stabstring = xrealloc (stabstring, len + len2 + 1);
2692 stabstring = xmalloc (len + len2 + 1);
2693 strcpy (stabstring, stabstring1);
2694 strcpy (stabstring + len, stabstring2);
2698 #define SET_NAMESTRING() \
2699 namestring = stabstring
2700 #define CUR_SYMBOL_TYPE type_code
2701 #define CUR_SYMBOL_VALUE sh.value
2702 #define START_PSYMTAB(ofile,fname,low,symoff,global_syms,static_syms)\
2704 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set) (void)0
2705 #define HANDLE_RBRAC(val) \
2706 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2707 #include "partial-stab.h"
2710 && stabstring != debug_info->ss + fh->issBase + sh.iss)
2713 /* end - Handle continuation */
2718 for (cur_sdx = 0; cur_sdx < fh->csym;)
2721 enum address_class class;
2723 (*swap_sym_in) (cur_bfd,
2724 ((char *) debug_info->external_sym
2725 + ((fh->isymBase + cur_sdx)
2726 * external_sym_size)),
2729 if (ECOFF_IS_STAB (&sh))
2735 /* Non absolute static symbols go into the minimal table. */
2736 if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil
2737 || (sh.index == indexNil
2738 && (sh.st != stStatic || sh.sc == scAbs)))
2740 /* FIXME, premature? */
2745 name = debug_info->ss + fh->issBase + sh.iss;
2751 /* The value of a stEnd symbol is the displacement from the
2752 corresponding start symbol value, do not relocate it. */
2754 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2761 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2765 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2776 prim_record_minimal_symbol_and_info (name, sh.value,
2777 mst_file_text, NULL,
2778 SECT_OFF_TEXT (objfile), NULL,
2784 /* Usually there is a local and a global stProc symbol
2785 for a function. This means that the function name
2786 has already been entered into the mimimal symbol table
2787 while processing the global symbols in pass 2 above.
2788 One notable exception is the PROGRAM name from
2789 f77 compiled executables, it is only put out as
2790 local stProc symbol, and a global MAIN__ stProc symbol
2791 points to it. It doesn't matter though, as gdb is
2792 still able to find the PROGRAM name via the partial
2793 symbol table, and the MAIN__ symbol via the minimal
2795 if (sh.st == stProc)
2796 add_psymbol_to_list (name, strlen (name),
2797 VAR_NAMESPACE, LOC_BLOCK,
2798 &objfile->global_psymbols,
2799 0, sh.value, psymtab_language, objfile);
2801 add_psymbol_to_list (name, strlen (name),
2802 VAR_NAMESPACE, LOC_BLOCK,
2803 &objfile->static_psymbols,
2804 0, sh.value, psymtab_language, objfile);
2806 /* Skip over procedure to next one. */
2807 if (sh.index >= hdr->iauxMax)
2809 /* Should not happen, but does when cross-compiling
2810 with the MIPS compiler. FIXME -- pull later. */
2811 complain (&index_complaint, name);
2812 new_sdx = cur_sdx + 1; /* Don't skip at all */
2815 new_sdx = AUX_GET_ISYM (fh->fBigendian,
2816 (debug_info->external_aux
2819 procaddr = sh.value;
2821 if (new_sdx <= cur_sdx)
2823 /* This should not happen either... FIXME. */
2824 complain (&aux_index_complaint, name);
2825 new_sdx = cur_sdx + 1; /* Don't skip backward */
2829 (*swap_sym_in) (cur_bfd,
2830 ((char *) debug_info->external_sym
2831 + ((fh->isymBase + cur_sdx - 1)
2832 * external_sym_size)),
2837 /* Kludge for Irix 5.2 zero fh->adr. */
2839 && (pst->textlow == 0 || procaddr < pst->textlow))
2840 pst->textlow = procaddr;
2842 high = procaddr + sh.value;
2843 if (high > pst->texthigh)
2844 pst->texthigh = high;
2847 case stStatic: /* Variable */
2848 if (SC_IS_DATA (sh.sc))
2849 prim_record_minimal_symbol_and_info (name, sh.value,
2850 mst_file_data, NULL,
2851 SECT_OFF_DATA (objfile),
2855 prim_record_minimal_symbol_and_info (name, sh.value,
2857 SECT_OFF_BSS (objfile),
2863 case stIndirect: /* Irix5 forward declaration */
2864 /* Skip forward declarations from Irix5 cc */
2867 case stTypedef: /* Typedef */
2868 /* Skip typedefs for forward declarations and opaque
2869 structs from alpha and mips cc. */
2870 if (sh.iss == 0 || has_opaque_xref (fh, &sh))
2872 class = LOC_TYPEDEF;
2875 case stConstant: /* Constant decl */
2882 case stBlock: /* { }, str, un, enum */
2883 /* Do not create a partial symbol for cc unnamed aggregates
2884 and gcc empty aggregates. */
2885 if ((sh.sc == scInfo
2886 || SC_IS_COMMON (sh.sc))
2888 && sh.index != cur_sdx + 2)
2890 add_psymbol_to_list (name, strlen (name),
2891 STRUCT_NAMESPACE, LOC_TYPEDEF,
2892 &objfile->static_psymbols,
2894 psymtab_language, objfile);
2896 handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
2898 /* Skip over the block */
2900 if (new_sdx <= cur_sdx)
2902 /* This happens with the Ultrix kernel. */
2903 complain (&block_index_complaint, name);
2904 new_sdx = cur_sdx + 1; /* Don't skip backward */
2909 case stFile: /* File headers */
2910 case stLabel: /* Labels */
2911 case stEnd: /* Ends of files */
2914 case stLocal: /* Local variables */
2915 /* Normally these are skipped because we skip over
2916 all blocks we see. However, these can occur
2917 as visible symbols in a .h file that contains code. */
2921 /* Both complaints are valid: one gives symbol name,
2922 the other the offending symbol type. */
2923 complain (&unknown_sym_complaint, name);
2924 complain (&unknown_st_complaint, sh.st);
2928 /* Use this gdb symbol */
2929 add_psymbol_to_list (name, strlen (name),
2930 VAR_NAMESPACE, class,
2931 &objfile->static_psymbols,
2932 0, sh.value, psymtab_language, objfile);
2934 cur_sdx++; /* Go to next file symbol */
2937 /* Now do enter the external symbols. */
2938 ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset];
2939 cur_sdx = fdr_to_pst[f_idx].n_globals;
2940 PST_PRIVATE (save_pst)->extern_count = cur_sdx;
2941 PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
2942 for (; --cur_sdx >= 0; ext_ptr++)
2944 enum address_class class;
2949 if (ext_ptr->ifd != f_idx)
2950 internal_error (__FILE__, __LINE__, "failed internal consistency check");
2951 psh = &ext_ptr->asym;
2953 /* Do not add undefined symbols to the partial symbol table. */
2954 if (SC_IS_UNDEF (psh->sc) || psh->sc == scNil)
2957 svalue = psh->value;
2962 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2969 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2973 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2980 /* These are generated for static symbols in .o files,
2985 /* External procedure symbols have been entered
2986 into the minimal symbol table in pass 2 above.
2987 Ignore them, as parse_external will ignore them too. */
2993 complain (&unknown_ext_complaint,
2994 debug_info->ssext + psh->iss);
2995 /* Fall through, pretend it's global. */
2997 /* Global common symbols are resolved by the runtime loader,
2999 if (SC_IS_COMMON (psh->sc))
3005 name = debug_info->ssext + psh->iss;
3006 add_psymbol_to_list (name, strlen (name),
3007 VAR_NAMESPACE, class,
3008 &objfile->global_psymbols,
3010 psymtab_language, objfile);
3014 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3015 empty and put on the free list. */
3016 fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
3017 psymtab_include_list, includes_used,
3018 -1, save_pst->texthigh,
3019 dependency_list, dependencies_used, textlow_not_set);
3021 dependencies_used = 0;
3023 if (objfile->ei.entry_point >= save_pst->textlow &&
3024 objfile->ei.entry_point < save_pst->texthigh)
3026 objfile->ei.entry_file_lowpc = save_pst->textlow;
3027 objfile->ei.entry_file_highpc = save_pst->texthigh;
3030 /* The objfile has its functions reordered if this partial symbol
3031 table overlaps any other partial symbol table.
3032 We cannot assume a reordered objfile if a partial symbol table
3033 is contained within another partial symbol table, as partial symbol
3034 tables for include files with executable code are contained
3035 within the partial symbol table for the including source file,
3036 and we do not want to flag the objfile reordered for these cases.
3038 This strategy works well for Irix-5.2 shared libraries, but we
3039 might have to use a more elaborate (and slower) algorithm for
3041 save_pst = fdr_to_pst[f_idx].pst;
3042 if (save_pst != NULL
3043 && save_pst->textlow != 0
3044 && !(objfile->flags & OBJF_REORDERED))
3046 ALL_OBJFILE_PSYMTABS (objfile, pst)
3049 && save_pst->textlow >= pst->textlow
3050 && save_pst->textlow < pst->texthigh
3051 && save_pst->texthigh > pst->texthigh)
3053 objfile->flags |= OBJF_REORDERED;
3060 /* Now scan the FDRs for dependencies */
3061 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
3063 fh = f_idx + debug_info->fdr;
3064 pst = fdr_to_pst[f_idx].pst;
3066 if (pst == (struct partial_symtab *) NULL)
3069 /* This should catch stabs-in-ecoff. */
3073 /* Skip the first file indirect entry as it is a self dependency
3074 for source files or a reverse .h -> .c dependency for header files. */
3075 pst->number_of_dependencies = 0;
3077 ((struct partial_symtab **)
3078 obstack_alloc (&objfile->psymbol_obstack,
3080 * sizeof (struct partial_symtab *))));
3081 for (s_idx = 1; s_idx < fh->crfd; s_idx++)
3085 (*swap_rfd_in) (cur_bfd,
3086 ((char *) debug_info->external_rfd
3087 + (fh->rfdBase + s_idx) * external_rfd_size),
3089 if (rh < 0 || rh >= hdr->ifdMax)
3091 complain (&bad_file_number_complaint, rh);
3095 /* Skip self dependencies of header files. */
3099 /* Do not add to dependeny list if psymtab was empty. */
3100 if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL)
3102 pst->dependencies[pst->number_of_dependencies++] = fdr_to_pst[rh].pst;
3106 /* Remove the dummy psymtab created for -O3 images above, if it is
3107 still empty, to enable the detection of stripped executables. */
3108 if (objfile->psymtabs->next == NULL
3109 && objfile->psymtabs->number_of_dependencies == 0
3110 && objfile->psymtabs->n_global_syms == 0
3111 && objfile->psymtabs->n_static_syms == 0)
3112 objfile->psymtabs = NULL;
3113 do_cleanups (old_chain);
3116 /* If the current psymbol has an enumerated type, we need to add
3117 all the the enum constants to the partial symbol table. */
3120 handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
3123 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
3124 void (*const swap_sym_in) (bfd *, PTR, SYMR *) = debug_swap->swap_sym_in;
3125 char *ext_sym = ((char *) debug_info->external_sym
3126 + ((fh->isymBase + cur_sdx + 1) * external_sym_size));
3136 /* It is an enumerated type if the next symbol entry is a stMember
3137 and its auxiliary index is indexNil or its auxiliary entry
3138 is a plain btNil or btVoid.
3139 Alpha cc -migrate enums are recognized by a zero index and
3140 a zero symbol value.
3141 DU 4.0 cc enums are recognized by a member type of btEnum without
3142 qualifiers and a zero symbol value. */
3143 (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3144 if (sh.st != stMember)
3147 if (sh.index == indexNil
3148 || (sh.index == 0 && svalue == 0))
3150 (*debug_swap->swap_tir_in) (fh->fBigendian,
3151 &(debug_info->external_aux
3152 + fh->iauxBase + sh.index)->a_ti,
3154 if ((tir.bt != btNil
3156 && (tir.bt != btEnum || svalue != 0))
3157 || tir.tq0 != tqNil)
3169 (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3170 if (sh.st != stMember)
3172 name = debug_info->ss + cur_fdr->issBase + sh.iss;
3174 /* Note that the value doesn't matter for enum constants
3175 in psymtabs, just in symtabs. */
3176 add_psymbol_to_list (name, strlen (name),
3177 VAR_NAMESPACE, LOC_CONST,
3178 &objfile->static_psymbols, 0,
3179 (CORE_ADDR) 0, psymtab_language, objfile);
3180 ext_sym += external_sym_size;
3184 /* Get the next symbol. OBJFILE is unused. */
3187 mdebug_next_symbol_text (struct objfile *objfile)
3192 (*debug_swap->swap_sym_in) (cur_bfd,
3193 ((char *) debug_info->external_sym
3194 + ((cur_fdr->isymBase + cur_sdx)
3195 * debug_swap->external_sym_size)),
3197 return debug_info->ss + cur_fdr->issBase + sh.iss;
3200 /* Ancillary function to psymtab_to_symtab(). Does all the work
3201 for turning the partial symtab PST into a symtab, recurring
3202 first on all dependent psymtabs. The argument FILENAME is
3203 only passed so we can see in debug stack traces what file
3206 This function has a split personality, based on whether the
3207 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3208 The flow of control and even the memory allocation differs. FIXME. */
3211 psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
3213 bfd_size_type external_sym_size;
3214 bfd_size_type external_pdr_size;
3215 void (*swap_sym_in) (bfd *, PTR, SYMR *);
3216 void (*swap_pdr_in) (bfd *, PTR, PDR *);
3218 struct symtab *st = NULL;
3220 struct linetable *lines;
3221 CORE_ADDR lowest_pdr_addr = 0;
3222 int last_symtab_ended = 0;
3228 /* Read in all partial symbtabs on which this one is dependent.
3229 NOTE that we do have circular dependencies, sigh. We solved
3230 that by setting pst->readin before this point. */
3232 for (i = 0; i < pst->number_of_dependencies; i++)
3233 if (!pst->dependencies[i]->readin)
3235 /* Inform about additional files to be read in. */
3238 fputs_filtered (" ", gdb_stdout);
3240 fputs_filtered ("and ", gdb_stdout);
3242 printf_filtered ("%s...",
3243 pst->dependencies[i]->filename);
3244 wrap_here (""); /* Flush output */
3245 gdb_flush (gdb_stdout);
3247 /* We only pass the filename for debug purposes */
3248 psymtab_to_symtab_1 (pst->dependencies[i],
3249 pst->dependencies[i]->filename);
3252 /* Do nothing if this is a dummy psymtab. */
3254 if (pst->n_global_syms == 0 && pst->n_static_syms == 0
3255 && pst->textlow == 0 && pst->texthigh == 0)
3258 /* Now read the symbols for this symtab */
3260 cur_bfd = CUR_BFD (pst);
3261 debug_swap = DEBUG_SWAP (pst);
3262 debug_info = DEBUG_INFO (pst);
3263 pending_list = PENDING_LIST (pst);
3264 external_sym_size = debug_swap->external_sym_size;
3265 external_pdr_size = debug_swap->external_pdr_size;
3266 swap_sym_in = debug_swap->swap_sym_in;
3267 swap_pdr_in = debug_swap->swap_pdr_in;
3268 current_objfile = pst->objfile;
3269 cur_fd = FDR_IDX (pst);
3270 fh = ((cur_fd == -1)
3272 : debug_info->fdr + cur_fd);
3275 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3276 processing_gcc_compilation = 0;
3277 if (fh != (FDR *) NULL && fh->csym >= 2)
3281 (*swap_sym_in) (cur_bfd,
3282 ((char *) debug_info->external_sym
3283 + (fh->isymBase + 1) * external_sym_size),
3285 if (STREQ (debug_info->ss + fh->issBase + sh.iss,
3288 /* We indicate that this is a GCC compilation so that certain
3289 features will be enabled in stabsread/dbxread. */
3290 processing_gcc_compilation = 2;
3294 if (processing_gcc_compilation != 0)
3297 /* This symbol table contains stabs-in-ecoff entries. */
3299 /* Parse local symbols first */
3301 if (fh->csym <= 2) /* FIXME, this blows psymtab->symtab ptr */
3303 current_objfile = NULL;
3306 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
3312 (*swap_sym_in) (cur_bfd,
3313 (((char *) debug_info->external_sym)
3314 + (fh->isymBase + cur_sdx) * external_sym_size),
3316 name = debug_info->ss + fh->issBase + sh.iss;
3318 /* XXX This is a hack. It will go away! */
3319 if (ECOFF_IS_STAB (&sh) || (name[0] == '#'))
3321 int type_code = ECOFF_UNMARK_STAB (sh.index);
3323 /* We should never get non N_STAB symbols here, but they
3324 should be harmless, so keep process_one_symbol from
3325 complaining about them. */
3326 if (type_code & N_STAB)
3328 /* If we found a trailing N_SO with no name, process
3329 it here instead of in process_one_symbol, so we
3330 can keep a handle to its symtab. The symtab
3331 would otherwise be ended twice, once in
3332 process_one_symbol, and once after this loop. */
3333 if (type_code == N_SO
3335 && previous_stab_code != (unsigned char) N_SO
3338 valu += ANOFFSET (pst->section_offsets,
3339 SECT_OFF_TEXT (pst->objfile));
3340 previous_stab_code = N_SO;
3341 st = end_symtab (valu, pst->objfile,
3342 SECT_OFF_TEXT (pst->objfile));
3344 last_symtab_ended = 1;
3348 last_symtab_ended = 0;
3349 process_one_symbol (type_code, 0, valu, name,
3350 pst->section_offsets, pst->objfile);
3353 /* Similarly a hack. */
3354 else if (name[0] == '#')
3356 process_one_symbol (N_SLINE, 0, valu, name,
3357 pst->section_offsets, pst->objfile);
3359 if (type_code == N_FUN)
3361 /* Make up special symbol to contain
3362 procedure specific info */
3363 struct mips_extra_func_info *e =
3364 ((struct mips_extra_func_info *)
3365 obstack_alloc (¤t_objfile->symbol_obstack,
3366 sizeof (struct mips_extra_func_info)));
3367 struct symbol *s = new_symbol (MIPS_EFI_SYMBOL_NAME);
3369 memset ((PTR) e, 0, sizeof (struct mips_extra_func_info));
3370 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
3371 SYMBOL_CLASS (s) = LOC_CONST;
3372 SYMBOL_TYPE (s) = mdebug_type_void;
3373 SYMBOL_VALUE (s) = (long) e;
3374 e->pdr.framereg = -1;
3375 add_symbol_to_list (s, &local_symbols);
3378 else if (sh.st == stLabel)
3380 if (sh.index == indexNil)
3382 /* This is what the gcc2_compiled and __gnu_compiled_*
3383 show up as. So don't complain. */
3388 /* Handle encoded stab line number. */
3389 valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile));
3390 record_line (current_subfile, sh.index, valu);
3393 else if (sh.st == stProc || sh.st == stStaticProc
3394 || sh.st == stStatic || sh.st == stEnd)
3395 /* These are generated by gcc-2.x, do not complain */
3398 complain (&stab_unknown_complaint, name);
3401 if (! last_symtab_ended)
3403 st = end_symtab (pst->texthigh, pst->objfile, SECT_OFF_TEXT (pst->objfile));
3407 /* Sort the symbol table now, we are done adding symbols to it.
3408 We must do this before parse_procedure calls lookup_symbol. */
3409 sort_symtab_syms (st);
3411 /* There used to be a call to sort_blocks here, but this should not
3412 be necessary for stabs symtabs. And as sort_blocks modifies the
3413 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3414 it did the wrong thing if the first procedure in a file was
3415 generated via asm statements. */
3417 /* Fill in procedure info next. */
3421 struct cleanup *old_chain;
3427 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
3428 old_chain = make_cleanup (xfree, pr_block);
3430 pdr_ptr = ((char *) debug_info->external_pdr
3431 + fh->ipdFirst * external_pdr_size);
3432 pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
3436 pdr_ptr += external_pdr_size, pdr_in++)
3438 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
3440 /* Determine lowest PDR address, the PDRs are not always
3442 if (pdr_in == pr_block)
3443 lowest_pdr_addr = pdr_in->adr;
3444 else if (pdr_in->adr < lowest_pdr_addr)
3445 lowest_pdr_addr = pdr_in->adr;
3449 pdr_in_end = pdr_in + fh->cpd;
3450 for (; pdr_in < pdr_in_end; pdr_in++)
3451 parse_procedure (pdr_in, st, pst);
3453 do_cleanups (old_chain);
3458 /* This symbol table contains ordinary ecoff entries. */
3464 /* How many symbols will we need */
3465 /* FIXME, this does not count enum values. */
3466 f_max = pst->n_global_syms + pst->n_static_syms;
3470 st = new_symtab ("unknown", f_max, 0, pst->objfile);
3474 f_max += fh->csym + fh->cpd;
3475 maxlines = 2 * fh->cline;
3476 st = new_symtab (pst->filename, 2 * f_max, maxlines, pst->objfile);
3478 /* The proper language was already determined when building
3479 the psymtab, use it. */
3480 st->language = PST_PRIVATE (pst)->pst_language;
3483 psymtab_language = st->language;
3485 lines = LINETABLE (st);
3487 /* Get a new lexical context */
3489 push_parse_stack ();
3490 top_stack->cur_st = st;
3491 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
3493 BLOCK_START (top_stack->cur_block) = pst->textlow;
3494 BLOCK_END (top_stack->cur_block) = 0;
3495 top_stack->blocktype = stFile;
3496 top_stack->maxsyms = 2 * f_max;
3497 top_stack->cur_type = 0;
3498 top_stack->procadr = 0;
3499 top_stack->numargs = 0;
3500 found_ecoff_debugging_info = 0;
3507 /* Parse local symbols first */
3508 sym_ptr = ((char *) debug_info->external_sym
3509 + fh->isymBase * external_sym_size);
3510 sym_end = sym_ptr + fh->csym * external_sym_size;
3511 while (sym_ptr < sym_end)
3516 (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
3517 c = parse_symbol (&sh,
3518 debug_info->external_aux + fh->iauxBase,
3519 sym_ptr, fh->fBigendian, pst->section_offsets, pst->objfile);
3520 sym_ptr += c * external_sym_size;
3523 /* Linenumbers. At the end, check if we can save memory.
3524 parse_lines has to look ahead an arbitrary number of PDR
3525 structures, so we swap them all first. */
3529 struct cleanup *old_chain;
3535 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
3537 old_chain = make_cleanup (xfree, pr_block);
3539 pdr_ptr = ((char *) debug_info->external_pdr
3540 + fh->ipdFirst * external_pdr_size);
3541 pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
3545 pdr_ptr += external_pdr_size, pdr_in++)
3547 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
3549 /* Determine lowest PDR address, the PDRs are not always
3551 if (pdr_in == pr_block)
3552 lowest_pdr_addr = pdr_in->adr;
3553 else if (pdr_in->adr < lowest_pdr_addr)
3554 lowest_pdr_addr = pdr_in->adr;
3557 parse_lines (fh, pr_block, lines, maxlines, pst, lowest_pdr_addr);
3558 if (lines->nitems < fh->cline)
3559 lines = shrink_linetable (lines);
3561 /* Fill in procedure info next. */
3563 pdr_in_end = pdr_in + fh->cpd;
3564 for (; pdr_in < pdr_in_end; pdr_in++)
3565 parse_procedure (pdr_in, 0, pst);
3567 do_cleanups (old_chain);
3571 LINETABLE (st) = lines;
3573 /* .. and our share of externals.
3574 XXX use the global list to speed up things here. how?
3575 FIXME, Maybe quit once we have found the right number of ext's? */
3576 top_stack->cur_st = st;
3577 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
3579 top_stack->blocktype = stFile;
3581 = (debug_info->symbolic_header.isymMax
3582 + debug_info->symbolic_header.ipdMax
3583 + debug_info->symbolic_header.iextMax);
3585 ext_ptr = PST_PRIVATE (pst)->extern_tab;
3586 for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
3587 parse_external (ext_ptr, fh->fBigendian, pst->section_offsets, pst->objfile);
3589 /* If there are undefined symbols, tell the user.
3590 The alpha has an undefined symbol for every symbol that is
3591 from a shared library, so tell the user only if verbose is on. */
3592 if (info_verbose && n_undef_symbols)
3594 printf_filtered ("File %s contains %d unresolved references:",
3595 st->filename, n_undef_symbols);
3596 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
3597 n_undef_vars, n_undef_procs, n_undef_labels);
3598 n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0;
3605 /* Sort the symbol table now, we are done adding symbols to it. */
3606 sort_symtab_syms (st);
3611 /* Now link the psymtab and the symtab. */
3614 current_objfile = NULL;
3617 /* Ancillary parsing procedures. */
3619 /* Return 1 if the symbol pointed to by SH has a cross reference
3620 to an opaque aggregate type, else 0. */
3623 has_opaque_xref (FDR *fh, SYMR *sh)
3630 if (sh->index == indexNil)
3633 ax = debug_info->external_aux + fh->iauxBase + sh->index;
3634 (*debug_swap->swap_tir_in) (fh->fBigendian, &ax->a_ti, &tir);
3635 if (tir.bt != btStruct && tir.bt != btUnion && tir.bt != btEnum)
3639 (*debug_swap->swap_rndx_in) (fh->fBigendian, &ax->a_rndx, rn);
3640 if (rn->rfd == 0xfff)
3641 rf = AUX_GET_ISYM (fh->fBigendian, ax + 1);
3649 /* Lookup the type at relative index RN. Return it in TPP
3650 if found and in any event come up with its name PNAME.
3651 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
3652 Return value says how many aux symbols we ate. */
3655 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. */
3656 char **pname, int bigend, char *sym_name)
3665 struct mdebug_pending *pend;
3667 *tpp = (struct type *) NULL;
3669 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
3671 /* Escape index means 'the next one' */
3672 if (rn->rfd == 0xfff)
3675 rf = AUX_GET_ISYM (bigend, ax + 1);
3682 /* mips cc uses a rf of -1 for opaque struct definitions.
3683 Set TYPE_FLAG_STUB for these types so that check_typedef will
3684 resolve them if the struct gets defined in another compilation unit. */
3687 *pname = "<undefined>";
3688 *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
3689 TYPE_FLAGS (*tpp) |= TYPE_FLAG_STUB;
3693 /* mips cc uses an escaped rn->index of 0 for struct return types
3694 of procedures that were compiled without -g. These will always remain
3696 if (rn->rfd == 0xfff && rn->index == 0)
3698 *pname = "<undefined>";
3702 /* Find the relative file descriptor and the symbol in it. */
3703 fh = get_rfd (fd, rf);
3704 xref_fd = fh - debug_info->fdr;
3706 if (rn->index >= fh->csym)
3708 /* File indirect entry is corrupt. */
3709 *pname = "<illegal>";
3710 complain (&bad_rfd_entry_complaint,
3711 sym_name, xref_fd, rn->index);
3715 /* If we have processed this symbol then we left a forwarding
3716 pointer to the type in the pending list. If not, we`ll put
3717 it in a list of pending types, to be processed later when
3718 the file will be. In any event, we collect the name for the
3721 esh = ((char *) debug_info->external_sym
3722 + ((fh->isymBase + rn->index)
3723 * debug_swap->external_sym_size));
3724 (*debug_swap->swap_sym_in) (cur_bfd, esh, &sh);
3726 /* Make sure that this type of cross reference can be handled. */
3727 if ((sh.sc != scInfo
3728 || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect
3729 && sh.st != stStruct && sh.st != stUnion
3730 && sh.st != stEnum))
3731 && (sh.st != stBlock || !SC_IS_COMMON (sh.sc)))
3733 /* File indirect entry is corrupt. */
3734 *pname = "<illegal>";
3735 complain (&bad_rfd_entry_complaint,
3736 sym_name, xref_fd, rn->index);
3740 *pname = debug_info->ss + fh->issBase + sh.iss;
3742 pend = is_pending_symbol (fh, esh);
3747 /* We have not yet seen this type. */
3749 if ((sh.iss == 0 && sh.st == stTypedef) || sh.st == stIndirect)
3753 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3755 a) forward declarations of structs/unions/enums which are not
3756 defined in this compilation unit.
3757 For these the type will be void. This is a bad design decision
3758 as cross referencing across compilation units is impossible
3759 due to the missing name.
3760 b) forward declarations of structs/unions/enums/typedefs which
3761 are defined later in this file or in another file in the same
3762 compilation unit. Irix5 cc uses a stIndirect symbol for this.
3763 Simply cross reference those again to get the true type.
3764 The forward references are not entered in the pending list and
3765 in the symbol table. */
3767 (*debug_swap->swap_tir_in) (bigend,
3768 &(debug_info->external_aux
3769 + fh->iauxBase + sh.index)->a_ti,
3771 if (tir.tq0 != tqNil)
3772 complain (&illegal_forward_tq0_complaint, sym_name);
3776 *tpp = init_type (type_code, 0, 0, (char *) NULL,
3778 *pname = "<undefined>";
3785 (debug_info->external_aux
3786 + fh->iauxBase + sh.index + 1),
3787 tpp, type_code, pname,
3788 fh->fBigendian, sym_name);
3792 /* Follow a forward typedef. This might recursively
3793 call cross_ref till we get a non typedef'ed type.
3794 FIXME: This is not correct behaviour, but gdb currently
3795 cannot handle typedefs without type copying. Type
3796 copying is impossible as we might have mutual forward
3797 references between two files and the copied type would not
3798 get filled in when we later parse its definition. */
3799 *tpp = parse_type (xref_fd,
3800 debug_info->external_aux + fh->iauxBase,
3804 debug_info->ss + fh->issBase + sh.iss);
3805 add_pending (fh, esh, *tpp);
3809 complain (&illegal_forward_bt_complaint, tir.bt, sym_name);
3810 *tpp = init_type (type_code, 0, 0, (char *) NULL,
3816 else if (sh.st == stTypedef)
3818 /* Parse the type for a normal typedef. This might recursively call
3819 cross_ref till we get a non typedef'ed type.
3820 FIXME: This is not correct behaviour, but gdb currently
3821 cannot handle typedefs without type copying. But type copying is
3822 impossible as we might have mutual forward references between
3823 two files and the copied type would not get filled in when
3824 we later parse its definition. */
3825 *tpp = parse_type (xref_fd,
3826 debug_info->external_aux + fh->iauxBase,
3830 debug_info->ss + fh->issBase + sh.iss);
3834 /* Cross reference to a struct/union/enum which is defined
3835 in another file in the same compilation unit but that file
3836 has not been parsed yet.
3837 Initialize the type only, it will be filled in when
3838 it's definition is parsed. */
3839 *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
3841 add_pending (fh, esh, *tpp);
3844 /* We used one auxent normally, two if we got a "next one" rf. */
3849 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3850 keeping the symtab sorted */
3852 static struct symbol *
3853 mylookup_symbol (char *name, register struct block *block,
3854 namespace_enum namespace, enum address_class class)
3856 register int bot, top, inc;
3857 register struct symbol *sym;
3860 top = BLOCK_NSYMS (block);
3864 sym = BLOCK_SYM (block, bot);
3865 if (SYMBOL_NAME (sym)[0] == inc
3866 && SYMBOL_NAMESPACE (sym) == namespace
3867 && SYMBOL_CLASS (sym) == class
3868 && strcmp (SYMBOL_NAME (sym), name) == 0)
3872 block = BLOCK_SUPERBLOCK (block);
3874 return mylookup_symbol (name, block, namespace, class);
3879 /* Add a new symbol S to a block B.
3880 Infrequently, we will need to reallocate the block to make it bigger.
3881 We only detect this case when adding to top_stack->cur_block, since
3882 that's the only time we know how big the block is. FIXME. */
3885 add_symbol (struct symbol *s, struct block *b)
3887 int nsyms = BLOCK_NSYMS (b)++;
3888 struct block *origb;
3889 struct parse_stack *stackp;
3891 if (b == top_stack->cur_block &&
3892 nsyms >= top_stack->maxsyms)
3894 complain (&block_overflow_complaint, SYMBOL_NAME (s));
3895 /* In this case shrink_block is actually grow_block, since
3896 BLOCK_NSYMS(b) is larger than its current size. */
3898 b = shrink_block (top_stack->cur_block, top_stack->cur_st);
3900 /* Now run through the stack replacing pointers to the
3901 original block. shrink_block has already done this
3902 for the blockvector and BLOCK_FUNCTION. */
3903 for (stackp = top_stack; stackp; stackp = stackp->next)
3905 if (stackp->cur_block == origb)
3907 stackp->cur_block = b;
3908 stackp->maxsyms = BLOCK_NSYMS (b);
3912 BLOCK_SYM (b, nsyms) = s;
3915 /* Add a new block B to a symtab S */
3918 add_block (struct block *b, struct symtab *s)
3920 struct blockvector *bv = BLOCKVECTOR (s);
3922 bv = (struct blockvector *) xrealloc ((PTR) bv,
3923 (sizeof (struct blockvector)
3924 + BLOCKVECTOR_NBLOCKS (bv)
3925 * sizeof (bv->block)));
3926 if (bv != BLOCKVECTOR (s))
3927 BLOCKVECTOR (s) = bv;
3929 BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b;
3932 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3933 MIPS' linenumber encoding might need more than one byte
3934 to describe it, LAST is used to detect these continuation lines.
3936 Combining lines with the same line number seems like a bad idea.
3937 E.g: There could be a line number entry with the same line number after the
3938 prologue and GDB should not ignore it (this is a better way to find
3939 a prologue than mips_skip_prologue).
3940 But due to the compressed line table format there are line number entries
3941 for the same line which are needed to bridge the gap to the next
3942 line number entry. These entries have a bogus address info with them
3943 and we are unable to tell them from intended duplicate line number
3945 This is another reason why -ggdb debugging format is preferable. */
3948 add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last)
3950 /* DEC c89 sometimes produces zero linenos which confuse gdb.
3951 Change them to something sensible. */
3955 last = -2; /* make sure we record first line */
3957 if (last == lineno) /* skip continuation lines */
3960 lt->item[lt->nitems].line = lineno;
3961 lt->item[lt->nitems++].pc = adr << 2;
3965 /* Sorting and reordering procedures */
3967 /* Blocks with a smaller low bound should come first */
3970 compare_blocks (const PTR arg1, const PTR arg2)
3972 register int addr_diff;
3973 struct block **b1 = (struct block **) arg1;
3974 struct block **b2 = (struct block **) arg2;
3976 addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2)));
3978 return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1)));
3982 /* Sort the blocks of a symtab S.
3983 Reorder the blocks in the blockvector by code-address,
3984 as required by some MI search routines */
3987 sort_blocks (struct symtab *s)
3989 struct blockvector *bv = BLOCKVECTOR (s);
3991 if (BLOCKVECTOR_NBLOCKS (bv) <= 2)
3994 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0)
3995 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0;
3996 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0)
3997 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0;
4001 * This is very unfortunate: normally all functions are compiled in
4002 * the order they are found, but if the file is compiled -O3 things
4003 * are very different. It would be nice to find a reliable test
4004 * to detect -O3 images in advance.
4006 if (BLOCKVECTOR_NBLOCKS (bv) > 3)
4007 qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
4008 BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK,
4009 sizeof (struct block *),
4013 register CORE_ADDR high = 0;
4014 register int i, j = BLOCKVECTOR_NBLOCKS (bv);
4016 for (i = FIRST_LOCAL_BLOCK; i < j; i++)
4017 if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)))
4018 high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i));
4019 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high;
4022 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) =
4023 BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK));
4025 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4026 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4027 BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4028 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4032 /* Constructor/restructor/destructor procedures */
4034 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
4035 MAXSYMS and linenumbers MAXLINES we'll put in it */
4037 static struct symtab *
4038 new_symtab (char *name, int maxsyms, int maxlines, struct objfile *objfile)
4040 struct symtab *s = allocate_symtab (name, objfile);
4042 LINETABLE (s) = new_linetable (maxlines);
4044 /* All symtabs must have at least two blocks */
4045 BLOCKVECTOR (s) = new_bvect (2);
4046 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) = new_block (maxsyms);
4047 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) = new_block (maxsyms);
4048 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
4049 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4051 s->free_code = free_linetable;
4052 s->debugformat = obsavestring ("ECOFF", 5,
4053 &objfile->symbol_obstack);
4057 /* Allocate a new partial_symtab NAME */
4059 static struct partial_symtab *
4060 new_psymtab (char *name, struct objfile *objfile)
4062 struct partial_symtab *psymtab;
4064 psymtab = allocate_psymtab (name, objfile);
4065 psymtab->section_offsets = objfile->section_offsets;
4067 /* Keep a backpointer to the file's symbols */
4069 psymtab->read_symtab_private = ((char *)
4070 obstack_alloc (&objfile->psymbol_obstack,
4071 sizeof (struct symloc)));
4072 memset ((PTR) psymtab->read_symtab_private, 0, sizeof (struct symloc));
4073 CUR_BFD (psymtab) = cur_bfd;
4074 DEBUG_SWAP (psymtab) = debug_swap;
4075 DEBUG_INFO (psymtab) = debug_info;
4076 PENDING_LIST (psymtab) = pending_list;
4078 /* The way to turn this into a symtab is to call... */
4079 psymtab->read_symtab = mdebug_psymtab_to_symtab;
4084 /* Allocate a linetable array of the given SIZE. Since the struct
4085 already includes one item, we subtract one when calculating the
4086 proper size to allocate. */
4088 static struct linetable *
4089 new_linetable (int size)
4091 struct linetable *l;
4093 size = (size - 1) * sizeof (l->item) + sizeof (struct linetable);
4094 l = (struct linetable *) xmalloc (size);
4099 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4100 I am not so sure about the 3.4 ones.
4102 Since the struct linetable already includes one item, we subtract one when
4103 calculating the proper size to allocate. */
4105 static struct linetable *
4106 shrink_linetable (struct linetable *lt)
4109 return (struct linetable *) xrealloc ((PTR) lt,
4110 (sizeof (struct linetable)
4112 * sizeof (lt->item))));
4115 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4117 static struct blockvector *
4118 new_bvect (int nblocks)
4120 struct blockvector *bv;
4123 size = sizeof (struct blockvector) + nblocks * sizeof (struct block *);
4124 bv = (struct blockvector *) xzalloc (size);
4126 BLOCKVECTOR_NBLOCKS (bv) = nblocks;
4131 /* Allocate and zero a new block of MAXSYMS symbols */
4133 static struct block *
4134 new_block (int maxsyms)
4136 int size = sizeof (struct block) + (maxsyms - 1) * sizeof (struct symbol *);
4138 return (struct block *) xzalloc (size);
4141 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
4142 Shrink_block can also be used by add_symbol to grow a block. */
4144 static struct block *
4145 shrink_block (struct block *b, struct symtab *s)
4148 struct blockvector *bv = BLOCKVECTOR (s);
4151 /* Just reallocate it and fix references to the old one */
4153 new = (struct block *) xrealloc ((PTR) b,
4154 (sizeof (struct block)
4155 + ((BLOCK_NSYMS (b) - 1)
4156 * sizeof (struct symbol *))));
4158 /* Should chase pointers to old one. Fortunately, that`s just
4159 the block`s function and inferior blocks */
4160 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b)
4161 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
4162 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
4163 if (BLOCKVECTOR_BLOCK (bv, i) == b)
4164 BLOCKVECTOR_BLOCK (bv, i) = new;
4165 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) == b)
4166 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) = new;
4170 /* Create a new symbol with printname NAME */
4172 static struct symbol *
4173 new_symbol (char *name)
4175 struct symbol *s = ((struct symbol *)
4176 obstack_alloc (¤t_objfile->symbol_obstack,
4177 sizeof (struct symbol)));
4179 memset ((PTR) s, 0, sizeof (*s));
4180 SYMBOL_NAME (s) = obsavestring (name, strlen (name),
4181 ¤t_objfile->symbol_obstack);
4182 SYMBOL_LANGUAGE (s) = psymtab_language;
4183 SYMBOL_INIT_DEMANGLED_NAME (s, ¤t_objfile->symbol_obstack);
4187 /* Create a new type with printname NAME */
4189 static struct type *
4190 new_type (char *name)
4194 t = alloc_type (current_objfile);
4195 TYPE_NAME (t) = name;
4196 TYPE_CPLUS_SPECIFIC (t) = (struct cplus_struct_type *) &cplus_struct_default;
4200 /* Read ECOFF debugging information from a BFD section. This is
4201 called from elfread.c. It parses the section into a
4202 ecoff_debug_info struct, and then lets the rest of the file handle
4206 elfmdebug_build_psymtabs (struct objfile *objfile,
4207 const struct ecoff_debug_swap *swap, asection *sec)
4209 bfd *abfd = objfile->obfd;
4210 struct ecoff_debug_info *info;
4212 info = ((struct ecoff_debug_info *)
4213 obstack_alloc (&objfile->psymbol_obstack,
4214 sizeof (struct ecoff_debug_info)));
4216 if (!(*swap->read_debug_info) (abfd, sec, info))
4217 error ("Error reading ECOFF debugging information: %s",
4218 bfd_errmsg (bfd_get_error ()));
4220 mdebug_build_psymtabs (objfile, swap, info);
4224 /* Things used for calling functions in the inferior.
4225 These functions are exported to our companion
4226 mips-tdep.c file and are here because they play
4227 with the symbol-table explicitly. */
4229 /* Sigtramp: make sure we have all the necessary information
4230 about the signal trampoline code. Since the official code
4231 from MIPS does not do so, we make up that information ourselves.
4232 If they fix the library (unlikely) this code will neutralize itself. */
4234 /* FIXME: This function is called only by mips-tdep.c. It needs to be
4235 here because it calls functions defined in this file, but perhaps
4236 this could be handled in a better way. Only compile it in when
4237 tm-mips.h is included. */
4242 fixup_sigtramp (void)
4246 struct block *b, *b0 = NULL;
4248 sigtramp_address = -1;
4250 /* We have to handle the following cases here:
4251 a) The Mips library has a sigtramp label within sigvec.
4252 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
4253 s = lookup_symbol ("sigvec", 0, VAR_NAMESPACE, 0, NULL);
4256 b0 = SYMBOL_BLOCK_VALUE (s);
4257 s = lookup_symbol ("sigtramp", b0, VAR_NAMESPACE, 0, NULL);
4261 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
4262 s = lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE, 0, NULL);
4265 /* But maybe this program uses its own version of sigvec */
4269 /* Did we or MIPSco fix the library ? */
4270 if (SYMBOL_CLASS (s) == LOC_BLOCK)
4272 sigtramp_address = BLOCK_START (SYMBOL_BLOCK_VALUE (s));
4273 sigtramp_end = BLOCK_END (SYMBOL_BLOCK_VALUE (s));
4277 sigtramp_address = SYMBOL_VALUE (s);
4278 sigtramp_end = sigtramp_address + 0x88; /* black magic */
4280 /* But what symtab does it live in ? */
4281 st = find_pc_symtab (SYMBOL_VALUE (s));
4284 * Ok, there goes the fix: turn it into a procedure, with all the
4285 * needed info. Note we make it a nested procedure of sigvec,
4286 * which is the way the (assembly) code is actually written.
4288 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
4289 SYMBOL_CLASS (s) = LOC_BLOCK;
4290 SYMBOL_TYPE (s) = init_type (TYPE_CODE_FUNC, 4, 0, (char *) NULL,
4292 TYPE_TARGET_TYPE (SYMBOL_TYPE (s)) = mdebug_type_void;
4294 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4296 SYMBOL_BLOCK_VALUE (s) = b;
4297 BLOCK_START (b) = sigtramp_address;
4298 BLOCK_END (b) = sigtramp_end;
4299 BLOCK_FUNCTION (b) = s;
4300 BLOCK_SUPERBLOCK (b) = BLOCK_SUPERBLOCK (b0);
4304 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4306 struct mips_extra_func_info *e =
4307 ((struct mips_extra_func_info *)
4308 xzalloc (sizeof (struct mips_extra_func_info)));
4310 e->numargs = 0; /* the kernel thinks otherwise */
4311 e->pdr.frameoffset = 32;
4312 e->pdr.framereg = SP_REGNUM;
4313 /* Note that setting pcreg is no longer strictly necessary as
4314 mips_frame_saved_pc is now aware of signal handler frames. */
4315 e->pdr.pcreg = PC_REGNUM;
4316 e->pdr.regmask = -2;
4317 /* Offset to saved r31, in the sigtramp case the saved registers
4318 are above the frame in the sigcontext.
4319 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4320 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4321 and 32 * 4 bytes for the floating point registers. */
4322 e->pdr.regoffset = 4 + 12 + 31 * 4;
4323 e->pdr.fregmask = -1;
4324 /* Offset to saved f30 (first saved *double* register). */
4325 e->pdr.fregoffset = 4 + 12 + 32 * 4 + 12 + 30 * 4;
4326 e->pdr.isym = (long) s;
4327 e->pdr.adr = sigtramp_address;
4329 current_objfile = st->objfile; /* Keep new_symbol happy */
4330 s = new_symbol (MIPS_EFI_SYMBOL_NAME);
4331 SYMBOL_VALUE (s) = (long) e;
4332 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
4333 SYMBOL_CLASS (s) = LOC_CONST;
4334 SYMBOL_TYPE (s) = mdebug_type_void;
4335 current_objfile = NULL;
4338 BLOCK_SYM (b, BLOCK_NSYMS (b)++) = s;
4341 #endif /* TM_MIPS_H */
4344 _initialize_mdebugread (void)
4347 init_type (TYPE_CODE_VOID, 1,
4349 "void", (struct objfile *) NULL);
4351 init_type (TYPE_CODE_INT, 1,
4353 "char", (struct objfile *) NULL);
4354 mdebug_type_unsigned_char =
4355 init_type (TYPE_CODE_INT, 1,
4357 "unsigned char", (struct objfile *) NULL);
4359 init_type (TYPE_CODE_INT, 2,
4361 "short", (struct objfile *) NULL);
4362 mdebug_type_unsigned_short =
4363 init_type (TYPE_CODE_INT, 2,
4365 "unsigned short", (struct objfile *) NULL);
4366 mdebug_type_int_32 =
4367 init_type (TYPE_CODE_INT, 4,
4369 "int", (struct objfile *) NULL);
4370 mdebug_type_unsigned_int_32 =
4371 init_type (TYPE_CODE_INT, 4,
4373 "unsigned int", (struct objfile *) NULL);
4374 mdebug_type_int_64 =
4375 init_type (TYPE_CODE_INT, 8,
4377 "int", (struct objfile *) NULL);
4378 mdebug_type_unsigned_int_64 =
4379 init_type (TYPE_CODE_INT, 8,
4381 "unsigned int", (struct objfile *) NULL);
4382 mdebug_type_long_32 =
4383 init_type (TYPE_CODE_INT, 4,
4385 "long", (struct objfile *) NULL);
4386 mdebug_type_unsigned_long_32 =
4387 init_type (TYPE_CODE_INT, 4,
4389 "unsigned long", (struct objfile *) NULL);
4390 mdebug_type_long_64 =
4391 init_type (TYPE_CODE_INT, 8,
4393 "long", (struct objfile *) NULL);
4394 mdebug_type_unsigned_long_64 =
4395 init_type (TYPE_CODE_INT, 8,
4397 "unsigned long", (struct objfile *) NULL);
4398 mdebug_type_long_long_64 =
4399 init_type (TYPE_CODE_INT, 8,
4401 "long long", (struct objfile *) NULL);
4402 mdebug_type_unsigned_long_long_64 =
4403 init_type (TYPE_CODE_INT, 8,
4405 "unsigned long long", (struct objfile *) NULL);
4406 mdebug_type_adr_32 =
4407 init_type (TYPE_CODE_PTR, 4,
4409 "adr_32", (struct objfile *) NULL);
4410 TYPE_TARGET_TYPE (mdebug_type_adr_32) = mdebug_type_void;
4411 mdebug_type_adr_64 =
4412 init_type (TYPE_CODE_PTR, 8,
4414 "adr_64", (struct objfile *) NULL);
4415 TYPE_TARGET_TYPE (mdebug_type_adr_64) = mdebug_type_void;
4417 init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
4419 "float", (struct objfile *) NULL);
4420 mdebug_type_double =
4421 init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
4423 "double", (struct objfile *) NULL);
4424 mdebug_type_complex =
4425 init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
4427 "complex", (struct objfile *) NULL);
4428 TYPE_TARGET_TYPE (mdebug_type_complex) = mdebug_type_float;
4429 mdebug_type_double_complex =
4430 init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
4432 "double complex", (struct objfile *) NULL);
4433 TYPE_TARGET_TYPE (mdebug_type_double_complex) = mdebug_type_double;
4435 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4437 mdebug_type_string =
4438 init_type (TYPE_CODE_STRING,
4439 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
4441 (struct objfile *) NULL);
4443 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4444 good? Would we be better off with TYPE_CODE_ERROR? Should
4445 TYPE_CODE_ERROR print things in hex if it knows the size? */
4446 mdebug_type_fixed_dec =
4447 init_type (TYPE_CODE_INT,
4448 TARGET_INT_BIT / TARGET_CHAR_BIT,
4450 (struct objfile *) NULL);
4452 mdebug_type_float_dec =
4453 init_type (TYPE_CODE_ERROR,
4454 TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
4455 0, "floating decimal",
4456 (struct objfile *) NULL);
4458 nodebug_func_symbol_type = init_type (TYPE_CODE_FUNC, 1, 0,
4459 "<function, no debug info>", NULL);
4460 TYPE_TARGET_TYPE (nodebug_func_symbol_type) = mdebug_type_int;
4461 nodebug_var_symbol_type =
4462 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
4463 "<variable, no debug info>", NULL);