1 /* Read a symbol table in ECOFF format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
3 1997, 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
5 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
6 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
26 /* This module provides the function mdebug_build_psymtabs. It reads
27 ECOFF debugging information into partial symbol tables. The
28 debugging information is read from two structures. A struct
29 ecoff_debug_swap includes the sizes of each ECOFF structure and
30 swapping routines; these are fixed for a particular target. A
31 struct ecoff_debug_info points to the debugging information for a
32 particular object file.
34 ECOFF symbol tables are mostly written in the byte order of the
35 target machine. However, one section of the table (the auxiliary
36 symbol information) is written in the host byte order. There is a
37 bit in the other symbol info which describes which host byte order
38 was used. ECOFF thereby takes the trophy from Intel `b.out' for
39 the most brain-dead adaptation of a file format to byte order.
41 This module can read all four of the known byte-order combinations,
42 on any type of host. */
50 #include "gdb_obstack.h"
52 #include "stabsread.h"
53 #include "complaints.h"
55 #include "gdb_assert.h"
57 /* These are needed if the tm.h file does not contain the necessary
58 mips specific definitions. */
60 #ifndef MIPS_EFI_SYMBOL_NAME
61 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
62 extern void ecoff_relocate_efi (struct symbol *, CORE_ADDR);
64 #include "coff/symconst.h"
65 typedef struct mips_extra_func_info
70 *mips_extra_func_info_t;
77 #include <sys/types.h>
81 #include "gdb_string.h"
85 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
87 #include "libaout.h" /* Private BFD a.out information. */
88 #include "aout/aout64.h"
89 #include "aout/stab_gnu.h" /* STABS information */
91 #include "expression.h"
92 #include "language.h" /* For local_hex_string() */
94 extern void _initialize_mdebugread (void);
96 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
97 We use this define in order to know whether we should override a
98 symbol's ECOFF section with its ELF section. This is necessary in
99 case the symbol's ELF section could not be represented in ECOFF. */
100 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
101 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
104 /* We put a pointer to this structure in the read_symtab_private field
109 /* Index of the FDR that this psymtab represents. */
111 /* The BFD that the psymtab was created from. */
113 const struct ecoff_debug_swap *debug_swap;
114 struct ecoff_debug_info *debug_info;
115 struct mdebug_pending **pending_list;
116 /* Pointer to external symbols for this file. */
118 /* Size of extern_tab. */
120 enum language pst_language;
123 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
124 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
125 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
126 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
127 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
128 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
130 #define SC_IS_TEXT(sc) ((sc) == scText \
131 || (sc) == scRConst \
134 #define SC_IS_DATA(sc) ((sc) == scData \
139 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
140 #define SC_IS_BSS(sc) ((sc) == scBss)
141 #define SC_IS_SBSS(sc) ((sc) == scSBss)
142 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
144 /* Various complaints about symbol reading that don't abort the process */
146 index_complaint (const char *arg1)
148 complaint (&symfile_complaints, "bad aux index at symbol %s", arg1);
152 unknown_ext_complaint (const char *arg1)
154 complaint (&symfile_complaints, "unknown external symbol %s", arg1);
158 basic_type_complaint (int arg1, const char *arg2)
160 complaint (&symfile_complaints, "cannot map ECOFF basic type 0x%x for %s",
165 bad_tag_guess_complaint (const char *arg1)
167 complaint (&symfile_complaints, "guessed tag type of %s incorrectly", arg1);
171 bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
173 complaint (&symfile_complaints, "bad rfd entry for %s: file %d, index %d",
178 unexpected_type_code_complaint (const char *arg1)
180 complaint (&symfile_complaints, "unexpected type code for %s", arg1);
183 /* Macros and extra defs */
185 /* Puns: hard to find whether -g was used and how */
187 #define MIN_GLEVEL GLEVEL_0
188 #define compare_glevel(a,b) \
189 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
190 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
192 /* Things that really are local to this module */
194 /* Remember what we deduced to be the source language of this psymtab. */
196 static enum language psymtab_language = language_unknown;
202 /* How to parse debugging information for CUR_BFD. */
204 static const struct ecoff_debug_swap *debug_swap;
206 /* Pointers to debugging information for CUR_BFD. */
208 static struct ecoff_debug_info *debug_info;
210 /* Pointer to current file decriptor record, and its index */
215 /* Index of current symbol */
219 /* Note how much "debuggable" this image is. We would like
220 to see at least one FDR with full symbols */
222 static int max_gdbinfo;
223 static int max_glevel;
225 /* When examining .o files, report on undefined symbols */
227 static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
229 /* Pseudo symbol to use when putting stabs into the symbol table. */
231 static char stabs_symbol[] = STABS_SYMBOL;
233 /* Types corresponding to mdebug format bt* basic types. */
235 static struct type *mdebug_type_void;
236 static struct type *mdebug_type_char;
237 static struct type *mdebug_type_short;
238 static struct type *mdebug_type_int_32;
239 #define mdebug_type_int mdebug_type_int_32
240 static struct type *mdebug_type_int_64;
241 static struct type *mdebug_type_long_32;
242 static struct type *mdebug_type_long_64;
243 static struct type *mdebug_type_long_long_64;
244 static struct type *mdebug_type_unsigned_char;
245 static struct type *mdebug_type_unsigned_short;
246 static struct type *mdebug_type_unsigned_int_32;
247 static struct type *mdebug_type_unsigned_int_64;
248 static struct type *mdebug_type_unsigned_long_32;
249 static struct type *mdebug_type_unsigned_long_64;
250 static struct type *mdebug_type_unsigned_long_long_64;
251 static struct type *mdebug_type_adr_32;
252 static struct type *mdebug_type_adr_64;
253 static struct type *mdebug_type_float;
254 static struct type *mdebug_type_double;
255 static struct type *mdebug_type_complex;
256 static struct type *mdebug_type_double_complex;
257 static struct type *mdebug_type_fixed_dec;
258 static struct type *mdebug_type_float_dec;
259 static struct type *mdebug_type_string;
261 /* Types for symbols from files compiled without debugging info. */
263 static struct type *nodebug_func_symbol_type;
264 static struct type *nodebug_var_symbol_type;
266 /* Nonzero if we have seen ecoff debugging info for a file. */
268 static int found_ecoff_debugging_info;
270 /* Forward declarations */
272 static int upgrade_type (int, struct type **, int, union aux_ext *,
275 static void parse_partial_symbols (struct objfile *);
277 static int has_opaque_xref (FDR *, SYMR *);
279 static int cross_ref (int, union aux_ext *, struct type **, enum type_code,
280 char **, int, char *);
282 static struct symbol *new_symbol (char *);
284 static struct type *new_type (char *);
286 static struct block *new_block (int);
288 static struct symtab *new_symtab (char *, int, int, struct objfile *);
290 static struct linetable *new_linetable (int);
292 static struct blockvector *new_bvect (int);
294 static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
297 static struct symbol *mylookup_symbol (char *, struct block *, namespace_enum,
300 static struct block *shrink_block (struct block *, struct symtab *);
302 static void sort_blocks (struct symtab *);
304 static struct partial_symtab *new_psymtab (char *, struct objfile *);
306 static void psymtab_to_symtab_1 (struct partial_symtab *, char *);
308 static void add_block (struct block *, struct symtab *);
310 static void add_symbol (struct symbol *, struct block *);
312 static int add_line (struct linetable *, int, CORE_ADDR, int);
314 static struct linetable *shrink_linetable (struct linetable *);
316 static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
319 static char *mdebug_next_symbol_text (struct objfile *);
321 /* Address bounds for the signal trampoline in inferior, if any */
323 CORE_ADDR sigtramp_address, sigtramp_end;
325 /* Allocate zeroed memory */
328 xzalloc (unsigned int size)
330 void *p = xmalloc (size);
336 /* Exported procedure: Builds a symtab from the PST partial one.
337 Restores the environment in effect when PST was created, delegates
338 most of the work to an ancillary procedure, and sorts
339 and reorders the symtab list at the end */
342 mdebug_psymtab_to_symtab (struct partial_symtab *pst)
350 printf_filtered ("Reading in symbols for %s...", pst->filename);
351 gdb_flush (gdb_stdout);
354 next_symbol_text_func = mdebug_next_symbol_text;
356 psymtab_to_symtab_1 (pst, pst->filename);
358 /* Match with global symbols. This only needs to be done once,
359 after all of the symtabs and dependencies have been read in. */
360 scan_file_globals (pst->objfile);
363 printf_filtered ("done.\n");
366 /* File-level interface functions */
368 /* Find a file descriptor given its index RF relative to a file CF */
371 get_rfd (int cf, int rf)
377 fdrs = debug_info->fdr;
379 /* Object files do not have the RFD table, all refs are absolute */
382 (*debug_swap->swap_rfd_in) (cur_bfd,
383 ((char *) debug_info->external_rfd
385 * debug_swap->external_rfd_size)),
390 /* Return a safer print NAME for a file descriptor */
396 return "<stripped file>";
399 return debug_info->ss + f->issBase + f->rss;
403 /* Read in and parse the symtab of the file OBJFILE. Symbols from
404 different sections are relocated via the SECTION_OFFSETS. */
407 mdebug_build_psymtabs (struct objfile *objfile,
408 const struct ecoff_debug_swap *swap,
409 struct ecoff_debug_info *info)
411 cur_bfd = objfile->obfd;
415 stabsread_new_init ();
416 buildsym_new_init ();
417 free_header_files ();
418 init_header_files ();
420 /* Make sure all the FDR information is swapped in. */
421 if (info->fdr == (FDR *) NULL)
427 info->fdr = (FDR *) obstack_alloc (&objfile->psymbol_obstack,
428 (info->symbolic_header.ifdMax
430 fdr_src = info->external_fdr;
432 + info->symbolic_header.ifdMax * swap->external_fdr_size);
434 for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++)
435 (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);
438 parse_partial_symbols (objfile);
441 /* Check to make sure file was compiled with -g. If not, warn the
442 user of this limitation. */
443 if (compare_glevel (max_glevel, GLEVEL_2) < 0)
445 if (max_gdbinfo == 0)
446 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
448 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
449 gdb_flush (gdb_stdout);
454 /* Local utilities */
456 /* Map of FDR indexes to partial symtabs */
460 struct partial_symtab *pst; /* the psymtab proper */
461 long n_globals; /* exported globals (external symbols) */
462 long globals_offset; /* cumulative */
466 /* Utility stack, used to nest procedures and blocks properly.
467 It is a doubly linked list, to avoid too many alloc/free.
468 Since we might need it quite a few times it is NOT deallocated
471 static struct parse_stack
473 struct parse_stack *next, *prev;
474 struct symtab *cur_st; /* Current symtab. */
475 struct block *cur_block; /* Block in it. */
477 /* What are we parsing. stFile, or stBlock are for files and
478 blocks. stProc or stStaticProc means we have seen the start of a
479 procedure, but not the start of the block within in. When we see
480 the start of that block, we change it to stNil, without pushing a
481 new block, i.e. stNil means both a procedure and a block. */
485 int maxsyms; /* Max symbols in this block. */
486 struct type *cur_type; /* Type we parse fields for. */
487 int cur_field; /* Field number in cur_type. */
488 CORE_ADDR procadr; /* Start addres of this procedure */
489 int numargs; /* Its argument count */
492 *top_stack; /* Top stack ptr */
495 /* Enter a new lexical context */
498 push_parse_stack (void)
500 struct parse_stack *new;
502 /* Reuse frames if possible */
503 if (top_stack && top_stack->prev)
504 new = top_stack->prev;
506 new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
507 /* Initialize new frame with previous content */
510 register struct parse_stack *prev = new->prev;
513 top_stack->prev = new;
515 new->next = top_stack;
520 /* Exit a lexical context */
523 pop_parse_stack (void)
528 top_stack = top_stack->next;
532 /* Cross-references might be to things we haven't looked at
533 yet, e.g. type references. To avoid too many type
534 duplications we keep a quick fixup table, an array
535 of lists of references indexed by file descriptor */
537 struct mdebug_pending
539 struct mdebug_pending *next; /* link */
540 char *s; /* the unswapped symbol */
541 struct type *t; /* its partial type descriptor */
545 /* The pending information is kept for an entire object file, and used
546 to be in the sym_private field. I took it out when I split
547 mdebugread from mipsread, because this might not be the only type
548 of symbols read from an object file. Instead, we allocate the
549 pending information table when we create the partial symbols, and
550 we store a pointer to the single table in each psymtab. */
552 static struct mdebug_pending **pending_list;
554 /* Check whether we already saw symbol SH in file FH */
556 static struct mdebug_pending *
557 is_pending_symbol (FDR *fh, char *sh)
559 int f_idx = fh - debug_info->fdr;
560 register struct mdebug_pending *p;
562 /* Linear search is ok, list is typically no more than 10 deep */
563 for (p = pending_list[f_idx]; p; p = p->next)
569 /* Add a new symbol SH of type T */
572 add_pending (FDR *fh, char *sh, struct type *t)
574 int f_idx = fh - debug_info->fdr;
575 struct mdebug_pending *p = is_pending_symbol (fh, sh);
577 /* Make sure we do not make duplicates */
580 p = ((struct mdebug_pending *)
581 obstack_alloc (¤t_objfile->psymbol_obstack,
582 sizeof (struct mdebug_pending)));
585 p->next = pending_list[f_idx];
586 pending_list[f_idx] = p;
591 /* Parsing Routines proper. */
593 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
594 For blocks, procedures and types we open a new lexical context.
595 This is basically just a big switch on the symbol's type. Argument
596 AX is the base pointer of aux symbols for this file (fh->iauxBase).
597 EXT_SH points to the unswapped symbol, which is needed for struct,
598 union, etc., types; it is NULL for an EXTR. BIGEND says whether
599 aux symbols are big-endian or little-endian. Return count of
600 SYMR's handled (normally one). */
603 parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
604 struct section_offsets *section_offsets, struct objfile *objfile)
606 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
607 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
611 struct mdebug_pending *pend;
615 enum address_class class;
617 long svalue = sh->value;
620 if (ext_sh == (char *) NULL)
621 name = debug_info->ssext + sh->iss;
623 name = debug_info->ss + cur_fdr->issBase + sh->iss;
629 /* Do not relocate relative values.
630 The value of a stEnd symbol is the displacement from the
631 corresponding start symbol value.
632 The value of a stBlock symbol is the displacement from the
633 procedure address. */
634 if (sh->st != stEnd && sh->st != stBlock)
635 sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
642 sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
646 sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
655 case stGlobal: /* external symbol, goes into global block */
657 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
659 s = new_symbol (name);
660 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
663 case stStatic: /* static data, goes into current block. */
665 b = top_stack->cur_block;
666 s = new_symbol (name);
667 if (SC_IS_COMMON (sh->sc))
669 /* It is a FORTRAN common block. At least for SGI Fortran the
670 address is not in the symbol; we need to fix it later in
671 scan_file_globals. */
672 int bucket = hashname (SYMBOL_NAME (s));
673 SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
674 global_sym_chain[bucket] = s;
677 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
680 case stLocal: /* local variable, goes into current block */
681 if (sh->sc == scRegister)
683 class = LOC_REGISTER;
684 svalue = ECOFF_REG_TO_REGNUM (svalue);
688 b = top_stack->cur_block;
689 s = new_symbol (name);
690 SYMBOL_VALUE (s) = svalue;
692 data: /* Common code for symbols describing data */
693 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
694 SYMBOL_CLASS (s) = class;
697 /* Type could be missing if file is compiled without debugging info. */
698 if (SC_IS_UNDEF (sh->sc)
699 || sh->sc == scNil || sh->index == indexNil)
700 SYMBOL_TYPE (s) = nodebug_var_symbol_type;
702 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
703 /* Value of a data symbol is its memory address */
706 case stParam: /* arg to procedure, goes into current block */
708 found_ecoff_debugging_info = 1;
709 top_stack->numargs++;
711 /* Special GNU C++ name. */
712 if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0)
713 name = "this"; /* FIXME, not alloc'd in obstack */
714 s = new_symbol (name);
716 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
720 /* Pass by value in register. */
721 SYMBOL_CLASS (s) = LOC_REGPARM;
722 svalue = ECOFF_REG_TO_REGNUM (svalue);
725 /* Pass by reference on stack. */
726 SYMBOL_CLASS (s) = LOC_REF_ARG;
729 /* Pass by reference in register. */
730 SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
731 svalue = ECOFF_REG_TO_REGNUM (svalue);
734 /* Pass by value on stack. */
735 SYMBOL_CLASS (s) = LOC_ARG;
738 SYMBOL_VALUE (s) = svalue;
739 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
740 add_symbol (s, top_stack->cur_block);
743 case stLabel: /* label, goes into current block */
744 s = new_symbol (name);
745 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; /* so that it can be used */
746 SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused */
747 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
748 SYMBOL_TYPE (s) = mdebug_type_int;
749 add_symbol (s, top_stack->cur_block);
752 case stProc: /* Procedure, usually goes into global block */
753 case stStaticProc: /* Static procedure, goes into current block */
754 s = new_symbol (name);
755 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
756 SYMBOL_CLASS (s) = LOC_BLOCK;
757 /* Type of the return value */
758 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
762 t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
763 if (STREQ (name, "malloc") && TYPE_CODE (t) == TYPE_CODE_VOID)
765 /* I don't know why, but, at least under Alpha GNU/Linux,
766 when linking against a malloc without debugging
767 symbols, its read as a function returning void---this
768 is bad because it means we cannot call functions with
769 string arguments interactively; i.e., "call
770 printf("howdy\n")" would fail with the error message
771 "program has no memory available". To avoid this, we
772 patch up the type and make it void*
773 instead. (davidm@azstarnet.com)
775 t = make_pointer_type (t, NULL);
778 b = top_stack->cur_block;
779 if (sh->st == stProc)
781 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
782 /* The next test should normally be true, but provides a
783 hook for nested functions (which we don't want to make
785 if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
786 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
787 /* Irix 5 sometimes has duplicate names for the same
788 function. We want to add such names up at the global
789 level, not as a nested function. */
790 else if (sh->value == top_stack->procadr)
791 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
795 /* Make a type for the procedure itself */
796 SYMBOL_TYPE (s) = lookup_function_type (t);
798 /* Create and enter a new lexical context */
799 b = new_block (top_stack->maxsyms);
800 SYMBOL_BLOCK_VALUE (s) = b;
801 BLOCK_FUNCTION (b) = s;
802 BLOCK_START (b) = BLOCK_END (b) = sh->value;
803 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
804 add_block (b, top_stack->cur_st);
806 /* Not if we only have partial info */
807 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
811 top_stack->cur_block = b;
812 top_stack->blocktype = sh->st;
813 top_stack->cur_type = SYMBOL_TYPE (s);
814 top_stack->cur_field = -1;
815 top_stack->procadr = sh->value;
816 top_stack->numargs = 0;
819 /* Beginning of code for structure, union, and enum definitions.
820 They all share a common set of local variables, defined here. */
822 enum type_code type_code;
828 case stStruct: /* Start a block defining a struct type */
829 type_code = TYPE_CODE_STRUCT;
830 goto structured_common;
832 case stUnion: /* Start a block defining a union type */
833 type_code = TYPE_CODE_UNION;
834 goto structured_common;
836 case stEnum: /* Start a block defining an enum type */
837 type_code = TYPE_CODE_ENUM;
838 goto structured_common;
840 case stBlock: /* Either a lexical block, or some type */
841 if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc))
842 goto case_stBlock_code; /* Lexical block */
844 type_code = TYPE_CODE_UNDEF; /* We have a type. */
846 /* Common code for handling struct, union, enum, and/or as-yet-
847 unknown-type blocks of info about structured data. `type_code'
848 has been set to the proper TYPE_CODE, if we know it. */
850 found_ecoff_debugging_info = 1;
852 top_stack->blocktype = stBlock;
854 /* First count the number of fields and the highest value. */
857 for (ext_tsym = ext_sh + external_sym_size;
859 ext_tsym += external_sym_size)
863 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
871 if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
873 /* If the type of the member is Nil (or Void),
874 without qualifiers, assume the tag is an
876 Alpha cc -migrate enums are recognized by a zero
877 index and a zero symbol value.
878 DU 4.0 cc enums are recognized by a member type of
879 btEnum without qualifiers and a zero symbol value. */
880 if (tsym.index == indexNil
881 || (tsym.index == 0 && sh->value == 0))
882 type_code = TYPE_CODE_ENUM;
885 (*debug_swap->swap_tir_in) (bigend,
886 &ax[tsym.index].a_ti,
888 if ((tir.bt == btNil || tir.bt == btVoid
889 || (tir.bt == btEnum && sh->value == 0))
891 type_code = TYPE_CODE_ENUM;
895 if (tsym.value > max_value)
896 max_value = tsym.value;
905 /* This is a no-op; is it trying to tell us something
906 we should be checking? */
907 if (tsym.sc == scVariant); /*UNIMPLEMENTED */
911 /* This is something like a struct within a
912 struct. Skip over the fields of the inner
913 struct. The -1 is because the for loop will
914 increment ext_tsym. */
915 ext_tsym = ((char *) debug_info->external_sym
916 + ((cur_fdr->isymBase + tsym.index - 1)
917 * external_sym_size));
923 /* mips cc puts out a typedef for struct x if it is not yet
924 defined when it encounters
925 struct y { struct x *xp; };
930 /* Irix5 cc puts out a stIndirect for struct x if it is not
931 yet defined when it encounters
932 struct y { struct x *xp; };
937 complaint (&symfile_complaints,
938 "declaration block contains unhandled symbol type %d",
944 /* In an stBlock, there is no way to distinguish structs,
945 unions, and enums at this point. This is a bug in the
946 original design (that has been fixed with the recent
947 addition of the stStruct, stUnion, and stEnum symbol
948 types.) The way you can tell is if/when you see a variable
949 or field of that type. In that case the variable's type
950 (in the AUX table) says if the type is struct, union, or
951 enum, and points back to the stBlock here. So you can
952 patch the tag kind up later - but only if there actually is
953 a variable or field of that type.
955 So until we know for sure, we will guess at this point.
957 If the first member has index==indexNil or a void type,
958 assume we have an enumeration.
959 Otherwise, if there is more than one member, and all
960 the members have offset 0, assume we have a union.
961 Otherwise, assume we have a struct.
963 The heuristic could guess wrong in the case of of an
964 enumeration with no members or a union with one (or zero)
965 members, or when all except the last field of a struct have
966 width zero. These are uncommon and/or illegal situations,
967 and in any case guessing wrong probably doesn't matter
970 But if we later do find out we were wrong, we fixup the tag
971 kind. Members of an enumeration must be handled
972 differently from struct/union fields, and that is harder to
973 patch up, but luckily we shouldn't need to. (If there are
974 any enumeration members, we can tell for sure it's an enum
977 if (type_code == TYPE_CODE_UNDEF)
979 if (nfields > 1 && max_value == 0)
980 type_code = TYPE_CODE_UNION;
982 type_code = TYPE_CODE_STRUCT;
985 /* Create a new type or use the pending type. */
986 pend = is_pending_symbol (cur_fdr, ext_sh);
987 if (pend == (struct mdebug_pending *) NULL)
990 add_pending (cur_fdr, ext_sh, t);
995 /* Do not set the tag name if it is a compiler generated tag name
996 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
997 Alpha cc puts out an sh->iss of zero for those. */
998 if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
999 TYPE_TAG_NAME (t) = NULL;
1001 TYPE_TAG_NAME (t) = obconcat (¤t_objfile->symbol_obstack,
1004 TYPE_CODE (t) = type_code;
1005 TYPE_LENGTH (t) = sh->value;
1006 TYPE_NFIELDS (t) = nfields;
1007 TYPE_FIELDS (t) = f = ((struct field *)
1009 nfields * sizeof (struct field)));
1011 if (type_code == TYPE_CODE_ENUM)
1013 int unsigned_enum = 1;
1015 /* This is a non-empty enum. */
1017 /* DEC c89 has the number of enumerators in the sh.value field,
1018 not the type length, so we have to compensate for that
1019 incompatibility quirk.
1020 This might do the wrong thing for an enum with one or two
1021 enumerators and gcc -gcoff -fshort-enums, but these cases
1022 are hopefully rare enough.
1023 Alpha cc -migrate has a sh.value field of zero, we adjust
1025 if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
1026 || TYPE_LENGTH (t) == 0)
1027 TYPE_LENGTH (t) = TARGET_INT_BIT / HOST_CHAR_BIT;
1028 for (ext_tsym = ext_sh + external_sym_size;
1030 ext_tsym += external_sym_size)
1033 struct symbol *enum_sym;
1035 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
1037 if (tsym.st != stMember)
1040 FIELD_BITPOS (*f) = tsym.value;
1041 FIELD_TYPE (*f) = t;
1042 FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
1043 FIELD_BITSIZE (*f) = 0;
1044 FIELD_STATIC_KIND (*f) = 0;
1046 enum_sym = ((struct symbol *)
1047 obstack_alloc (¤t_objfile->symbol_obstack,
1048 sizeof (struct symbol)));
1049 memset (enum_sym, 0, sizeof (struct symbol));
1050 SYMBOL_NAME (enum_sym) =
1051 obsavestring (f->name, strlen (f->name),
1052 ¤t_objfile->symbol_obstack);
1053 SYMBOL_CLASS (enum_sym) = LOC_CONST;
1054 SYMBOL_TYPE (enum_sym) = t;
1055 SYMBOL_NAMESPACE (enum_sym) = VAR_NAMESPACE;
1056 SYMBOL_VALUE (enum_sym) = tsym.value;
1057 if (SYMBOL_VALUE (enum_sym) < 0)
1059 add_symbol (enum_sym, top_stack->cur_block);
1061 /* Skip the stMembers that we've handled. */
1066 TYPE_FLAGS (t) |= TYPE_FLAG_UNSIGNED;
1068 /* make this the current type */
1069 top_stack->cur_type = t;
1070 top_stack->cur_field = 0;
1072 /* Do not create a symbol for alpha cc unnamed structs. */
1076 /* gcc puts out an empty struct for an opaque struct definitions,
1077 do not create a symbol for it either. */
1078 if (TYPE_NFIELDS (t) == 0)
1080 TYPE_FLAGS (t) |= TYPE_FLAG_STUB;
1084 s = new_symbol (name);
1085 SYMBOL_NAMESPACE (s) = STRUCT_NAMESPACE;
1086 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1087 SYMBOL_VALUE (s) = 0;
1088 SYMBOL_TYPE (s) = t;
1089 add_symbol (s, top_stack->cur_block);
1092 /* End of local variables shared by struct, union, enum, and
1093 block (as yet unknown struct/union/enum) processing. */
1097 found_ecoff_debugging_info = 1;
1098 /* beginnning of (code) block. Value of symbol
1099 is the displacement from procedure start */
1100 push_parse_stack ();
1102 /* Do not start a new block if this is the outermost block of a
1103 procedure. This allows the LOC_BLOCK symbol to point to the
1104 block with the local variables, so funcname::var works. */
1105 if (top_stack->blocktype == stProc
1106 || top_stack->blocktype == stStaticProc)
1108 top_stack->blocktype = stNil;
1112 top_stack->blocktype = stBlock;
1113 b = new_block (top_stack->maxsyms);
1114 BLOCK_START (b) = sh->value + top_stack->procadr;
1115 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1116 top_stack->cur_block = b;
1117 add_block (b, top_stack->cur_st);
1120 case stEnd: /* end (of anything) */
1121 if (sh->sc == scInfo || SC_IS_COMMON (sh->sc))
1123 /* Finished with type */
1124 top_stack->cur_type = 0;
1126 else if (sh->sc == scText &&
1127 (top_stack->blocktype == stProc ||
1128 top_stack->blocktype == stStaticProc))
1130 /* Finished with procedure */
1131 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
1132 struct mips_extra_func_info *e;
1134 struct type *ftype = top_stack->cur_type;
1137 BLOCK_END (top_stack->cur_block) += sh->value; /* size */
1139 /* Make up special symbol to contain procedure specific info */
1140 s = new_symbol (MIPS_EFI_SYMBOL_NAME);
1141 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
1142 SYMBOL_CLASS (s) = LOC_CONST;
1143 SYMBOL_TYPE (s) = mdebug_type_void;
1144 e = ((struct mips_extra_func_info *)
1145 obstack_alloc (¤t_objfile->symbol_obstack,
1146 sizeof (struct mips_extra_func_info)));
1147 memset (e, 0, sizeof (struct mips_extra_func_info));
1148 SYMBOL_VALUE (s) = (long) e;
1149 e->numargs = top_stack->numargs;
1150 e->pdr.framereg = -1;
1151 add_symbol (s, top_stack->cur_block);
1153 /* Reallocate symbols, saving memory */
1154 b = shrink_block (top_stack->cur_block, top_stack->cur_st);
1156 /* f77 emits proc-level with address bounds==[0,0],
1157 So look for such child blocks, and patch them. */
1158 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
1160 struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
1161 if (BLOCK_SUPERBLOCK (b_bad) == b
1162 && BLOCK_START (b_bad) == top_stack->procadr
1163 && BLOCK_END (b_bad) == top_stack->procadr)
1165 BLOCK_START (b_bad) = BLOCK_START (b);
1166 BLOCK_END (b_bad) = BLOCK_END (b);
1170 if (TYPE_NFIELDS (ftype) <= 0)
1172 /* No parameter type information is recorded with the function's
1173 type. Set that from the type of the parameter symbols. */
1174 int nparams = top_stack->numargs;
1180 TYPE_NFIELDS (ftype) = nparams;
1181 TYPE_FIELDS (ftype) = (struct field *)
1182 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
1184 for (i = iparams = 0; iparams < nparams; i++)
1186 sym = BLOCK_SYM (b, i);
1187 switch (SYMBOL_CLASS (sym))
1192 case LOC_REGPARM_ADDR:
1193 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
1194 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
1204 else if (sh->sc == scText && top_stack->blocktype == stBlock)
1206 /* End of (code) block. The value of the symbol is the
1207 displacement from the procedure`s start address of the
1208 end of this block. */
1209 BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
1210 shrink_block (top_stack->cur_block, top_stack->cur_st);
1212 else if (sh->sc == scText && top_stack->blocktype == stNil)
1214 /* End of outermost block. Pop parse stack and ignore. The
1215 following stEnd of stProc will take care of the block. */
1218 else if (sh->sc == scText && top_stack->blocktype == stFile)
1220 /* End of file. Pop parse stack and ignore. Higher
1221 level code deals with this. */
1225 complaint (&symfile_complaints,
1226 "stEnd with storage class %d not handled", sh->sc);
1228 pop_parse_stack (); /* restore previous lexical context */
1231 case stMember: /* member of struct or union */
1232 f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
1233 FIELD_NAME (*f) = name;
1234 FIELD_BITPOS (*f) = sh->value;
1236 FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name);
1237 FIELD_BITSIZE (*f) = bitsize;
1238 FIELD_STATIC_KIND (*f) = 0;
1241 case stIndirect: /* forward declaration on Irix5 */
1242 /* Forward declarations from Irix5 cc are handled by cross_ref,
1246 case stTypedef: /* type definition */
1247 found_ecoff_debugging_info = 1;
1249 /* Typedefs for forward declarations and opaque structs from alpha cc
1250 are handled by cross_ref, skip them. */
1254 /* Parse the type or use the pending type. */
1255 pend = is_pending_symbol (cur_fdr, ext_sh);
1256 if (pend == (struct mdebug_pending *) NULL)
1258 t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name);
1259 add_pending (cur_fdr, ext_sh, t);
1264 /* mips cc puts out a typedef with the name of the struct for forward
1265 declarations. These should not go into the symbol table and
1266 TYPE_NAME should not be set for them.
1267 They can't be distinguished from an intentional typedef to
1268 the same name however:
1270 struct x { int ix; int jx; };
1274 struct xx {int ixx; int jxx; };
1275 generates a cross referencing stTypedef for x and xx.
1276 The user visible effect of this is that the type of a pointer
1277 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1278 The problem is fixed with alpha cc and Irix5 cc. */
1280 /* However if the typedef cross references to an opaque aggregate, it
1281 is safe to omit it from the symbol table. */
1283 if (has_opaque_xref (cur_fdr, sh))
1285 s = new_symbol (name);
1286 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
1287 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1288 SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
1289 SYMBOL_TYPE (s) = t;
1290 add_symbol (s, top_stack->cur_block);
1292 /* Incomplete definitions of structs should not get a name. */
1293 if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
1294 && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0
1295 || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT
1296 && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION)))
1298 if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR
1299 || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC)
1301 /* If we are giving a name to a type such as "pointer to
1302 foo" or "function returning foo", we better not set
1303 the TYPE_NAME. If the program contains "typedef char
1304 *caddr_t;", we don't want all variables of type char
1305 * to print as caddr_t. This is not just a
1306 consequence of GDB's type management; CC and GCC (at
1307 least through version 2.4) both output variables of
1308 either type char * or caddr_t with the type
1309 refering to the stTypedef symbol for caddr_t. If a future
1310 compiler cleans this up it GDB is not ready for it
1311 yet, but if it becomes ready we somehow need to
1312 disable this check (without breaking the PCC/GCC2.4
1317 Fortunately, this check seems not to be necessary
1318 for anything except pointers or functions. */
1321 TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_NAME (s);
1325 case stFile: /* file name */
1326 push_parse_stack ();
1327 top_stack->blocktype = sh->st;
1330 /* I`ve never seen these for C */
1332 break; /* register relocation */
1334 break; /* forwarding address */
1336 break; /* constant */
1338 complaint (&symfile_complaints, "unknown symbol type 0x%x", sh->st);
1345 /* Parse the type information provided in the raw AX entries for
1346 the symbol SH. Return the bitfield size in BS, in case.
1347 We must byte-swap the AX entries before we use them; BIGEND says whether
1348 they are big-endian or little-endian (from fh->fBigendian). */
1350 static struct type *
1351 parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
1352 int bigend, char *sym_name)
1354 /* Null entries in this map are treated specially */
1355 static struct type **map_bt[] =
1357 &mdebug_type_void, /* btNil */
1358 &mdebug_type_adr_32, /* btAdr */
1359 &mdebug_type_char, /* btChar */
1360 &mdebug_type_unsigned_char, /* btUChar */
1361 &mdebug_type_short, /* btShort */
1362 &mdebug_type_unsigned_short, /* btUShort */
1363 &mdebug_type_int_32, /* btInt */
1364 &mdebug_type_unsigned_int_32, /* btUInt */
1365 &mdebug_type_long_32, /* btLong */
1366 &mdebug_type_unsigned_long_32, /* btULong */
1367 &mdebug_type_float, /* btFloat */
1368 &mdebug_type_double, /* btDouble */
1375 &mdebug_type_complex, /* btComplex */
1376 &mdebug_type_double_complex, /* btDComplex */
1378 &mdebug_type_fixed_dec, /* btFixedDec */
1379 &mdebug_type_float_dec, /* btFloatDec */
1380 &mdebug_type_string, /* btString */
1383 &mdebug_type_void, /* btVoid */
1384 0, /* DEC C++: Pointer to member */
1385 0, /* DEC C++: Virtual function table */
1386 0, /* DEC C++: Class (Record) */
1387 &mdebug_type_long_64, /* btLong64 */
1388 &mdebug_type_unsigned_long_64, /* btULong64 */
1389 &mdebug_type_long_long_64, /* btLongLong64 */
1390 &mdebug_type_unsigned_long_long_64, /* btULongLong64 */
1391 &mdebug_type_adr_64, /* btAdr64 */
1392 &mdebug_type_int_64, /* btInt64 */
1393 &mdebug_type_unsigned_int_64, /* btUInt64 */
1397 struct type *tp = 0;
1398 enum type_code type_code = TYPE_CODE_UNDEF;
1400 /* Handle undefined types, they have indexNil. */
1401 if (aux_index == indexNil)
1402 return mdebug_type_int;
1404 /* Handle corrupt aux indices. */
1405 if (aux_index >= (debug_info->fdr + fd)->caux)
1407 index_complaint (sym_name);
1408 return mdebug_type_int;
1412 /* Use aux as a type information record, map its basic type. */
1413 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1414 if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt)))
1416 basic_type_complaint (t->bt, sym_name);
1417 return mdebug_type_int;
1421 tp = *map_bt[t->bt];
1426 /* Cannot use builtin types -- build our own */
1430 type_code = TYPE_CODE_STRUCT;
1433 type_code = TYPE_CODE_UNION;
1436 type_code = TYPE_CODE_ENUM;
1439 type_code = TYPE_CODE_RANGE;
1442 type_code = TYPE_CODE_SET;
1445 /* alpha cc -migrate uses this for typedefs. The true type will
1446 be obtained by crossreferencing below. */
1447 type_code = TYPE_CODE_ERROR;
1450 /* alpha cc uses this for typedefs. The true type will be
1451 obtained by crossreferencing below. */
1452 type_code = TYPE_CODE_ERROR;
1455 basic_type_complaint (t->bt, sym_name);
1456 return mdebug_type_int;
1460 /* Move on to next aux */
1465 int width = AUX_GET_WIDTH (bigend, ax);
1467 /* Inhibit core dumps with some cfront generated objects that
1469 if (bs == (int *) NULL)
1471 /* Alpha cc -migrate encodes char and unsigned char types
1472 as short and unsigned short types with a field width of 8.
1473 Enum types also have a field width which we ignore for now. */
1474 if (t->bt == btShort && width == 8)
1475 tp = mdebug_type_char;
1476 else if (t->bt == btUShort && width == 8)
1477 tp = mdebug_type_unsigned_char;
1478 else if (t->bt == btEnum)
1481 complaint (&symfile_complaints, "can't handle TIR fBitfield for %s",
1489 /* A btIndirect entry cross references to an aux entry containing
1491 if (t->bt == btIndirect)
1498 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
1500 if (rn->rfd == 0xfff)
1502 rf = AUX_GET_ISYM (bigend, ax);
1510 complaint (&symfile_complaints,
1511 "unable to cross ref btIndirect for %s", sym_name);
1512 return mdebug_type_int;
1514 xref_fh = get_rfd (fd, rf);
1515 xref_fd = xref_fh - debug_info->fdr;
1516 tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase,
1517 rn->index, (int *) NULL, xref_fh->fBigendian, sym_name);
1520 /* All these types really point to some (common) MIPS type
1521 definition, and only the type-qualifiers fully identify
1522 them. We'll make the same effort at sharing. */
1523 if (t->bt == btStruct ||
1527 /* btSet (I think) implies that the name is a tag name, not a typedef
1528 name. This apparently is a MIPS extension for C sets. */
1533 /* Try to cross reference this type, build new type on failure. */
1534 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1535 if (tp == (struct type *) NULL)
1536 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1538 /* DEC c89 produces cross references to qualified aggregate types,
1539 dereference them. */
1540 while (TYPE_CODE (tp) == TYPE_CODE_PTR
1541 || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
1542 tp = TYPE_TARGET_TYPE (tp);
1544 /* Make sure that TYPE_CODE(tp) has an expected type code.
1545 Any type may be returned from cross_ref if file indirect entries
1547 if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
1548 && TYPE_CODE (tp) != TYPE_CODE_UNION
1549 && TYPE_CODE (tp) != TYPE_CODE_ENUM)
1551 unexpected_type_code_complaint (sym_name);
1556 /* Usually, TYPE_CODE(tp) is already type_code. The main
1557 exception is if we guessed wrong re struct/union/enum.
1558 But for struct vs. union a wrong guess is harmless, so
1559 don't complain(). */
1560 if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
1561 && type_code != TYPE_CODE_ENUM)
1562 || (TYPE_CODE (tp) != TYPE_CODE_ENUM
1563 && type_code == TYPE_CODE_ENUM))
1565 bad_tag_guess_complaint (sym_name);
1568 if (TYPE_CODE (tp) != type_code)
1570 TYPE_CODE (tp) = type_code;
1573 /* Do not set the tag name if it is a compiler generated tag name
1574 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1575 if (name[0] == '.' || name[0] == '\0')
1576 TYPE_TAG_NAME (tp) = NULL;
1577 else if (TYPE_TAG_NAME (tp) == NULL
1578 || !STREQ (TYPE_TAG_NAME (tp), name))
1579 TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name),
1580 ¤t_objfile->type_obstack);
1584 /* All these types really point to some (common) MIPS type
1585 definition, and only the type-qualifiers fully identify
1586 them. We'll make the same effort at sharing.
1587 FIXME: We are not doing any guessing on range types. */
1588 if (t->bt == btRange)
1592 /* Try to cross reference this type, build new type on failure. */
1593 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1594 if (tp == (struct type *) NULL)
1595 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1597 /* Make sure that TYPE_CODE(tp) has an expected type code.
1598 Any type may be returned from cross_ref if file indirect entries
1600 if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
1602 unexpected_type_code_complaint (sym_name);
1606 /* Usually, TYPE_CODE(tp) is already type_code. The main
1607 exception is if we guessed wrong re struct/union/enum. */
1608 if (TYPE_CODE (tp) != type_code)
1610 bad_tag_guess_complaint (sym_name);
1611 TYPE_CODE (tp) = type_code;
1613 if (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name))
1614 TYPE_NAME (tp) = obsavestring (name, strlen (name),
1615 ¤t_objfile->type_obstack);
1618 if (t->bt == btTypedef)
1622 /* Try to cross reference this type, it should succeed. */
1623 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1624 if (tp == (struct type *) NULL)
1626 complaint (&symfile_complaints,
1627 "unable to cross ref btTypedef for %s", sym_name);
1628 tp = mdebug_type_int;
1632 /* Deal with range types */
1633 if (t->bt == btRange)
1635 TYPE_NFIELDS (tp) = 2;
1636 TYPE_FIELDS (tp) = ((struct field *)
1637 TYPE_ALLOC (tp, 2 * sizeof (struct field)));
1638 TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
1639 ¤t_objfile->type_obstack);
1640 TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
1642 TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
1643 ¤t_objfile->type_obstack);
1644 TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
1648 /* Parse all the type qualifiers now. If there are more
1649 than 6 the game will continue in the next aux */
1653 #define PARSE_TQ(tq) \
1654 if (t->tq != tqNil) \
1655 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1667 /* mips cc 2.x and gcc never put out continued aux entries. */
1671 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1675 /* Complain for illegal continuations due to corrupt aux entries. */
1677 complaint (&symfile_complaints, "illegal TIR continued for %s", sym_name);
1682 /* Make up a complex type from a basic one. Type is passed by
1683 reference in TPP and side-effected as necessary. The type
1684 qualifier TQ says how to handle the aux symbols at AX for
1685 the symbol SX we are currently analyzing. BIGEND says whether
1686 aux symbols are big-endian or little-endian.
1687 Returns the number of aux symbols we parsed. */
1690 upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
1696 /* Used in array processing */
1707 t = lookup_pointer_type (*tpp);
1712 t = lookup_function_type (*tpp);
1719 /* Determine and record the domain type (type of index) */
1720 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx);
1726 rf = AUX_GET_ISYM (bigend, ax);
1729 fh = get_rfd (fd, rf);
1731 indx = parse_type (fh - debug_info->fdr,
1732 debug_info->external_aux + fh->iauxBase,
1733 id, (int *) NULL, bigend, sym_name);
1735 /* The bounds type should be an integer type, but might be anything
1736 else due to corrupt aux entries. */
1737 if (TYPE_CODE (indx) != TYPE_CODE_INT)
1739 complaint (&symfile_complaints,
1740 "illegal array index type for %s, assuming int", sym_name);
1741 indx = mdebug_type_int;
1744 /* Get the bounds, and create the array type. */
1746 lower = AUX_GET_DNLOW (bigend, ax);
1748 upper = AUX_GET_DNHIGH (bigend, ax);
1750 rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */
1752 range = create_range_type ((struct type *) NULL, indx,
1755 t = create_array_type ((struct type *) NULL, *tpp, range);
1757 /* We used to fill in the supplied array element bitsize
1758 here if the TYPE_LENGTH of the target type was zero.
1759 This happens for a `pointer to an array of anonymous structs',
1760 but in this case the array element bitsize is also zero,
1761 so nothing is gained.
1762 And we used to check the TYPE_LENGTH of the target type against
1763 the supplied array element bitsize.
1764 gcc causes a mismatch for `pointer to array of object',
1765 since the sdb directives it uses do not have a way of
1766 specifying the bitsize, but it does no harm (the
1767 TYPE_LENGTH should be correct) and we should be able to
1768 ignore the erroneous bitsize from the auxiliary entry safely.
1769 dbx seems to ignore it too. */
1771 /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
1773 if (TYPE_LENGTH (*tpp) == 0)
1775 TYPE_FLAGS (t) |= TYPE_FLAG_TARGET_STUB;
1782 /* Volatile -- currently ignored */
1786 /* Const -- currently ignored */
1790 complaint (&symfile_complaints, "unknown type qualifier 0x%x", tq);
1796 /* Parse a procedure descriptor record PR. Note that the procedure is
1797 parsed _after_ the local symbols, now we just insert the extra
1798 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1799 already been placed in the procedure's main block. Note also that
1800 images that have been partially stripped (ld -x) have been deprived
1801 of local symbols, and we have to cope with them here. FIRST_OFF is
1802 the offset of the first procedure for this FDR; we adjust the
1803 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1804 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1805 in question, or NULL to use top_stack->cur_block. */
1807 static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *);
1810 parse_procedure (PDR *pr, struct symtab *search_symtab,
1811 struct partial_symtab *pst)
1813 struct symbol *s, *i;
1815 struct mips_extra_func_info *e;
1818 /* Simple rule to find files linked "-x" */
1819 if (cur_fdr->rss == -1)
1823 /* Static procedure at address pr->adr. Sigh. */
1824 /* FIXME-32x64. assuming pr->adr fits in long. */
1825 complaint (&symfile_complaints,
1826 "can't handle PDR for static proc at 0x%lx",
1827 (unsigned long) pr->adr);
1835 (*debug_swap->swap_ext_in) (cur_bfd,
1836 ((char *) debug_info->external_ext
1838 * debug_swap->external_ext_size)),
1840 sh_name = debug_info->ssext + she.asym.iss;
1848 (*debug_swap->swap_sym_in) (cur_bfd,
1849 ((char *) debug_info->external_sym
1850 + ((cur_fdr->isymBase + pr->isym)
1851 * debug_swap->external_sym_size)),
1853 sh_name = debug_info->ss + cur_fdr->issBase + sh.iss;
1856 if (search_symtab != NULL)
1859 /* This loses both in the case mentioned (want a static, find a global),
1860 but also if we are looking up a non-mangled name which happens to
1861 match the name of a mangled function. */
1862 /* We have to save the cur_fdr across the call to lookup_symbol.
1863 If the pdr is for a static function and if a global function with
1864 the same name exists, lookup_symbol will eventually read in the symtab
1865 for the global function and clobber cur_fdr. */
1866 FDR *save_cur_fdr = cur_fdr;
1867 s = lookup_symbol (sh_name, NULL, VAR_NAMESPACE, 0, NULL);
1868 cur_fdr = save_cur_fdr;
1872 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
1878 s = mylookup_symbol (sh_name, top_stack->cur_block,
1879 VAR_NAMESPACE, LOC_BLOCK);
1883 b = SYMBOL_BLOCK_VALUE (s);
1887 complaint (&symfile_complaints, "PDR for %s, but no symbol", sh_name);
1891 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1892 s = new_symbol (sh_name);
1893 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
1894 SYMBOL_CLASS (s) = LOC_BLOCK;
1895 /* Donno its type, hope int is ok */
1896 SYMBOL_TYPE (s) = lookup_function_type (mdebug_type_int);
1897 add_symbol (s, top_stack->cur_block);
1898 /* Wont have symbols for this one */
1900 SYMBOL_BLOCK_VALUE (s) = b;
1901 BLOCK_FUNCTION (b) = s;
1902 BLOCK_START (b) = pr->adr;
1903 /* BOUND used to be the end of procedure's text, but the
1904 argument is no longer passed in. */
1905 BLOCK_END (b) = bound;
1906 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1907 add_block (b, top_stack->cur_st);
1911 i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, LOC_CONST);
1915 e = (struct mips_extra_func_info *) SYMBOL_VALUE (i);
1917 e->pdr.isym = (long) s;
1919 /* GDB expects the absolute function start address for the
1920 procedure descriptor in e->pdr.adr.
1921 As the address in the procedure descriptor is usually relative,
1922 we would have to relocate e->pdr.adr with cur_fdr->adr and
1923 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
1924 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
1925 in shared libraries on some systems, and on other systems
1926 e->pdr.adr is sometimes offset by a bogus value.
1927 To work around these problems, we replace e->pdr.adr with
1928 the start address of the function. */
1929 e->pdr.adr = BLOCK_START (b);
1931 /* Correct incorrect setjmp procedure descriptor from the library
1932 to make backtrace through setjmp work. */
1933 if (e->pdr.pcreg == 0 && STREQ (sh_name, "setjmp"))
1935 complaint (&symfile_complaints, "fixing bad setjmp PDR from libc");
1936 e->pdr.pcreg = RA_REGNUM;
1937 e->pdr.regmask = 0x80000000;
1938 e->pdr.regoffset = -4;
1942 /* It would be reasonable that functions that have been compiled
1943 without debugging info have a btNil type for their return value,
1944 and functions that are void and are compiled with debugging info
1946 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
1947 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
1949 The glevel field in cur_fdr could be used to determine the presence
1950 of debugging info, but GCC doesn't always pass the -g switch settings
1951 to the assembler and GAS doesn't set the glevel field from the -g switch
1953 To work around these problems, the return value type of a TYPE_CODE_VOID
1954 function is adjusted accordingly if no debugging info was found in the
1955 compilation unit. */
1957 if (processing_gcc_compilation == 0
1958 && found_ecoff_debugging_info == 0
1959 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
1960 SYMBOL_TYPE (s) = nodebug_func_symbol_type;
1963 /* Relocate the extra function info pointed to by the symbol table. */
1966 ecoff_relocate_efi (struct symbol *sym, CORE_ADDR delta)
1968 struct mips_extra_func_info *e;
1970 e = (struct mips_extra_func_info *) SYMBOL_VALUE (sym);
1972 e->pdr.adr += delta;
1975 /* Parse the external symbol ES. Just call parse_symbol() after
1976 making sure we know where the aux are for it.
1977 BIGEND says whether aux entries are big-endian or little-endian.
1979 This routine clobbers top_stack->cur_block and ->cur_st. */
1981 static void parse_external (EXTR *, int, struct section_offsets *,
1985 parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
1986 struct objfile *objfile)
1990 if (es->ifd != ifdNil)
1993 cur_fdr = debug_info->fdr + cur_fd;
1994 ax = debug_info->external_aux + cur_fdr->iauxBase;
1998 cur_fdr = debug_info->fdr;
2002 /* Reading .o files */
2003 if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil)
2006 switch (es->asym.st)
2009 /* These are generated for static symbols in .o files,
2030 /* FIXME: Turn this into a complaint? */
2032 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
2033 what, debug_info->ssext + es->asym.iss,
2034 fdr_name (cur_fdr));
2038 switch (es->asym.st)
2042 /* There is no need to parse the external procedure symbols.
2043 If they are from objects compiled without -g, their index will
2044 be indexNil, and the symbol definition from the minimal symbol
2045 is preferrable (yielding a function returning int instead of int).
2046 If the index points to a local procedure symbol, the local
2047 symbol already provides the correct type.
2048 Note that the index of the external procedure symbol points
2049 to the local procedure symbol in the local symbol table, and
2050 _not_ to the auxiliary symbol info. */
2054 /* Global common symbols are resolved by the runtime loader,
2056 if (SC_IS_COMMON (es->asym.sc))
2059 /* Note that the case of a symbol with indexNil must be handled
2060 anyways by parse_symbol(). */
2061 parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets, objfile);
2068 /* Parse the line number info for file descriptor FH into
2069 GDB's linetable LT. MIPS' encoding requires a little bit
2070 of magic to get things out. Note also that MIPS' line
2071 numbers can go back and forth, apparently we can live
2072 with that and do not need to reorder our linetables */
2074 static void parse_lines (FDR *, PDR *, struct linetable *, int,
2075 struct partial_symtab *, CORE_ADDR);
2078 parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
2079 struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr)
2081 unsigned char *base;
2083 int delta, count, lineno = 0;
2085 if (fh->cbLine == 0)
2088 /* Scan by procedure descriptors */
2090 for (j = 0; j < fh->cpd; j++, pr++)
2094 unsigned char *halt;
2096 /* No code for this one */
2097 if (pr->iline == ilineNil ||
2098 pr->lnLow == -1 || pr->lnHigh == -1)
2101 /* Determine start and end address of compressed line bytes for
2103 base = debug_info->line + fh->cbLineOffset;
2104 if (j != (fh->cpd - 1))
2105 halt = base + pr[1].cbLineOffset;
2107 halt = base + fh->cbLine;
2108 base += pr->cbLineOffset;
2110 adr = pst->textlow + pr->adr - lowest_pdr_addr;
2112 l = adr >> 2; /* in words */
2113 for (lineno = pr->lnLow; base < halt;)
2115 count = *base & 0x0f;
2116 delta = *base++ >> 4;
2121 delta = (base[0] << 8) | base[1];
2122 if (delta >= 0x8000)
2126 lineno += delta; /* first delta is 0 */
2128 /* Complain if the line table overflows. Could happen
2129 with corrupt binaries. */
2130 if (lt->nitems >= maxlines)
2132 complaint (&symfile_complaints,
2133 "guessed size of linetable for %s incorrectly",
2137 k = add_line (lt, lineno, l, k);
2144 function_outside_compilation_unit_complaint (const char *arg1)
2146 complaint (&symfile_complaints,
2147 "function `%s' appears to be defined outside of all compilation units",
2151 /* Master parsing procedure for first-pass reading of file symbols
2152 into a partial_symtab. */
2155 parse_partial_symbols (struct objfile *objfile)
2157 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
2158 const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
2159 const bfd_size_type external_ext_size = debug_swap->external_ext_size;
2160 void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in;
2161 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
2162 void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in;
2164 HDRR *hdr = &debug_info->symbolic_header;
2165 /* Running pointers */
2170 register EXTR *ext_in;
2173 struct partial_symtab *pst;
2174 int textlow_not_set = 1;
2175 int past_first_source_file = 0;
2177 /* List of current psymtab's include files */
2178 char **psymtab_include_list;
2179 int includes_allocated;
2182 struct pst_map *fdr_to_pst;
2183 /* Index within current psymtab dependency list */
2184 struct partial_symtab **dependency_list;
2185 int dependencies_used, dependencies_allocated;
2186 struct cleanup *old_chain;
2188 enum language prev_language;
2189 asection *text_sect;
2190 int relocatable = 0;
2192 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2193 the shared libraries are prelinked at a high memory address.
2194 We have to adjust the start address of the object file for this case,
2195 by setting it to the start address of the first procedure in the file.
2196 But we should do no adjustments if we are debugging a .o file, where
2197 the text section (and fh->adr) really starts at zero. */
2198 text_sect = bfd_get_section_by_name (cur_bfd, ".text");
2199 if (text_sect != NULL
2200 && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
2203 extern_tab = (EXTR *) obstack_alloc (&objfile->psymbol_obstack,
2204 sizeof (EXTR) * hdr->iextMax);
2206 includes_allocated = 30;
2208 psymtab_include_list = (char **) alloca (includes_allocated *
2210 next_symbol_text_func = mdebug_next_symbol_text;
2212 dependencies_allocated = 30;
2213 dependencies_used = 0;
2215 (struct partial_symtab **) alloca (dependencies_allocated *
2216 sizeof (struct partial_symtab *));
2218 last_source_file = NULL;
2223 * Only parse the Local and External symbols, and the Relative FDR.
2224 * Fixup enough of the loader symtab to be able to use it.
2225 * Allocate space only for the file's portions we need to
2230 max_glevel = MIN_GLEVEL;
2232 /* Allocate the map FDR -> PST.
2233 Minor hack: -O3 images might claim some global data belongs
2234 to FDR -1. We`ll go along with that */
2235 fdr_to_pst = (struct pst_map *) xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
2236 old_chain = make_cleanup (xfree, fdr_to_pst);
2239 struct partial_symtab *pst = new_psymtab ("", objfile);
2240 fdr_to_pst[-1].pst = pst;
2244 /* Allocate the global pending list. */
2246 ((struct mdebug_pending **)
2247 obstack_alloc (&objfile->psymbol_obstack,
2248 hdr->ifdMax * sizeof (struct mdebug_pending *)));
2249 memset (pending_list, 0,
2250 hdr->ifdMax * sizeof (struct mdebug_pending *));
2252 /* Pass 0 over external syms: swap them in. */
2253 ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
2254 make_cleanup (xfree, ext_block);
2256 ext_out = (char *) debug_info->external_ext;
2257 ext_out_end = ext_out + hdr->iextMax * external_ext_size;
2259 for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
2260 (*swap_ext_in) (cur_bfd, ext_out, ext_in);
2262 /* Pass 1 over external syms: Presize and partition the list */
2264 ext_in_end = ext_in + hdr->iextMax;
2265 for (; ext_in < ext_in_end; ext_in++)
2267 /* See calls to complain below. */
2268 if (ext_in->ifd >= -1
2269 && ext_in->ifd < hdr->ifdMax
2270 && ext_in->asym.iss >= 0
2271 && ext_in->asym.iss < hdr->issExtMax)
2272 fdr_to_pst[ext_in->ifd].n_globals++;
2275 /* Pass 1.5 over files: partition out global symbol space */
2277 for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++)
2279 fdr_to_pst[f_idx].globals_offset = s_idx;
2280 s_idx += fdr_to_pst[f_idx].n_globals;
2281 fdr_to_pst[f_idx].n_globals = 0;
2286 For ECOFF in ELF, we skip the creation of the minimal symbols.
2287 The ECOFF symbols should be a subset of the Elf symbols, and the
2288 section information of the elf symbols will be more accurate.
2289 FIXME! What about Irix 5's native linker?
2291 By default, Elf sections which don't exist in ECOFF
2292 get put in ECOFF's absolute section by the gnu linker.
2293 Since absolute sections don't get relocated, we
2294 end up calculating an address different from that of
2295 the symbol's minimal symbol (created earlier from the
2298 To fix this, either :
2299 1) don't create the duplicate symbol
2300 (assumes ECOFF symtab is a subset of the ELF symtab;
2301 assumes no side-effects result from ignoring ECOFF symbol)
2302 2) create it, only if lookup for existing symbol in ELF's minimal
2305 assumes no side-effects result from ignoring ECOFF symbol)
2306 3) create it, but lookup ELF's minimal symbol and use it's section
2307 during relocation, then modify "uniqify" phase to merge and
2308 eliminate the duplicate symbol
2309 (highly inefficient)
2311 I've implemented #1 here...
2312 Skip the creation of the minimal symbols based on the ECOFF
2315 /* Pass 2 over external syms: fill in external symbols */
2317 ext_in_end = ext_in + hdr->iextMax;
2318 for (; ext_in < ext_in_end; ext_in++)
2320 enum minimal_symbol_type ms_type = mst_text;
2321 CORE_ADDR svalue = ext_in->asym.value;
2323 /* The Irix 5 native tools seem to sometimes generate bogus
2324 external symbols. */
2325 if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
2327 complaint (&symfile_complaints,
2328 "bad ifd for external symbol: %d (max %ld)", ext_in->ifd,
2332 if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
2334 complaint (&symfile_complaints,
2335 "bad iss for external symbol: %ld (max %ld)",
2336 ext_in->asym.iss, hdr->issExtMax);
2340 extern_tab[fdr_to_pst[ext_in->ifd].globals_offset
2341 + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in;
2344 if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil)
2348 /* Pass 3 over files, over local syms: fill in static symbols */
2349 name = debug_info->ssext + ext_in->asym.iss;
2351 /* Process ECOFF Symbol Types and Storage Classes */
2352 switch (ext_in->asym.st)
2355 /* Beginnning of Procedure */
2356 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2359 /* Load time only static procs */
2360 ms_type = mst_file_text;
2361 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2364 /* External symbol */
2365 if (SC_IS_COMMON (ext_in->asym.sc))
2367 /* The value of a common symbol is its size, not its address.
2371 else if (SC_IS_DATA (ext_in->asym.sc))
2374 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2376 else if (SC_IS_BSS (ext_in->asym.sc))
2379 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2381 else if (SC_IS_SBSS (ext_in->asym.sc))
2384 svalue += ANOFFSET (objfile->section_offsets,
2385 get_section_index (objfile, ".sbss"));
2393 /* On certain platforms, some extra label symbols can be
2394 generated by the linker. One possible usage for this kind
2395 of symbols is to represent the address of the begining of a
2396 given section. For instance, on Tru64 5.1, the address of
2397 the _ftext label is the start address of the .text section.
2399 The storage class of these symbols is usually directly
2400 related to the section to which the symbol refers. For
2401 instance, on Tru64 5.1, the storage class for the _fdata
2402 label is scData, refering to the .data section.
2404 It is actually possible that the section associated to the
2405 storage class of the label does not exist. On True64 5.1
2406 for instance, the libm.so shared library does not contain
2407 any .data section, although it contains a _fpdata label
2408 which storage class is scData... Since these symbols are
2409 usually useless for the debugger user anyway, we just
2410 discard these symbols.
2413 if (SC_IS_TEXT (ext_in->asym.sc))
2415 if (objfile->sect_index_text == -1)
2418 ms_type = mst_file_text;
2419 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2421 else if (SC_IS_DATA (ext_in->asym.sc))
2423 if (objfile->sect_index_data == -1)
2426 ms_type = mst_file_data;
2427 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2429 else if (SC_IS_BSS (ext_in->asym.sc))
2431 if (objfile->sect_index_bss == -1)
2434 ms_type = mst_file_bss;
2435 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2437 else if (SC_IS_SBSS (ext_in->asym.sc))
2439 const int sbss_sect_index = get_section_index (objfile, ".sbss");
2441 if (sbss_sect_index == -1)
2444 ms_type = mst_file_bss;
2445 svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index);
2452 /* The alpha has the section start addresses in stLocal symbols
2453 whose name starts with a `.'. Skip those but complain for all
2454 other stLocal symbols.
2455 Irix6 puts the section start addresses in stNil symbols, skip
2461 ms_type = mst_unknown;
2462 unknown_ext_complaint (name);
2464 if (!ECOFF_IN_ELF (cur_bfd))
2465 prim_record_minimal_symbol (name, svalue, ms_type, objfile);
2468 /* Pass 3 over files, over local syms: fill in static symbols */
2469 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
2471 struct partial_symtab *save_pst;
2475 cur_fdr = fh = debug_info->fdr + f_idx;
2479 fdr_to_pst[f_idx].pst = NULL;
2483 /* Determine the start address for this object file from the
2484 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2488 if (relocatable || textlow != 0)
2489 textlow += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2493 pst = start_psymtab_common (objfile, objfile->section_offsets,
2496 objfile->global_psymbols.next,
2497 objfile->static_psymbols.next);
2498 pst->read_symtab_private = ((char *)
2499 obstack_alloc (&objfile->psymbol_obstack,
2500 sizeof (struct symloc)));
2501 memset (pst->read_symtab_private, 0, sizeof (struct symloc));
2504 FDR_IDX (pst) = f_idx;
2505 CUR_BFD (pst) = cur_bfd;
2506 DEBUG_SWAP (pst) = debug_swap;
2507 DEBUG_INFO (pst) = debug_info;
2508 PENDING_LIST (pst) = pending_list;
2510 /* The way to turn this into a symtab is to call... */
2511 pst->read_symtab = mdebug_psymtab_to_symtab;
2513 /* Set up language for the pst.
2514 The language from the FDR is used if it is unambigious (e.g. cfront
2515 with native cc and g++ will set the language to C).
2516 Otherwise we have to deduce the language from the filename.
2517 Native ecoff has every header file in a separate FDR, so
2518 deduce_language_from_filename will return language_unknown for
2519 a header file, which is not what we want.
2520 But the FDRs for the header files are after the FDR for the source
2521 file, so we can assign the language of the source file to the
2522 following header files. Then we save the language in the private
2523 pst data so that we can reuse it when building symtabs. */
2524 prev_language = psymtab_language;
2528 case langCplusplusV2:
2529 psymtab_language = language_cplus;
2532 psymtab_language = deduce_language_from_filename (fdr_name (fh));
2535 if (psymtab_language == language_unknown)
2536 psymtab_language = prev_language;
2537 PST_PRIVATE (pst)->pst_language = psymtab_language;
2539 pst->texthigh = pst->textlow;
2541 /* For stabs-in-ecoff files, the second symbol must be @stab.
2542 This symbol is emitted by mips-tfile to signal that the
2543 current object file uses encapsulated stabs instead of mips
2544 ecoff for local symbols. (It is the second symbol because
2545 the first symbol is the stFile used to signal the start of a
2547 processing_gcc_compilation = 0;
2550 (*swap_sym_in) (cur_bfd,
2551 ((char *) debug_info->external_sym
2552 + (fh->isymBase + 1) * external_sym_size),
2554 if (STREQ (debug_info->ss + fh->issBase + sh.iss, stabs_symbol))
2555 processing_gcc_compilation = 2;
2558 if (processing_gcc_compilation != 0)
2560 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
2565 (*swap_sym_in) (cur_bfd,
2566 (((char *) debug_info->external_sym)
2567 + (fh->isymBase + cur_sdx) * external_sym_size),
2569 type_code = ECOFF_UNMARK_STAB (sh.index);
2570 if (!ECOFF_IS_STAB (&sh))
2572 if (sh.st == stProc || sh.st == stStaticProc)
2577 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2578 if (sh.st == stStaticProc)
2580 namestring = debug_info->ss + fh->issBase + sh.iss;
2581 prim_record_minimal_symbol_and_info (namestring,
2585 SECT_OFF_TEXT (objfile),
2589 procaddr = sh.value;
2591 isym = AUX_GET_ISYM (fh->fBigendian,
2592 (debug_info->external_aux
2595 (*swap_sym_in) (cur_bfd,
2596 ((char *) debug_info->external_sym
2597 + ((fh->isymBase + isym - 1)
2598 * external_sym_size)),
2602 CORE_ADDR high = procaddr + sh.value;
2604 /* Kludge for Irix 5.2 zero fh->adr. */
2606 && (pst->textlow == 0 || procaddr < pst->textlow))
2607 pst->textlow = procaddr;
2608 if (high > pst->texthigh)
2609 pst->texthigh = high;
2612 else if (sh.st == stStatic)
2627 namestring = debug_info->ss + fh->issBase + sh.iss;
2628 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2629 prim_record_minimal_symbol_and_info (namestring,
2633 SECT_OFF_DATA (objfile),
2639 /* FIXME! Shouldn't this use cases for bss,
2640 then have the default be abs? */
2641 namestring = debug_info->ss + fh->issBase + sh.iss;
2642 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2643 prim_record_minimal_symbol_and_info (namestring,
2647 SECT_OFF_BSS (objfile),
2655 /* Handle stabs continuation */
2657 char *stabstring = debug_info->ss + fh->issBase + sh.iss;
2658 int len = strlen (stabstring);
2659 while (stabstring[len - 1] == '\\')
2662 char *stabstring1 = stabstring;
2666 /* Ignore continuation char from 1st string */
2669 /* Read next stabstring */
2671 (*swap_sym_in) (cur_bfd,
2672 (((char *) debug_info->external_sym)
2673 + (fh->isymBase + cur_sdx)
2674 * external_sym_size),
2676 stabstring2 = debug_info->ss + fh->issBase + sh2.iss;
2677 len2 = strlen (stabstring2);
2679 /* Concatinate stabstring2 with stabstring1 */
2681 && stabstring != debug_info->ss + fh->issBase + sh.iss)
2682 stabstring = xrealloc (stabstring, len + len2 + 1);
2685 stabstring = xmalloc (len + len2 + 1);
2686 strcpy (stabstring, stabstring1);
2688 strcpy (stabstring + len, stabstring2);
2696 * Standard, external, non-debugger, symbols
2699 case N_TEXT | N_EXT:
2700 case N_NBTEXT | N_EXT:
2701 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2704 case N_DATA | N_EXT:
2705 case N_NBDATA | N_EXT:
2706 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2711 case N_NBBSS | N_EXT:
2712 case N_SETV | N_EXT: /* FIXME, is this in BSS? */
2713 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2720 /* Standard, local, non-debugger, symbols */
2724 /* We need to be able to deal with both N_FN or N_TEXT,
2725 because we have no way of knowing whether the sys-supplied ld
2726 or GNU ld was used to make the executable. Sequents throw
2727 in another wrinkle -- they renumbered N_FN. */
2735 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2738 case N_UNDF | N_EXT:
2739 continue; /* Just undefined, not COMMON */
2744 /* Lots of symbol types we can just ignore. */
2751 /* Keep going . . . */
2754 * Special symbol types for GNU
2757 case N_INDR | N_EXT:
2759 case N_SETA | N_EXT:
2761 case N_SETT | N_EXT:
2763 case N_SETD | N_EXT:
2765 case N_SETB | N_EXT:
2776 static int prev_so_symnum = -10;
2777 static int first_so_symnum;
2779 int prev_textlow_not_set;
2781 valu = sh.value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2783 prev_textlow_not_set = textlow_not_set;
2785 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2786 /* A zero value is probably an indication for the SunPRO 3.0
2787 compiler. end_psymtab explicitly tests for zero, so
2788 don't relocate it. */
2792 textlow_not_set = 1;
2796 textlow_not_set = 0;
2798 textlow_not_set = 0;
2800 past_first_source_file = 1;
2802 if (prev_so_symnum != symnum - 1)
2803 { /* Here if prev stab wasn't N_SO */
2804 first_so_symnum = symnum;
2808 pst = (struct partial_symtab *) 0;
2810 dependencies_used = 0;
2814 prev_so_symnum = symnum;
2816 /* End the current partial symtab and start a new one */
2818 /* SET_NAMESTRING ();*/
2819 namestring = stabstring;
2821 /* Null name means end of .o file. Don't start a new one. */
2822 if (*namestring == '\000')
2825 /* Some compilers (including gcc) emit a pair of initial N_SOs.
2826 The first one is a directory name; the second the file name.
2827 If pst exists, is empty, and has a filename ending in '/',
2828 we assume the previous N_SO was a directory name. */
2830 p = strrchr (namestring, '/');
2831 if (p && *(p + 1) == '\000')
2832 continue; /* Simply ignore directory name SOs */
2834 /* Some other compilers (C++ ones in particular) emit useless
2835 SOs for non-existant .c files. We ignore all subsequent SOs that
2836 immediately follow the first. */
2848 enum language tmp_language;
2849 /* Mark down an include file in the current psymtab */
2851 /* SET_NAMESTRING ();*/
2852 namestring = stabstring;
2854 tmp_language = deduce_language_from_filename (namestring);
2856 /* Only change the psymtab's language if we've learned
2857 something useful (eg. tmp_language is not language_unknown).
2858 In addition, to match what start_subfile does, never change
2860 if (tmp_language != language_unknown
2861 && (tmp_language != language_c
2862 || psymtab_language != language_cplus))
2863 psymtab_language = tmp_language;
2865 /* In C++, one may expect the same filename to come round many
2866 times, when code is coming alternately from the main file
2867 and from inline functions in other files. So I check to see
2868 if this is a file we've seen before -- either the main
2869 source file, or a previously included file.
2871 This seems to be a lot of time to be spending on N_SOL, but
2872 things like "break c-exp.y:435" need to work (I
2873 suppose the psymtab_include_list could be hashed or put
2874 in a binary tree, if profiling shows this is a major hog). */
2875 if (pst && STREQ (namestring, pst->filename))
2879 for (i = 0; i < includes_used; i++)
2880 if (STREQ (namestring, psymtab_include_list[i]))
2889 psymtab_include_list[includes_used++] = namestring;
2890 if (includes_used >= includes_allocated)
2892 char **orig = psymtab_include_list;
2894 psymtab_include_list = (char **)
2895 alloca ((includes_allocated *= 2) *
2897 memcpy ((PTR) psymtab_include_list, (PTR) orig,
2898 includes_used * sizeof (char *));
2902 case N_LSYM: /* Typedef or automatic variable. */
2903 case N_STSYM: /* Data seg var -- static */
2904 case N_LCSYM: /* BSS " */
2905 case N_ROSYM: /* Read-only data seg var -- static. */
2906 case N_NBSTS: /* Gould nobase. */
2907 case N_NBLCS: /* symbols. */
2909 case N_GSYM: /* Global (extern) variable; can be
2910 data or bss (sigh FIXME). */
2912 /* Following may probably be ignored; I'll leave them here
2913 for now (until I do Pascal and Modula 2 extensions). */
2915 case N_PC: /* I may or may not need this; I
2917 case N_M2C: /* I suspect that I can ignore this here. */
2918 case N_SCOPE: /* Same. */
2920 /* SET_NAMESTRING ();*/
2921 namestring = stabstring;
2922 p = (char *) strchr (namestring, ':');
2924 continue; /* Not a debugging symbol. */
2928 /* Main processing section for debugging symbols which
2929 the initial read through the symbol tables needs to worry
2930 about. If we reach this point, the symbol which we are
2931 considering is definitely one we are interested in.
2932 p must also contain the (valid) index into the namestring
2933 which indicates the debugging type symbol. */
2938 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2939 #ifdef STATIC_TRANSFORM_NAME
2940 namestring = STATIC_TRANSFORM_NAME (namestring);
2942 add_psymbol_to_list (namestring, p - namestring,
2943 VAR_NAMESPACE, LOC_STATIC,
2944 &objfile->static_psymbols,
2946 psymtab_language, objfile);
2949 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2950 /* The addresses in these entries are reported to be
2951 wrong. See the code that reads 'G's for symtabs. */
2952 add_psymbol_to_list (namestring, p - namestring,
2953 VAR_NAMESPACE, LOC_STATIC,
2954 &objfile->global_psymbols,
2956 psymtab_language, objfile);
2960 /* When a 'T' entry is defining an anonymous enum, it
2961 may have a name which is the empty string, or a
2962 single space. Since they're not really defining a
2963 symbol, those shouldn't go in the partial symbol
2964 table. We do pick up the elements of such enums at
2965 'check_enum:', below. */
2966 if (p >= namestring + 2
2967 || (p == namestring + 1
2968 && namestring[0] != ' '))
2970 add_psymbol_to_list (namestring, p - namestring,
2971 STRUCT_NAMESPACE, LOC_TYPEDEF,
2972 &objfile->static_psymbols,
2974 psymtab_language, objfile);
2977 /* Also a typedef with the same name. */
2978 add_psymbol_to_list (namestring, p - namestring,
2979 VAR_NAMESPACE, LOC_TYPEDEF,
2980 &objfile->static_psymbols,
2982 psymtab_language, objfile);
2985 /* The semantics of C++ state that "struct foo { ... }"
2986 also defines a typedef for "foo". Unfortuantely, cfront
2987 never makes the typedef when translating from C++ to C.
2988 We make the typedef here so that "ptype foo" works as
2989 expected for cfront translated code. */
2990 else if (psymtab_language == language_cplus)
2992 /* Also a typedef with the same name. */
2993 add_psymbol_to_list (namestring, p - namestring,
2994 VAR_NAMESPACE, LOC_TYPEDEF,
2995 &objfile->static_psymbols,
2997 psymtab_language, objfile);
3002 if (p != namestring) /* a name is there, not just :T... */
3004 add_psymbol_to_list (namestring, p - namestring,
3005 VAR_NAMESPACE, LOC_TYPEDEF,
3006 &objfile->static_psymbols,
3008 psymtab_language, objfile);
3011 /* If this is an enumerated type, we need to
3012 add all the enum constants to the partial symbol
3013 table. This does not cover enums without names, e.g.
3014 "enum {a, b} c;" in C, but fortunately those are
3015 rare. There is no way for GDB to find those from the
3016 enum type without spending too much time on it. Thus
3017 to solve this problem, the compiler needs to put out the
3018 enum in a nameless type. GCC2 does this. */
3020 /* We are looking for something of the form
3021 <name> ":" ("t" | "T") [<number> "="] "e"
3022 {<constant> ":" <value> ","} ";". */
3024 /* Skip over the colon and the 't' or 'T'. */
3026 /* This type may be given a number. Also, numbers can come
3027 in pairs like (0,26). Skip over it. */
3028 while ((*p >= '0' && *p <= '9')
3029 || *p == '(' || *p == ',' || *p == ')'
3035 /* The aix4 compiler emits extra crud before the members. */
3038 /* Skip over the type (?). */
3042 /* Skip over the colon. */
3046 /* We have found an enumerated type. */
3047 /* According to comments in read_enum_type
3048 a comma could end it instead of a semicolon.
3049 I don't know where that happens.
3051 while (*p && *p != ';' && *p != ',')
3055 /* Check for and handle cretinous dbx symbol name
3057 if (*p == '\\' || (*p == '?' && p[1] == '\0'))
3058 p = next_symbol_text (objfile);
3060 /* Point to the character after the name
3061 of the enum constant. */
3062 for (q = p; *q && *q != ':'; q++)
3064 /* Note that the value doesn't matter for
3065 enum constants in psymtabs, just in symtabs. */
3066 add_psymbol_to_list (p, q - p,
3067 VAR_NAMESPACE, LOC_CONST,
3068 &objfile->static_psymbols, 0,
3069 0, psymtab_language, objfile);
3070 /* Point past the name. */
3072 /* Skip over the value. */
3073 while (*p && *p != ',')
3075 /* Advance past the comma. */
3082 /* Constant, e.g. from "const" in Pascal. */
3083 add_psymbol_to_list (namestring, p - namestring,
3084 VAR_NAMESPACE, LOC_CONST,
3085 &objfile->static_psymbols, sh.value,
3086 0, psymtab_language, objfile);
3092 int name_len = p - namestring;
3093 char *name = xmalloc (name_len + 1);
3094 memcpy (name, namestring, name_len);
3095 name[name_len] = '\0';
3096 function_outside_compilation_unit_complaint (name);
3099 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3100 add_psymbol_to_list (namestring, p - namestring,
3101 VAR_NAMESPACE, LOC_BLOCK,
3102 &objfile->static_psymbols,
3104 psymtab_language, objfile);
3107 /* Global functions were ignored here, but now they
3108 are put into the global psymtab like one would expect.
3109 They're also in the minimal symbol table. */
3113 int name_len = p - namestring;
3114 char *name = xmalloc (name_len + 1);
3115 memcpy (name, namestring, name_len);
3116 name[name_len] = '\0';
3117 function_outside_compilation_unit_complaint (name);
3120 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3121 add_psymbol_to_list (namestring, p - namestring,
3122 VAR_NAMESPACE, LOC_BLOCK,
3123 &objfile->global_psymbols,
3125 psymtab_language, objfile);
3128 /* Two things show up here (hopefully); static symbols of
3129 local scope (static used inside braces) or extensions
3130 of structure symbols. We can ignore both. */
3144 case '#': /* for symbol identification (used in live ranges) */
3145 /* added to support cfront stabs strings */
3146 case 'Z': /* for definition continuations */
3147 case 'P': /* for prototypes */
3151 /* It is a C++ nested symbol. We don't need to record it
3152 (I don't think); if we try to look up foo::bar::baz,
3153 then symbols for the symtab containing foo should get
3154 read in, I think. */
3155 /* Someone says sun cc puts out symbols like
3156 /foo/baz/maclib::/usr/local/bin/maclib,
3157 which would get here with a symbol type of ':'. */
3161 /* Unexpected symbol descriptor. The second and subsequent stabs
3162 of a continued stab can show up here. The question is
3163 whether they ever can mimic a normal stab--it would be
3164 nice if not, since we certainly don't want to spend the
3165 time searching to the end of every string looking for
3168 complaint (&symfile_complaints,
3169 "unknown symbol descriptor `%c'", p[1]);
3171 /* Ignore it; perhaps it is an extension that we don't
3180 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
3181 /* Solaris 2 end of module, finish current partial
3182 symbol table. END_PSYMTAB will set
3183 pst->texthigh to the proper value, which is
3184 necessary if a module compiled without
3185 debugging info follows this module. */
3188 pst = (struct partial_symtab *) 0;
3190 dependencies_used = 0;
3196 if (sh.value > save_pst->texthigh)
3197 save_pst->texthigh = sh.value;
3202 case N_SSYM: /* Claim: Structure or union element.
3203 Hopefully, I can ignore this. */
3204 case N_ENTRY: /* Alternate entry point; can ignore. */
3205 case N_MAIN: /* Can definitely ignore this. */
3206 case N_CATCH: /* These are GNU C++ extensions */
3207 case N_EHDECL: /* that can safely be ignored here. */
3217 case N_NSYMS: /* Ultrix 4.0: symbol count */
3218 case N_DEFD: /* GNU Modula-2 */
3219 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */
3221 case N_OBJ: /* useless types from Solaris */
3223 /* These symbols aren't interesting; don't worry about them */
3228 /* If we haven't found it yet, ignore it. It's probably some
3229 new type we don't know about yet. */
3230 complaint (&symfile_complaints, "unknown symbol type %s",
3231 local_hex_string (type_code)); /*CUR_SYMBOL_TYPE*/
3235 && stabstring != debug_info->ss + fh->issBase + sh.iss)
3238 /* end - Handle continuation */
3243 for (cur_sdx = 0; cur_sdx < fh->csym;)
3246 enum address_class class;
3248 (*swap_sym_in) (cur_bfd,
3249 ((char *) debug_info->external_sym
3250 + ((fh->isymBase + cur_sdx)
3251 * external_sym_size)),
3254 if (ECOFF_IS_STAB (&sh))
3260 /* Non absolute static symbols go into the minimal table. */
3261 if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil
3262 || (sh.index == indexNil
3263 && (sh.st != stStatic || sh.sc == scAbs)))
3265 /* FIXME, premature? */
3270 name = debug_info->ss + fh->issBase + sh.iss;
3276 /* The value of a stEnd symbol is the displacement from the
3277 corresponding start symbol value, do not relocate it. */
3279 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3286 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3290 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
3301 prim_record_minimal_symbol_and_info (name, sh.value,
3302 mst_file_text, NULL,
3303 SECT_OFF_TEXT (objfile), NULL,
3309 /* Usually there is a local and a global stProc symbol
3310 for a function. This means that the function name
3311 has already been entered into the mimimal symbol table
3312 while processing the global symbols in pass 2 above.
3313 One notable exception is the PROGRAM name from
3314 f77 compiled executables, it is only put out as
3315 local stProc symbol, and a global MAIN__ stProc symbol
3316 points to it. It doesn't matter though, as gdb is
3317 still able to find the PROGRAM name via the partial
3318 symbol table, and the MAIN__ symbol via the minimal
3320 if (sh.st == stProc)
3321 add_psymbol_to_list (name, strlen (name),
3322 VAR_NAMESPACE, LOC_BLOCK,
3323 &objfile->global_psymbols,
3324 0, sh.value, psymtab_language, objfile);
3326 add_psymbol_to_list (name, strlen (name),
3327 VAR_NAMESPACE, LOC_BLOCK,
3328 &objfile->static_psymbols,
3329 0, sh.value, psymtab_language, objfile);
3331 /* Skip over procedure to next one. */
3332 if (sh.index >= hdr->iauxMax)
3334 /* Should not happen, but does when cross-compiling
3335 with the MIPS compiler. FIXME -- pull later. */
3336 index_complaint (name);
3337 new_sdx = cur_sdx + 1; /* Don't skip at all */
3340 new_sdx = AUX_GET_ISYM (fh->fBigendian,
3341 (debug_info->external_aux
3344 procaddr = sh.value;
3346 if (new_sdx <= cur_sdx)
3348 /* This should not happen either... FIXME. */
3349 complaint (&symfile_complaints,
3350 "bad proc end in aux found from symbol %s",
3352 new_sdx = cur_sdx + 1; /* Don't skip backward */
3356 (*swap_sym_in) (cur_bfd,
3357 ((char *) debug_info->external_sym
3358 + ((fh->isymBase + cur_sdx - 1)
3359 * external_sym_size)),
3364 /* Kludge for Irix 5.2 zero fh->adr. */
3366 && (pst->textlow == 0 || procaddr < pst->textlow))
3367 pst->textlow = procaddr;
3369 high = procaddr + sh.value;
3370 if (high > pst->texthigh)
3371 pst->texthigh = high;
3374 case stStatic: /* Variable */
3375 if (SC_IS_DATA (sh.sc))
3376 prim_record_minimal_symbol_and_info (name, sh.value,
3377 mst_file_data, NULL,
3378 SECT_OFF_DATA (objfile),
3382 prim_record_minimal_symbol_and_info (name, sh.value,
3384 SECT_OFF_BSS (objfile),
3390 case stIndirect: /* Irix5 forward declaration */
3391 /* Skip forward declarations from Irix5 cc */
3394 case stTypedef: /* Typedef */
3395 /* Skip typedefs for forward declarations and opaque
3396 structs from alpha and mips cc. */
3397 if (sh.iss == 0 || has_opaque_xref (fh, &sh))
3399 class = LOC_TYPEDEF;
3402 case stConstant: /* Constant decl */
3409 case stBlock: /* { }, str, un, enum */
3410 /* Do not create a partial symbol for cc unnamed aggregates
3411 and gcc empty aggregates. */
3412 if ((sh.sc == scInfo
3413 || SC_IS_COMMON (sh.sc))
3415 && sh.index != cur_sdx + 2)
3417 add_psymbol_to_list (name, strlen (name),
3418 STRUCT_NAMESPACE, LOC_TYPEDEF,
3419 &objfile->static_psymbols,
3421 psymtab_language, objfile);
3423 handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
3425 /* Skip over the block */
3427 if (new_sdx <= cur_sdx)
3429 /* This happens with the Ultrix kernel. */
3430 complaint (&symfile_complaints,
3431 "bad aux index at block symbol %s", name);
3432 new_sdx = cur_sdx + 1; /* Don't skip backward */
3437 case stFile: /* File headers */
3438 case stLabel: /* Labels */
3439 case stEnd: /* Ends of files */
3442 case stLocal: /* Local variables */
3443 /* Normally these are skipped because we skip over
3444 all blocks we see. However, these can occur
3445 as visible symbols in a .h file that contains code. */
3449 /* Both complaints are valid: one gives symbol name,
3450 the other the offending symbol type. */
3451 complaint (&symfile_complaints, "unknown local symbol %s",
3453 complaint (&symfile_complaints, "with type %d", sh.st);
3457 /* Use this gdb symbol */
3458 add_psymbol_to_list (name, strlen (name),
3459 VAR_NAMESPACE, class,
3460 &objfile->static_psymbols,
3461 0, sh.value, psymtab_language, objfile);
3463 cur_sdx++; /* Go to next file symbol */
3466 /* Now do enter the external symbols. */
3467 ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset];
3468 cur_sdx = fdr_to_pst[f_idx].n_globals;
3469 PST_PRIVATE (save_pst)->extern_count = cur_sdx;
3470 PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
3471 for (; --cur_sdx >= 0; ext_ptr++)
3473 enum address_class class;
3478 if (ext_ptr->ifd != f_idx)
3479 internal_error (__FILE__, __LINE__, "failed internal consistency check");
3480 psh = &ext_ptr->asym;
3482 /* Do not add undefined symbols to the partial symbol table. */
3483 if (SC_IS_UNDEF (psh->sc) || psh->sc == scNil)
3486 svalue = psh->value;
3491 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3498 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3502 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
3509 /* These are generated for static symbols in .o files,
3514 /* External procedure symbols have been entered
3515 into the minimal symbol table in pass 2 above.
3516 Ignore them, as parse_external will ignore them too. */
3522 unknown_ext_complaint (debug_info->ssext + psh->iss);
3523 /* Fall through, pretend it's global. */
3525 /* Global common symbols are resolved by the runtime loader,
3527 if (SC_IS_COMMON (psh->sc))
3533 name = debug_info->ssext + psh->iss;
3534 add_psymbol_to_list (name, strlen (name),
3535 VAR_NAMESPACE, class,
3536 &objfile->global_psymbols,
3538 psymtab_language, objfile);
3542 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3543 empty and put on the free list. */
3544 fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
3545 psymtab_include_list, includes_used,
3546 -1, save_pst->texthigh,
3547 dependency_list, dependencies_used, textlow_not_set);
3549 dependencies_used = 0;
3551 if (objfile->ei.entry_point >= save_pst->textlow &&
3552 objfile->ei.entry_point < save_pst->texthigh)
3554 objfile->ei.entry_file_lowpc = save_pst->textlow;
3555 objfile->ei.entry_file_highpc = save_pst->texthigh;
3558 /* The objfile has its functions reordered if this partial symbol
3559 table overlaps any other partial symbol table.
3560 We cannot assume a reordered objfile if a partial symbol table
3561 is contained within another partial symbol table, as partial symbol
3562 tables for include files with executable code are contained
3563 within the partial symbol table for the including source file,
3564 and we do not want to flag the objfile reordered for these cases.
3566 This strategy works well for Irix-5.2 shared libraries, but we
3567 might have to use a more elaborate (and slower) algorithm for
3569 save_pst = fdr_to_pst[f_idx].pst;
3570 if (save_pst != NULL
3571 && save_pst->textlow != 0
3572 && !(objfile->flags & OBJF_REORDERED))
3574 ALL_OBJFILE_PSYMTABS (objfile, pst)
3577 && save_pst->textlow >= pst->textlow
3578 && save_pst->textlow < pst->texthigh
3579 && save_pst->texthigh > pst->texthigh)
3581 objfile->flags |= OBJF_REORDERED;
3588 /* Now scan the FDRs for dependencies */
3589 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
3591 fh = f_idx + debug_info->fdr;
3592 pst = fdr_to_pst[f_idx].pst;
3594 if (pst == (struct partial_symtab *) NULL)
3597 /* This should catch stabs-in-ecoff. */
3601 /* Skip the first file indirect entry as it is a self dependency
3602 for source files or a reverse .h -> .c dependency for header files. */
3603 pst->number_of_dependencies = 0;
3605 ((struct partial_symtab **)
3606 obstack_alloc (&objfile->psymbol_obstack,
3608 * sizeof (struct partial_symtab *))));
3609 for (s_idx = 1; s_idx < fh->crfd; s_idx++)
3613 (*swap_rfd_in) (cur_bfd,
3614 ((char *) debug_info->external_rfd
3615 + (fh->rfdBase + s_idx) * external_rfd_size),
3617 if (rh < 0 || rh >= hdr->ifdMax)
3619 complaint (&symfile_complaints, "bad file number %ld", rh);
3623 /* Skip self dependencies of header files. */
3627 /* Do not add to dependeny list if psymtab was empty. */
3628 if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL)
3630 pst->dependencies[pst->number_of_dependencies++] = fdr_to_pst[rh].pst;
3634 /* Remove the dummy psymtab created for -O3 images above, if it is
3635 still empty, to enable the detection of stripped executables. */
3636 if (objfile->psymtabs->next == NULL
3637 && objfile->psymtabs->number_of_dependencies == 0
3638 && objfile->psymtabs->n_global_syms == 0
3639 && objfile->psymtabs->n_static_syms == 0)
3640 objfile->psymtabs = NULL;
3641 do_cleanups (old_chain);
3644 /* If the current psymbol has an enumerated type, we need to add
3645 all the the enum constants to the partial symbol table. */
3648 handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
3651 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
3652 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
3653 char *ext_sym = ((char *) debug_info->external_sym
3654 + ((fh->isymBase + cur_sdx + 1) * external_sym_size));
3664 /* It is an enumerated type if the next symbol entry is a stMember
3665 and its auxiliary index is indexNil or its auxiliary entry
3666 is a plain btNil or btVoid.
3667 Alpha cc -migrate enums are recognized by a zero index and
3668 a zero symbol value.
3669 DU 4.0 cc enums are recognized by a member type of btEnum without
3670 qualifiers and a zero symbol value. */
3671 (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3672 if (sh.st != stMember)
3675 if (sh.index == indexNil
3676 || (sh.index == 0 && svalue == 0))
3678 (*debug_swap->swap_tir_in) (fh->fBigendian,
3679 &(debug_info->external_aux
3680 + fh->iauxBase + sh.index)->a_ti,
3682 if ((tir.bt != btNil
3684 && (tir.bt != btEnum || svalue != 0))
3685 || tir.tq0 != tqNil)
3697 (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3698 if (sh.st != stMember)
3700 name = debug_info->ss + cur_fdr->issBase + sh.iss;
3702 /* Note that the value doesn't matter for enum constants
3703 in psymtabs, just in symtabs. */
3704 add_psymbol_to_list (name, strlen (name),
3705 VAR_NAMESPACE, LOC_CONST,
3706 &objfile->static_psymbols, 0,
3707 (CORE_ADDR) 0, psymtab_language, objfile);
3708 ext_sym += external_sym_size;
3712 /* Get the next symbol. OBJFILE is unused. */
3715 mdebug_next_symbol_text (struct objfile *objfile)
3720 (*debug_swap->swap_sym_in) (cur_bfd,
3721 ((char *) debug_info->external_sym
3722 + ((cur_fdr->isymBase + cur_sdx)
3723 * debug_swap->external_sym_size)),
3725 return debug_info->ss + cur_fdr->issBase + sh.iss;
3728 /* Ancillary function to psymtab_to_symtab(). Does all the work
3729 for turning the partial symtab PST into a symtab, recurring
3730 first on all dependent psymtabs. The argument FILENAME is
3731 only passed so we can see in debug stack traces what file
3734 This function has a split personality, based on whether the
3735 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3736 The flow of control and even the memory allocation differs. FIXME. */
3739 psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
3741 bfd_size_type external_sym_size;
3742 bfd_size_type external_pdr_size;
3743 void (*swap_sym_in) (bfd *, void *, SYMR *);
3744 void (*swap_pdr_in) (bfd *, void *, PDR *);
3746 struct symtab *st = NULL;
3748 struct linetable *lines;
3749 CORE_ADDR lowest_pdr_addr = 0;
3750 int last_symtab_ended = 0;
3756 /* Read in all partial symbtabs on which this one is dependent.
3757 NOTE that we do have circular dependencies, sigh. We solved
3758 that by setting pst->readin before this point. */
3760 for (i = 0; i < pst->number_of_dependencies; i++)
3761 if (!pst->dependencies[i]->readin)
3763 /* Inform about additional files to be read in. */
3766 fputs_filtered (" ", gdb_stdout);
3768 fputs_filtered ("and ", gdb_stdout);
3770 printf_filtered ("%s...",
3771 pst->dependencies[i]->filename);
3772 wrap_here (""); /* Flush output */
3773 gdb_flush (gdb_stdout);
3775 /* We only pass the filename for debug purposes */
3776 psymtab_to_symtab_1 (pst->dependencies[i],
3777 pst->dependencies[i]->filename);
3780 /* Do nothing if this is a dummy psymtab. */
3782 if (pst->n_global_syms == 0 && pst->n_static_syms == 0
3783 && pst->textlow == 0 && pst->texthigh == 0)
3786 /* Now read the symbols for this symtab */
3788 cur_bfd = CUR_BFD (pst);
3789 debug_swap = DEBUG_SWAP (pst);
3790 debug_info = DEBUG_INFO (pst);
3791 pending_list = PENDING_LIST (pst);
3792 external_sym_size = debug_swap->external_sym_size;
3793 external_pdr_size = debug_swap->external_pdr_size;
3794 swap_sym_in = debug_swap->swap_sym_in;
3795 swap_pdr_in = debug_swap->swap_pdr_in;
3796 current_objfile = pst->objfile;
3797 cur_fd = FDR_IDX (pst);
3798 fh = ((cur_fd == -1)
3800 : debug_info->fdr + cur_fd);
3803 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3804 processing_gcc_compilation = 0;
3805 if (fh != (FDR *) NULL && fh->csym >= 2)
3809 (*swap_sym_in) (cur_bfd,
3810 ((char *) debug_info->external_sym
3811 + (fh->isymBase + 1) * external_sym_size),
3813 if (STREQ (debug_info->ss + fh->issBase + sh.iss,
3816 /* We indicate that this is a GCC compilation so that certain
3817 features will be enabled in stabsread/dbxread. */
3818 processing_gcc_compilation = 2;
3822 if (processing_gcc_compilation != 0)
3825 /* This symbol table contains stabs-in-ecoff entries. */
3827 /* Parse local symbols first */
3829 if (fh->csym <= 2) /* FIXME, this blows psymtab->symtab ptr */
3831 current_objfile = NULL;
3834 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
3840 (*swap_sym_in) (cur_bfd,
3841 (((char *) debug_info->external_sym)
3842 + (fh->isymBase + cur_sdx) * external_sym_size),
3844 name = debug_info->ss + fh->issBase + sh.iss;
3846 /* XXX This is a hack. It will go away! */
3847 if (ECOFF_IS_STAB (&sh) || (name[0] == '#'))
3849 int type_code = ECOFF_UNMARK_STAB (sh.index);
3851 /* We should never get non N_STAB symbols here, but they
3852 should be harmless, so keep process_one_symbol from
3853 complaining about them. */
3854 if (type_code & N_STAB)
3856 /* If we found a trailing N_SO with no name, process
3857 it here instead of in process_one_symbol, so we
3858 can keep a handle to its symtab. The symtab
3859 would otherwise be ended twice, once in
3860 process_one_symbol, and once after this loop. */
3861 if (type_code == N_SO
3863 && previous_stab_code != (unsigned char) N_SO
3866 valu += ANOFFSET (pst->section_offsets,
3867 SECT_OFF_TEXT (pst->objfile));
3868 previous_stab_code = N_SO;
3869 st = end_symtab (valu, pst->objfile,
3870 SECT_OFF_TEXT (pst->objfile));
3872 last_symtab_ended = 1;
3876 last_symtab_ended = 0;
3877 process_one_symbol (type_code, 0, valu, name,
3878 pst->section_offsets, pst->objfile);
3881 /* Similarly a hack. */
3882 else if (name[0] == '#')
3884 process_one_symbol (N_SLINE, 0, valu, name,
3885 pst->section_offsets, pst->objfile);
3887 if (type_code == N_FUN)
3889 /* Make up special symbol to contain
3890 procedure specific info */
3891 struct mips_extra_func_info *e =
3892 ((struct mips_extra_func_info *)
3893 obstack_alloc (¤t_objfile->symbol_obstack,
3894 sizeof (struct mips_extra_func_info)));
3895 struct symbol *s = new_symbol (MIPS_EFI_SYMBOL_NAME);
3897 memset (e, 0, sizeof (struct mips_extra_func_info));
3898 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
3899 SYMBOL_CLASS (s) = LOC_CONST;
3900 SYMBOL_TYPE (s) = mdebug_type_void;
3901 SYMBOL_VALUE (s) = (long) e;
3902 e->pdr.framereg = -1;
3903 add_symbol_to_list (s, &local_symbols);
3906 else if (sh.st == stLabel)
3908 if (sh.index == indexNil)
3910 /* This is what the gcc2_compiled and __gnu_compiled_*
3911 show up as. So don't complain. */
3916 /* Handle encoded stab line number. */
3917 valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile));
3918 record_line (current_subfile, sh.index, valu);
3921 else if (sh.st == stProc || sh.st == stStaticProc
3922 || sh.st == stStatic || sh.st == stEnd)
3923 /* These are generated by gcc-2.x, do not complain */
3926 complaint (&symfile_complaints, "unknown stabs symbol %s", name);
3929 if (! last_symtab_ended)
3931 st = end_symtab (pst->texthigh, pst->objfile, SECT_OFF_TEXT (pst->objfile));
3935 /* Sort the symbol table now, we are done adding symbols to it.
3936 We must do this before parse_procedure calls lookup_symbol. */
3937 sort_symtab_syms (st);
3939 /* There used to be a call to sort_blocks here, but this should not
3940 be necessary for stabs symtabs. And as sort_blocks modifies the
3941 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3942 it did the wrong thing if the first procedure in a file was
3943 generated via asm statements. */
3945 /* Fill in procedure info next. */
3949 struct cleanup *old_chain;
3955 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
3956 old_chain = make_cleanup (xfree, pr_block);
3958 pdr_ptr = ((char *) debug_info->external_pdr
3959 + fh->ipdFirst * external_pdr_size);
3960 pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
3964 pdr_ptr += external_pdr_size, pdr_in++)
3966 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
3968 /* Determine lowest PDR address, the PDRs are not always
3970 if (pdr_in == pr_block)
3971 lowest_pdr_addr = pdr_in->adr;
3972 else if (pdr_in->adr < lowest_pdr_addr)
3973 lowest_pdr_addr = pdr_in->adr;
3977 pdr_in_end = pdr_in + fh->cpd;
3978 for (; pdr_in < pdr_in_end; pdr_in++)
3979 parse_procedure (pdr_in, st, pst);
3981 do_cleanups (old_chain);
3986 /* This symbol table contains ordinary ecoff entries. */
3992 /* How many symbols will we need */
3993 /* FIXME, this does not count enum values. */
3994 f_max = pst->n_global_syms + pst->n_static_syms;
3998 st = new_symtab ("unknown", f_max, 0, pst->objfile);
4002 f_max += fh->csym + fh->cpd;
4003 maxlines = 2 * fh->cline;
4004 st = new_symtab (pst->filename, 2 * f_max, maxlines, pst->objfile);
4006 /* The proper language was already determined when building
4007 the psymtab, use it. */
4008 st->language = PST_PRIVATE (pst)->pst_language;
4011 psymtab_language = st->language;
4013 lines = LINETABLE (st);
4015 /* Get a new lexical context */
4017 push_parse_stack ();
4018 top_stack->cur_st = st;
4019 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
4021 BLOCK_START (top_stack->cur_block) = pst->textlow;
4022 BLOCK_END (top_stack->cur_block) = 0;
4023 top_stack->blocktype = stFile;
4024 top_stack->maxsyms = 2 * f_max;
4025 top_stack->cur_type = 0;
4026 top_stack->procadr = 0;
4027 top_stack->numargs = 0;
4028 found_ecoff_debugging_info = 0;
4035 /* Parse local symbols first */
4036 sym_ptr = ((char *) debug_info->external_sym
4037 + fh->isymBase * external_sym_size);
4038 sym_end = sym_ptr + fh->csym * external_sym_size;
4039 while (sym_ptr < sym_end)
4044 (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
4045 c = parse_symbol (&sh,
4046 debug_info->external_aux + fh->iauxBase,
4047 sym_ptr, fh->fBigendian, pst->section_offsets, pst->objfile);
4048 sym_ptr += c * external_sym_size;
4051 /* Linenumbers. At the end, check if we can save memory.
4052 parse_lines has to look ahead an arbitrary number of PDR
4053 structures, so we swap them all first. */
4057 struct cleanup *old_chain;
4063 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
4065 old_chain = make_cleanup (xfree, pr_block);
4067 pdr_ptr = ((char *) debug_info->external_pdr
4068 + fh->ipdFirst * external_pdr_size);
4069 pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
4073 pdr_ptr += external_pdr_size, pdr_in++)
4075 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
4077 /* Determine lowest PDR address, the PDRs are not always
4079 if (pdr_in == pr_block)
4080 lowest_pdr_addr = pdr_in->adr;
4081 else if (pdr_in->adr < lowest_pdr_addr)
4082 lowest_pdr_addr = pdr_in->adr;
4085 parse_lines (fh, pr_block, lines, maxlines, pst, lowest_pdr_addr);
4086 if (lines->nitems < fh->cline)
4087 lines = shrink_linetable (lines);
4089 /* Fill in procedure info next. */
4091 pdr_in_end = pdr_in + fh->cpd;
4092 for (; pdr_in < pdr_in_end; pdr_in++)
4093 parse_procedure (pdr_in, 0, pst);
4095 do_cleanups (old_chain);
4099 LINETABLE (st) = lines;
4101 /* .. and our share of externals.
4102 XXX use the global list to speed up things here. how?
4103 FIXME, Maybe quit once we have found the right number of ext's? */
4104 top_stack->cur_st = st;
4105 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
4107 top_stack->blocktype = stFile;
4109 = (debug_info->symbolic_header.isymMax
4110 + debug_info->symbolic_header.ipdMax
4111 + debug_info->symbolic_header.iextMax);
4113 ext_ptr = PST_PRIVATE (pst)->extern_tab;
4114 for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
4115 parse_external (ext_ptr, fh->fBigendian, pst->section_offsets, pst->objfile);
4117 /* If there are undefined symbols, tell the user.
4118 The alpha has an undefined symbol for every symbol that is
4119 from a shared library, so tell the user only if verbose is on. */
4120 if (info_verbose && n_undef_symbols)
4122 printf_filtered ("File %s contains %d unresolved references:",
4123 st->filename, n_undef_symbols);
4124 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
4125 n_undef_vars, n_undef_procs, n_undef_labels);
4126 n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0;
4133 /* Sort the symbol table now, we are done adding symbols to it. */
4134 sort_symtab_syms (st);
4139 /* Now link the psymtab and the symtab. */
4142 current_objfile = NULL;
4145 /* Ancillary parsing procedures. */
4147 /* Return 1 if the symbol pointed to by SH has a cross reference
4148 to an opaque aggregate type, else 0. */
4151 has_opaque_xref (FDR *fh, SYMR *sh)
4158 if (sh->index == indexNil)
4161 ax = debug_info->external_aux + fh->iauxBase + sh->index;
4162 (*debug_swap->swap_tir_in) (fh->fBigendian, &ax->a_ti, &tir);
4163 if (tir.bt != btStruct && tir.bt != btUnion && tir.bt != btEnum)
4167 (*debug_swap->swap_rndx_in) (fh->fBigendian, &ax->a_rndx, rn);
4168 if (rn->rfd == 0xfff)
4169 rf = AUX_GET_ISYM (fh->fBigendian, ax + 1);
4177 /* Lookup the type at relative index RN. Return it in TPP
4178 if found and in any event come up with its name PNAME.
4179 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4180 Return value says how many aux symbols we ate. */
4183 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. */
4184 char **pname, int bigend, char *sym_name)
4193 struct mdebug_pending *pend;
4195 *tpp = (struct type *) NULL;
4197 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
4199 /* Escape index means 'the next one' */
4200 if (rn->rfd == 0xfff)
4203 rf = AUX_GET_ISYM (bigend, ax + 1);
4210 /* mips cc uses a rf of -1 for opaque struct definitions.
4211 Set TYPE_FLAG_STUB for these types so that check_typedef will
4212 resolve them if the struct gets defined in another compilation unit. */
4215 *pname = "<undefined>";
4216 *tpp = init_type (type_code, 0, TYPE_FLAG_STUB, (char *) NULL, current_objfile);
4220 /* mips cc uses an escaped rn->index of 0 for struct return types
4221 of procedures that were compiled without -g. These will always remain
4223 if (rn->rfd == 0xfff && rn->index == 0)
4225 *pname = "<undefined>";
4229 /* Find the relative file descriptor and the symbol in it. */
4230 fh = get_rfd (fd, rf);
4231 xref_fd = fh - debug_info->fdr;
4233 if (rn->index >= fh->csym)
4235 /* File indirect entry is corrupt. */
4236 *pname = "<illegal>";
4237 bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4241 /* If we have processed this symbol then we left a forwarding
4242 pointer to the type in the pending list. If not, we`ll put
4243 it in a list of pending types, to be processed later when
4244 the file will be. In any event, we collect the name for the
4247 esh = ((char *) debug_info->external_sym
4248 + ((fh->isymBase + rn->index)
4249 * debug_swap->external_sym_size));
4250 (*debug_swap->swap_sym_in) (cur_bfd, esh, &sh);
4252 /* Make sure that this type of cross reference can be handled. */
4253 if ((sh.sc != scInfo
4254 || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect
4255 && sh.st != stStruct && sh.st != stUnion
4256 && sh.st != stEnum))
4257 && (sh.st != stBlock || !SC_IS_COMMON (sh.sc)))
4259 /* File indirect entry is corrupt. */
4260 *pname = "<illegal>";
4261 bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4265 *pname = debug_info->ss + fh->issBase + sh.iss;
4267 pend = is_pending_symbol (fh, esh);
4272 /* We have not yet seen this type. */
4274 if ((sh.iss == 0 && sh.st == stTypedef) || sh.st == stIndirect)
4278 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4280 a) forward declarations of structs/unions/enums which are not
4281 defined in this compilation unit.
4282 For these the type will be void. This is a bad design decision
4283 as cross referencing across compilation units is impossible
4284 due to the missing name.
4285 b) forward declarations of structs/unions/enums/typedefs which
4286 are defined later in this file or in another file in the same
4287 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4288 Simply cross reference those again to get the true type.
4289 The forward references are not entered in the pending list and
4290 in the symbol table. */
4292 (*debug_swap->swap_tir_in) (bigend,
4293 &(debug_info->external_aux
4294 + fh->iauxBase + sh.index)->a_ti,
4296 if (tir.tq0 != tqNil)
4297 complaint (&symfile_complaints,
4298 "illegal tq0 in forward typedef for %s", sym_name);
4302 *tpp = init_type (type_code, 0, 0, (char *) NULL,
4304 *pname = "<undefined>";
4311 (debug_info->external_aux
4312 + fh->iauxBase + sh.index + 1),
4313 tpp, type_code, pname,
4314 fh->fBigendian, sym_name);
4318 /* Follow a forward typedef. This might recursively
4319 call cross_ref till we get a non typedef'ed type.
4320 FIXME: This is not correct behaviour, but gdb currently
4321 cannot handle typedefs without type copying. Type
4322 copying is impossible as we might have mutual forward
4323 references between two files and the copied type would not
4324 get filled in when we later parse its definition. */
4325 *tpp = parse_type (xref_fd,
4326 debug_info->external_aux + fh->iauxBase,
4330 debug_info->ss + fh->issBase + sh.iss);
4331 add_pending (fh, esh, *tpp);
4335 complaint (&symfile_complaints,
4336 "illegal bt %d in forward typedef for %s", tir.bt,
4338 *tpp = init_type (type_code, 0, 0, (char *) NULL,
4344 else if (sh.st == stTypedef)
4346 /* Parse the type for a normal typedef. This might recursively call
4347 cross_ref till we get a non typedef'ed type.
4348 FIXME: This is not correct behaviour, but gdb currently
4349 cannot handle typedefs without type copying. But type copying is
4350 impossible as we might have mutual forward references between
4351 two files and the copied type would not get filled in when
4352 we later parse its definition. */
4353 *tpp = parse_type (xref_fd,
4354 debug_info->external_aux + fh->iauxBase,
4358 debug_info->ss + fh->issBase + sh.iss);
4362 /* Cross reference to a struct/union/enum which is defined
4363 in another file in the same compilation unit but that file
4364 has not been parsed yet.
4365 Initialize the type only, it will be filled in when
4366 it's definition is parsed. */
4367 *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
4369 add_pending (fh, esh, *tpp);
4372 /* We used one auxent normally, two if we got a "next one" rf. */
4377 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4378 keeping the symtab sorted */
4380 static struct symbol *
4381 mylookup_symbol (char *name, register struct block *block,
4382 namespace_enum namespace, enum address_class class)
4388 ALL_BLOCK_SYMBOLS (block, i, sym)
4390 if (SYMBOL_NAME (sym)[0] == inc
4391 && SYMBOL_NAMESPACE (sym) == namespace
4392 && SYMBOL_CLASS (sym) == class
4393 && strcmp (SYMBOL_NAME (sym), name) == 0)
4397 block = BLOCK_SUPERBLOCK (block);
4399 return mylookup_symbol (name, block, namespace, class);
4404 /* Add a new symbol S to a block B.
4405 Infrequently, we will need to reallocate the block to make it bigger.
4406 We only detect this case when adding to top_stack->cur_block, since
4407 that's the only time we know how big the block is. FIXME. */
4410 add_symbol (struct symbol *s, struct block *b)
4412 int nsyms = BLOCK_NSYMS (b)++;
4413 struct block *origb;
4414 struct parse_stack *stackp;
4416 if (b == top_stack->cur_block &&
4417 nsyms >= top_stack->maxsyms)
4419 complaint (&symfile_complaints, "block containing %s overfilled",
4421 /* In this case shrink_block is actually grow_block, since
4422 BLOCK_NSYMS(b) is larger than its current size. */
4424 b = shrink_block (top_stack->cur_block, top_stack->cur_st);
4426 /* Now run through the stack replacing pointers to the
4427 original block. shrink_block has already done this
4428 for the blockvector and BLOCK_FUNCTION. */
4429 for (stackp = top_stack; stackp; stackp = stackp->next)
4431 if (stackp->cur_block == origb)
4433 stackp->cur_block = b;
4434 stackp->maxsyms = BLOCK_NSYMS (b);
4438 BLOCK_SYM (b, nsyms) = s;
4441 /* Add a new block B to a symtab S */
4444 add_block (struct block *b, struct symtab *s)
4446 struct blockvector *bv = BLOCKVECTOR (s);
4448 bv = (struct blockvector *) xrealloc ((void *) bv,
4449 (sizeof (struct blockvector)
4450 + BLOCKVECTOR_NBLOCKS (bv)
4451 * sizeof (bv->block)));
4452 if (bv != BLOCKVECTOR (s))
4453 BLOCKVECTOR (s) = bv;
4455 BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b;
4458 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4459 MIPS' linenumber encoding might need more than one byte
4460 to describe it, LAST is used to detect these continuation lines.
4462 Combining lines with the same line number seems like a bad idea.
4463 E.g: There could be a line number entry with the same line number after the
4464 prologue and GDB should not ignore it (this is a better way to find
4465 a prologue than mips_skip_prologue).
4466 But due to the compressed line table format there are line number entries
4467 for the same line which are needed to bridge the gap to the next
4468 line number entry. These entries have a bogus address info with them
4469 and we are unable to tell them from intended duplicate line number
4471 This is another reason why -ggdb debugging format is preferable. */
4474 add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last)
4476 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4477 Change them to something sensible. */
4481 last = -2; /* make sure we record first line */
4483 if (last == lineno) /* skip continuation lines */
4486 lt->item[lt->nitems].line = lineno;
4487 lt->item[lt->nitems++].pc = adr << 2;
4491 /* Sorting and reordering procedures */
4493 /* Blocks with a smaller low bound should come first */
4496 compare_blocks (const void *arg1, const void *arg2)
4498 register int addr_diff;
4499 struct block **b1 = (struct block **) arg1;
4500 struct block **b2 = (struct block **) arg2;
4502 addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2)));
4504 return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1)));
4508 /* Sort the blocks of a symtab S.
4509 Reorder the blocks in the blockvector by code-address,
4510 as required by some MI search routines */
4513 sort_blocks (struct symtab *s)
4515 struct blockvector *bv = BLOCKVECTOR (s);
4517 if (BLOCKVECTOR_NBLOCKS (bv) <= 2)
4520 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0)
4521 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0;
4522 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0)
4523 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0;
4527 * This is very unfortunate: normally all functions are compiled in
4528 * the order they are found, but if the file is compiled -O3 things
4529 * are very different. It would be nice to find a reliable test
4530 * to detect -O3 images in advance.
4532 if (BLOCKVECTOR_NBLOCKS (bv) > 3)
4533 qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
4534 BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK,
4535 sizeof (struct block *),
4539 register CORE_ADDR high = 0;
4540 register int i, j = BLOCKVECTOR_NBLOCKS (bv);
4542 for (i = FIRST_LOCAL_BLOCK; i < j; i++)
4543 if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)))
4544 high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i));
4545 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high;
4548 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) =
4549 BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK));
4551 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4552 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4553 BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4554 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4558 /* Constructor/restructor/destructor procedures */
4560 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
4561 MAXSYMS and linenumbers MAXLINES we'll put in it */
4563 static struct symtab *
4564 new_symtab (char *name, int maxsyms, int maxlines, struct objfile *objfile)
4566 struct symtab *s = allocate_symtab (name, objfile);
4568 LINETABLE (s) = new_linetable (maxlines);
4570 /* All symtabs must have at least two blocks */
4571 BLOCKVECTOR (s) = new_bvect (2);
4572 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) = new_block (maxsyms);
4573 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) = new_block (maxsyms);
4574 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
4575 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4577 s->free_code = free_linetable;
4578 s->debugformat = obsavestring ("ECOFF", 5,
4579 &objfile->symbol_obstack);
4583 /* Allocate a new partial_symtab NAME */
4585 static struct partial_symtab *
4586 new_psymtab (char *name, struct objfile *objfile)
4588 struct partial_symtab *psymtab;
4590 psymtab = allocate_psymtab (name, objfile);
4591 psymtab->section_offsets = objfile->section_offsets;
4593 /* Keep a backpointer to the file's symbols */
4595 psymtab->read_symtab_private = ((char *)
4596 obstack_alloc (&objfile->psymbol_obstack,
4597 sizeof (struct symloc)));
4598 memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
4599 CUR_BFD (psymtab) = cur_bfd;
4600 DEBUG_SWAP (psymtab) = debug_swap;
4601 DEBUG_INFO (psymtab) = debug_info;
4602 PENDING_LIST (psymtab) = pending_list;
4604 /* The way to turn this into a symtab is to call... */
4605 psymtab->read_symtab = mdebug_psymtab_to_symtab;
4610 /* Allocate a linetable array of the given SIZE. Since the struct
4611 already includes one item, we subtract one when calculating the
4612 proper size to allocate. */
4614 static struct linetable *
4615 new_linetable (int size)
4617 struct linetable *l;
4619 size = (size - 1) * sizeof (l->item) + sizeof (struct linetable);
4620 l = (struct linetable *) xmalloc (size);
4625 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4626 I am not so sure about the 3.4 ones.
4628 Since the struct linetable already includes one item, we subtract one when
4629 calculating the proper size to allocate. */
4631 static struct linetable *
4632 shrink_linetable (struct linetable *lt)
4635 return (struct linetable *) xrealloc ((void *) lt,
4636 (sizeof (struct linetable)
4638 * sizeof (lt->item))));
4641 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4643 static struct blockvector *
4644 new_bvect (int nblocks)
4646 struct blockvector *bv;
4649 size = sizeof (struct blockvector) + nblocks * sizeof (struct block *);
4650 bv = (struct blockvector *) xzalloc (size);
4652 BLOCKVECTOR_NBLOCKS (bv) = nblocks;
4657 /* Allocate and zero a new block of MAXSYMS symbols */
4659 static struct block *
4660 new_block (int maxsyms)
4662 int size = sizeof (struct block) + (maxsyms - 1) * sizeof (struct symbol *);
4664 return (struct block *) xzalloc (size);
4667 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
4668 Shrink_block can also be used by add_symbol to grow a block. */
4670 static struct block *
4671 shrink_block (struct block *b, struct symtab *s)
4674 struct blockvector *bv = BLOCKVECTOR (s);
4677 /* Just reallocate it and fix references to the old one */
4679 new = (struct block *) xrealloc ((void *) b,
4680 (sizeof (struct block)
4681 + ((BLOCK_NSYMS (b) - 1)
4682 * sizeof (struct symbol *))));
4684 /* FIXME: Not worth hashing this block as it's built. */
4685 /* All callers should have created the block with new_block (), which
4686 would mean it was not previously hashed. Make sure. */
4687 gdb_assert (BLOCK_HASHTABLE (new) == 0);
4689 /* Should chase pointers to old one. Fortunately, that`s just
4690 the block`s function and inferior blocks */
4691 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b)
4692 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
4693 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
4694 if (BLOCKVECTOR_BLOCK (bv, i) == b)
4695 BLOCKVECTOR_BLOCK (bv, i) = new;
4696 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) == b)
4697 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) = new;
4701 /* Create a new symbol with printname NAME */
4703 static struct symbol *
4704 new_symbol (char *name)
4706 struct symbol *s = ((struct symbol *)
4707 obstack_alloc (¤t_objfile->symbol_obstack,
4708 sizeof (struct symbol)));
4710 memset (s, 0, sizeof (*s));
4711 SYMBOL_NAME (s) = obsavestring (name, strlen (name),
4712 ¤t_objfile->symbol_obstack);
4713 SYMBOL_LANGUAGE (s) = psymtab_language;
4714 SYMBOL_INIT_DEMANGLED_NAME (s, ¤t_objfile->symbol_obstack);
4718 /* Create a new type with printname NAME */
4720 static struct type *
4721 new_type (char *name)
4725 t = alloc_type (current_objfile);
4726 TYPE_NAME (t) = name;
4727 TYPE_CPLUS_SPECIFIC (t) = (struct cplus_struct_type *) &cplus_struct_default;
4731 /* Read ECOFF debugging information from a BFD section. This is
4732 called from elfread.c. It parses the section into a
4733 ecoff_debug_info struct, and then lets the rest of the file handle
4737 elfmdebug_build_psymtabs (struct objfile *objfile,
4738 const struct ecoff_debug_swap *swap, asection *sec)
4740 bfd *abfd = objfile->obfd;
4741 struct ecoff_debug_info *info;
4743 info = ((struct ecoff_debug_info *)
4744 obstack_alloc (&objfile->psymbol_obstack,
4745 sizeof (struct ecoff_debug_info)));
4747 if (!(*swap->read_debug_info) (abfd, sec, info))
4748 error ("Error reading ECOFF debugging information: %s",
4749 bfd_errmsg (bfd_get_error ()));
4751 mdebug_build_psymtabs (objfile, swap, info);
4755 /* Things used for calling functions in the inferior.
4756 These functions are exported to our companion
4757 mips-tdep.c file and are here because they play
4758 with the symbol-table explicitly. */
4760 /* Sigtramp: make sure we have all the necessary information
4761 about the signal trampoline code. Since the official code
4762 from MIPS does not do so, we make up that information ourselves.
4763 If they fix the library (unlikely) this code will neutralize itself. */
4765 /* FIXME: This function is called only by mips-tdep.c. It needs to be
4766 here because it calls functions defined in this file, but perhaps
4767 this could be handled in a better way. Only compile it in when
4768 tm-mips.h is included. */
4773 fixup_sigtramp (void)
4777 struct block *b, *b0 = NULL;
4779 sigtramp_address = -1;
4781 /* We have to handle the following cases here:
4782 a) The Mips library has a sigtramp label within sigvec.
4783 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
4784 s = lookup_symbol ("sigvec", 0, VAR_NAMESPACE, 0, NULL);
4787 b0 = SYMBOL_BLOCK_VALUE (s);
4788 s = lookup_symbol ("sigtramp", b0, VAR_NAMESPACE, 0, NULL);
4792 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
4793 s = lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE, 0, NULL);
4796 /* But maybe this program uses its own version of sigvec */
4800 /* Did we or MIPSco fix the library ? */
4801 if (SYMBOL_CLASS (s) == LOC_BLOCK)
4803 sigtramp_address = BLOCK_START (SYMBOL_BLOCK_VALUE (s));
4804 sigtramp_end = BLOCK_END (SYMBOL_BLOCK_VALUE (s));
4808 sigtramp_address = SYMBOL_VALUE (s);
4809 sigtramp_end = sigtramp_address + 0x88; /* black magic */
4811 /* But what symtab does it live in ? */
4812 st = find_pc_symtab (SYMBOL_VALUE (s));
4815 * Ok, there goes the fix: turn it into a procedure, with all the
4816 * needed info. Note we make it a nested procedure of sigvec,
4817 * which is the way the (assembly) code is actually written.
4819 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
4820 SYMBOL_CLASS (s) = LOC_BLOCK;
4821 SYMBOL_TYPE (s) = init_type (TYPE_CODE_FUNC, 4, 0, (char *) NULL,
4823 TYPE_TARGET_TYPE (SYMBOL_TYPE (s)) = mdebug_type_void;
4825 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4827 SYMBOL_BLOCK_VALUE (s) = b;
4828 BLOCK_START (b) = sigtramp_address;
4829 BLOCK_END (b) = sigtramp_end;
4830 BLOCK_FUNCTION (b) = s;
4831 BLOCK_SUPERBLOCK (b) = BLOCK_SUPERBLOCK (b0);
4835 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4837 struct mips_extra_func_info *e =
4838 ((struct mips_extra_func_info *)
4839 xzalloc (sizeof (struct mips_extra_func_info)));
4841 e->numargs = 0; /* the kernel thinks otherwise */
4842 e->pdr.frameoffset = 32;
4843 e->pdr.framereg = SP_REGNUM;
4844 /* Note that setting pcreg is no longer strictly necessary as
4845 mips_frame_saved_pc is now aware of signal handler frames. */
4846 e->pdr.pcreg = PC_REGNUM;
4847 e->pdr.regmask = -2;
4848 /* Offset to saved r31, in the sigtramp case the saved registers
4849 are above the frame in the sigcontext.
4850 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4851 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4852 and 32 * 4 bytes for the floating point registers. */
4853 e->pdr.regoffset = 4 + 12 + 31 * 4;
4854 e->pdr.fregmask = -1;
4855 /* Offset to saved f30 (first saved *double* register). */
4856 e->pdr.fregoffset = 4 + 12 + 32 * 4 + 12 + 30 * 4;
4857 e->pdr.isym = (long) s;
4858 e->pdr.adr = sigtramp_address;
4860 current_objfile = st->objfile; /* Keep new_symbol happy */
4861 s = new_symbol (MIPS_EFI_SYMBOL_NAME);
4862 SYMBOL_VALUE (s) = (long) e;
4863 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
4864 SYMBOL_CLASS (s) = LOC_CONST;
4865 SYMBOL_TYPE (s) = mdebug_type_void;
4866 current_objfile = NULL;
4869 BLOCK_SYM (b, BLOCK_NSYMS (b)++) = s;
4872 #endif /* TM_MIPS_H */
4875 _initialize_mdebugread (void)
4878 init_type (TYPE_CODE_VOID, 1,
4880 "void", (struct objfile *) NULL);
4882 init_type (TYPE_CODE_INT, 1,
4884 "char", (struct objfile *) NULL);
4885 mdebug_type_unsigned_char =
4886 init_type (TYPE_CODE_INT, 1,
4888 "unsigned char", (struct objfile *) NULL);
4890 init_type (TYPE_CODE_INT, 2,
4892 "short", (struct objfile *) NULL);
4893 mdebug_type_unsigned_short =
4894 init_type (TYPE_CODE_INT, 2,
4896 "unsigned short", (struct objfile *) NULL);
4897 mdebug_type_int_32 =
4898 init_type (TYPE_CODE_INT, 4,
4900 "int", (struct objfile *) NULL);
4901 mdebug_type_unsigned_int_32 =
4902 init_type (TYPE_CODE_INT, 4,
4904 "unsigned int", (struct objfile *) NULL);
4905 mdebug_type_int_64 =
4906 init_type (TYPE_CODE_INT, 8,
4908 "int", (struct objfile *) NULL);
4909 mdebug_type_unsigned_int_64 =
4910 init_type (TYPE_CODE_INT, 8,
4912 "unsigned int", (struct objfile *) NULL);
4913 mdebug_type_long_32 =
4914 init_type (TYPE_CODE_INT, 4,
4916 "long", (struct objfile *) NULL);
4917 mdebug_type_unsigned_long_32 =
4918 init_type (TYPE_CODE_INT, 4,
4920 "unsigned long", (struct objfile *) NULL);
4921 mdebug_type_long_64 =
4922 init_type (TYPE_CODE_INT, 8,
4924 "long", (struct objfile *) NULL);
4925 mdebug_type_unsigned_long_64 =
4926 init_type (TYPE_CODE_INT, 8,
4928 "unsigned long", (struct objfile *) NULL);
4929 mdebug_type_long_long_64 =
4930 init_type (TYPE_CODE_INT, 8,
4932 "long long", (struct objfile *) NULL);
4933 mdebug_type_unsigned_long_long_64 =
4934 init_type (TYPE_CODE_INT, 8,
4936 "unsigned long long", (struct objfile *) NULL);
4937 mdebug_type_adr_32 =
4938 init_type (TYPE_CODE_PTR, 4,
4940 "adr_32", (struct objfile *) NULL);
4941 TYPE_TARGET_TYPE (mdebug_type_adr_32) = mdebug_type_void;
4942 mdebug_type_adr_64 =
4943 init_type (TYPE_CODE_PTR, 8,
4945 "adr_64", (struct objfile *) NULL);
4946 TYPE_TARGET_TYPE (mdebug_type_adr_64) = mdebug_type_void;
4948 init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
4950 "float", (struct objfile *) NULL);
4951 mdebug_type_double =
4952 init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
4954 "double", (struct objfile *) NULL);
4955 mdebug_type_complex =
4956 init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
4958 "complex", (struct objfile *) NULL);
4959 TYPE_TARGET_TYPE (mdebug_type_complex) = mdebug_type_float;
4960 mdebug_type_double_complex =
4961 init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
4963 "double complex", (struct objfile *) NULL);
4964 TYPE_TARGET_TYPE (mdebug_type_double_complex) = mdebug_type_double;
4966 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4968 mdebug_type_string =
4969 init_type (TYPE_CODE_STRING,
4970 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
4972 (struct objfile *) NULL);
4974 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4975 good? Would we be better off with TYPE_CODE_ERROR? Should
4976 TYPE_CODE_ERROR print things in hex if it knows the size? */
4977 mdebug_type_fixed_dec =
4978 init_type (TYPE_CODE_INT,
4979 TARGET_INT_BIT / TARGET_CHAR_BIT,
4981 (struct objfile *) NULL);
4983 mdebug_type_float_dec =
4984 init_type (TYPE_CODE_ERROR,
4985 TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
4986 0, "floating decimal",
4987 (struct objfile *) NULL);
4989 nodebug_func_symbol_type = init_type (TYPE_CODE_FUNC, 1, 0,
4990 "<function, no debug info>", NULL);
4991 TYPE_TARGET_TYPE (nodebug_func_symbol_type) = mdebug_type_int;
4992 nodebug_var_symbol_type =
4993 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
4994 "<variable, no debug info>", NULL);