1 /* Read a symbol table in ECOFF format (Third-Eye).
3 Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009
5 Free Software Foundation, Inc.
7 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
8 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
11 This file is part of GDB.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 3 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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. */
49 #include "gdb_obstack.h"
51 #include "stabsread.h"
52 #include "complaints.h"
54 #include "gdb_assert.h"
56 #include "dictionary.h"
57 #include "mdebugread.h"
59 #include "gdb_string.h"
63 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
65 #include "libaout.h" /* Private BFD a.out information. */
66 #include "aout/aout64.h"
67 #include "aout/stab_gnu.h" /* STABS information */
69 #include "expression.h"
71 extern void _initialize_mdebugread (void);
73 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
74 We use this define in order to know whether we should override a
75 symbol's ECOFF section with its ELF section. This is necessary in
76 case the symbol's ELF section could not be represented in ECOFF. */
77 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
78 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
81 /* We put a pointer to this structure in the read_symtab_private field
86 /* Index of the FDR that this psymtab represents. */
88 /* The BFD that the psymtab was created from. */
90 const struct ecoff_debug_swap *debug_swap;
91 struct ecoff_debug_info *debug_info;
92 struct mdebug_pending **pending_list;
93 /* Pointer to external symbols for this file. */
95 /* Size of extern_tab. */
97 enum language pst_language;
100 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
101 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
102 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
103 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
104 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
105 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
107 #define SC_IS_TEXT(sc) ((sc) == scText \
108 || (sc) == scRConst \
111 #define SC_IS_DATA(sc) ((sc) == scData \
116 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
117 #define SC_IS_BSS(sc) ((sc) == scBss)
118 #define SC_IS_SBSS(sc) ((sc) == scSBss)
119 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
121 /* Various complaints about symbol reading that don't abort the process */
123 index_complaint (const char *arg1)
125 complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
129 unknown_ext_complaint (const char *arg1)
131 complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
135 basic_type_complaint (int arg1, const char *arg2)
137 complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
142 bad_tag_guess_complaint (const char *arg1)
144 complaint (&symfile_complaints, _("guessed tag type of %s incorrectly"), arg1);
148 bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
150 complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
155 unexpected_type_code_complaint (const char *arg1)
157 complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
160 /* Macros and extra defs */
162 /* Puns: hard to find whether -g was used and how */
164 #define MIN_GLEVEL GLEVEL_0
165 #define compare_glevel(a,b) \
166 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
167 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
169 /* Things that really are local to this module */
171 /* Remember what we deduced to be the source language of this psymtab. */
173 static enum language psymtab_language = language_unknown;
179 /* How to parse debugging information for CUR_BFD. */
181 static const struct ecoff_debug_swap *debug_swap;
183 /* Pointers to debugging information for CUR_BFD. */
185 static struct ecoff_debug_info *debug_info;
187 /* Pointer to current file decriptor record, and its index */
192 /* Index of current symbol */
196 /* Note how much "debuggable" this image is. We would like
197 to see at least one FDR with full symbols */
199 static int max_gdbinfo;
200 static int max_glevel;
202 /* When examining .o files, report on undefined symbols */
204 static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
206 /* Pseudo symbol to use when putting stabs into the symbol table. */
208 static char stabs_symbol[] = STABS_SYMBOL;
210 /* Nonzero if we have seen ecoff debugging info for a file. */
212 static int found_ecoff_debugging_info;
214 /* Forward declarations */
216 static int upgrade_type (int, struct type **, int, union aux_ext *,
219 static void parse_partial_symbols (struct objfile *);
221 static int has_opaque_xref (FDR *, SYMR *);
223 static int cross_ref (int, union aux_ext *, struct type **, enum type_code,
224 char **, int, char *);
226 static struct symbol *new_symbol (char *);
228 static struct type *new_type (char *);
230 enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };
232 static struct block *new_block (enum block_type);
234 static struct symtab *new_symtab (char *, int, struct objfile *);
236 static struct linetable *new_linetable (int);
238 static struct blockvector *new_bvect (int);
240 static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
243 static struct symbol *mylookup_symbol (char *, struct block *, domain_enum,
246 static void sort_blocks (struct symtab *);
248 static struct partial_symtab *new_psymtab (char *, struct objfile *);
250 static void psymtab_to_symtab_1 (struct partial_symtab *, char *);
252 static void add_block (struct block *, struct symtab *);
254 static void add_symbol (struct symbol *, struct symtab *, struct block *);
256 static int add_line (struct linetable *, int, CORE_ADDR, int);
258 static struct linetable *shrink_linetable (struct linetable *);
260 static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
263 static char *mdebug_next_symbol_text (struct objfile *);
265 /* Exported procedure: Builds a symtab from the PST partial one.
266 Restores the environment in effect when PST was created, delegates
267 most of the work to an ancillary procedure, and sorts
268 and reorders the symtab list at the end */
271 mdebug_psymtab_to_symtab (struct partial_symtab *pst)
279 printf_filtered (_("Reading in symbols for %s..."), pst->filename);
280 gdb_flush (gdb_stdout);
283 next_symbol_text_func = mdebug_next_symbol_text;
285 psymtab_to_symtab_1 (pst, pst->filename);
287 /* Match with global symbols. This only needs to be done once,
288 after all of the symtabs and dependencies have been read in. */
289 scan_file_globals (pst->objfile);
292 printf_filtered (_("done.\n"));
295 /* File-level interface functions */
297 /* Find a file descriptor given its index RF relative to a file CF */
300 get_rfd (int cf, int rf)
306 fdrs = debug_info->fdr;
308 /* Object files do not have the RFD table, all refs are absolute */
311 (*debug_swap->swap_rfd_in) (cur_bfd,
312 ((char *) debug_info->external_rfd
314 * debug_swap->external_rfd_size)),
319 /* Return a safer print NAME for a file descriptor */
325 return "<stripped file>";
328 return debug_info->ss + f->issBase + f->rss;
332 /* Read in and parse the symtab of the file OBJFILE. Symbols from
333 different sections are relocated via the SECTION_OFFSETS. */
336 mdebug_build_psymtabs (struct objfile *objfile,
337 const struct ecoff_debug_swap *swap,
338 struct ecoff_debug_info *info)
340 cur_bfd = objfile->obfd;
344 stabsread_new_init ();
345 buildsym_new_init ();
346 free_header_files ();
347 init_header_files ();
349 /* Make sure all the FDR information is swapped in. */
350 if (info->fdr == (FDR *) NULL)
356 info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack,
357 (info->symbolic_header.ifdMax
359 fdr_src = info->external_fdr;
361 + info->symbolic_header.ifdMax * swap->external_fdr_size);
363 for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++)
364 (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);
367 parse_partial_symbols (objfile);
370 /* Check to make sure file was compiled with -g. If not, warn the
371 user of this limitation. */
372 if (compare_glevel (max_glevel, GLEVEL_2) < 0)
374 if (max_gdbinfo == 0)
375 printf_unfiltered (_("\n%s not compiled with -g, debugging support is limited.\n"),
377 printf_unfiltered (_("You should compile with -g2 or -g3 for best debugging support.\n"));
378 gdb_flush (gdb_stdout);
383 /* Local utilities */
385 /* Map of FDR indexes to partial symtabs */
389 struct partial_symtab *pst; /* the psymtab proper */
390 long n_globals; /* exported globals (external symbols) */
391 long globals_offset; /* cumulative */
395 /* Utility stack, used to nest procedures and blocks properly.
396 It is a doubly linked list, to avoid too many alloc/free.
397 Since we might need it quite a few times it is NOT deallocated
400 static struct parse_stack
402 struct parse_stack *next, *prev;
403 struct symtab *cur_st; /* Current symtab. */
404 struct block *cur_block; /* Block in it. */
406 /* What are we parsing. stFile, or stBlock are for files and
407 blocks. stProc or stStaticProc means we have seen the start of a
408 procedure, but not the start of the block within in. When we see
409 the start of that block, we change it to stNil, without pushing a
410 new block, i.e. stNil means both a procedure and a block. */
414 struct type *cur_type; /* Type we parse fields for. */
415 int cur_field; /* Field number in cur_type. */
416 CORE_ADDR procadr; /* Start addres of this procedure */
417 int numargs; /* Its argument count */
420 *top_stack; /* Top stack ptr */
423 /* Enter a new lexical context */
426 push_parse_stack (void)
428 struct parse_stack *new;
430 /* Reuse frames if possible */
431 if (top_stack && top_stack->prev)
432 new = top_stack->prev;
434 new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
435 /* Initialize new frame with previous content */
438 struct parse_stack *prev = new->prev;
441 top_stack->prev = new;
443 new->next = top_stack;
448 /* Exit a lexical context */
451 pop_parse_stack (void)
456 top_stack = top_stack->next;
460 /* Cross-references might be to things we haven't looked at
461 yet, e.g. type references. To avoid too many type
462 duplications we keep a quick fixup table, an array
463 of lists of references indexed by file descriptor */
465 struct mdebug_pending
467 struct mdebug_pending *next; /* link */
468 char *s; /* the unswapped symbol */
469 struct type *t; /* its partial type descriptor */
473 /* The pending information is kept for an entire object file, and used
474 to be in the deprecated_sym_private field. I took it out when I
475 split mdebugread from mipsread, because this might not be the only
476 type of symbols read from an object file. Instead, we allocate the
477 pending information table when we create the partial symbols, and
478 we store a pointer to the single table in each psymtab. */
480 static struct mdebug_pending **pending_list;
482 /* Check whether we already saw symbol SH in file FH */
484 static struct mdebug_pending *
485 is_pending_symbol (FDR *fh, char *sh)
487 int f_idx = fh - debug_info->fdr;
488 struct mdebug_pending *p;
490 /* Linear search is ok, list is typically no more than 10 deep */
491 for (p = pending_list[f_idx]; p; p = p->next)
497 /* Add a new symbol SH of type T */
500 add_pending (FDR *fh, char *sh, struct type *t)
502 int f_idx = fh - debug_info->fdr;
503 struct mdebug_pending *p = is_pending_symbol (fh, sh);
505 /* Make sure we do not make duplicates */
508 p = ((struct mdebug_pending *)
509 obstack_alloc (¤t_objfile->objfile_obstack,
510 sizeof (struct mdebug_pending)));
513 p->next = pending_list[f_idx];
514 pending_list[f_idx] = p;
519 /* Parsing Routines proper. */
521 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
522 For blocks, procedures and types we open a new lexical context.
523 This is basically just a big switch on the symbol's type. Argument
524 AX is the base pointer of aux symbols for this file (fh->iauxBase).
525 EXT_SH points to the unswapped symbol, which is needed for struct,
526 union, etc., types; it is NULL for an EXTR. BIGEND says whether
527 aux symbols are big-endian or little-endian. Return count of
528 SYMR's handled (normally one). */
531 mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
533 return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
536 static const struct symbol_register_ops mdebug_register_funcs = {
541 parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
542 struct section_offsets *section_offsets, struct objfile *objfile)
544 struct gdbarch *gdbarch = get_objfile_arch (objfile);
545 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
546 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
550 struct mdebug_pending *pend;
554 enum address_class class;
556 long svalue = sh->value;
559 if (ext_sh == (char *) NULL)
560 name = debug_info->ssext + sh->iss;
562 name = debug_info->ss + cur_fdr->issBase + sh->iss;
568 /* Do not relocate relative values.
569 The value of a stEnd symbol is the displacement from the
570 corresponding start symbol value.
571 The value of a stBlock symbol is the displacement from the
572 procedure address. */
573 if (sh->st != stEnd && sh->st != stBlock)
574 sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
581 sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
585 sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
594 case stGlobal: /* external symbol, goes into global block */
596 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
598 s = new_symbol (name);
599 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
602 case stStatic: /* static data, goes into current block. */
604 b = top_stack->cur_block;
605 s = new_symbol (name);
606 if (SC_IS_COMMON (sh->sc))
608 /* It is a FORTRAN common block. At least for SGI Fortran the
609 address is not in the symbol; we need to fix it later in
610 scan_file_globals. */
611 int bucket = hashname (SYMBOL_LINKAGE_NAME (s));
612 SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
613 global_sym_chain[bucket] = s;
616 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
619 case stLocal: /* local variable, goes into current block */
620 b = top_stack->cur_block;
621 s = new_symbol (name);
622 SYMBOL_VALUE (s) = svalue;
623 if (sh->sc == scRegister)
625 class = LOC_REGISTER;
626 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
631 data: /* Common code for symbols describing data */
632 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
633 SYMBOL_CLASS (s) = class;
634 add_symbol (s, top_stack->cur_st, b);
636 /* Type could be missing if file is compiled without debugging info. */
637 if (SC_IS_UNDEF (sh->sc)
638 || sh->sc == scNil || sh->index == indexNil)
639 SYMBOL_TYPE (s) = builtin_type (gdbarch)->nodebug_data_symbol;
641 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
642 /* Value of a data symbol is its memory address */
645 case stParam: /* arg to procedure, goes into current block */
647 found_ecoff_debugging_info = 1;
648 top_stack->numargs++;
650 /* Special GNU C++ name. */
651 if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0)
652 name = "this"; /* FIXME, not alloc'd in obstack */
653 s = new_symbol (name);
655 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
656 SYMBOL_IS_ARGUMENT (s) = 1;
660 /* Pass by value in register. */
661 SYMBOL_CLASS (s) = LOC_REGISTER;
662 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
665 /* Pass by reference on stack. */
666 SYMBOL_CLASS (s) = LOC_REF_ARG;
669 /* Pass by reference in register. */
670 SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
671 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
674 /* Pass by value on stack. */
675 SYMBOL_CLASS (s) = LOC_ARG;
678 SYMBOL_VALUE (s) = svalue;
679 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
680 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
683 case stLabel: /* label, goes into current block */
684 s = new_symbol (name);
685 SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* so that it can be used */
686 SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused */
687 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
688 SYMBOL_TYPE (s) = builtin_type (gdbarch)->builtin_int;
689 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
692 case stProc: /* Procedure, usually goes into global block */
693 case stStaticProc: /* Static procedure, goes into current block */
694 /* For stProc symbol records, we need to check the storage class
695 as well, as only (stProc, scText) entries represent "real"
696 procedures - See the Compaq document titled "Object File /
697 Symbol Table Format Specification" for more information.
698 If the storage class is not scText, we discard the whole block
699 of symbol records for this stProc. */
700 if (sh->st == stProc && sh->sc != scText)
702 char *ext_tsym = ext_sh;
703 int keep_counting = 1;
706 while (keep_counting)
708 ext_tsym += external_sym_size;
709 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
719 complaint (&symfile_complaints,
720 _("unknown symbol type 0x%x"), sh->st);
726 s = new_symbol (name);
727 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
728 SYMBOL_CLASS (s) = LOC_BLOCK;
729 /* Type of the return value */
730 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
731 t = builtin_type (gdbarch)->builtin_int;
734 t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
735 if (strcmp (name, "malloc") == 0
736 && TYPE_CODE (t) == TYPE_CODE_VOID)
738 /* I don't know why, but, at least under Alpha GNU/Linux,
739 when linking against a malloc without debugging
740 symbols, its read as a function returning void---this
741 is bad because it means we cannot call functions with
742 string arguments interactively; i.e., "call
743 printf("howdy\n")" would fail with the error message
744 "program has no memory available". To avoid this, we
745 patch up the type and make it void*
746 instead. (davidm@azstarnet.com)
748 t = make_pointer_type (t, NULL);
751 b = top_stack->cur_block;
752 if (sh->st == stProc)
754 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
755 /* The next test should normally be true, but provides a
756 hook for nested functions (which we don't want to make
758 if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
759 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
760 /* Irix 5 sometimes has duplicate names for the same
761 function. We want to add such names up at the global
762 level, not as a nested function. */
763 else if (sh->value == top_stack->procadr)
764 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
766 add_symbol (s, top_stack->cur_st, b);
768 /* Make a type for the procedure itself */
769 SYMBOL_TYPE (s) = lookup_function_type (t);
771 /* All functions in C++ have prototypes. For C we don't have enough
772 information in the debug info. */
773 if (SYMBOL_LANGUAGE (s) == language_cplus)
774 TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
776 /* Create and enter a new lexical context */
777 b = new_block (FUNCTION_BLOCK);
778 SYMBOL_BLOCK_VALUE (s) = b;
779 BLOCK_FUNCTION (b) = s;
780 BLOCK_START (b) = BLOCK_END (b) = sh->value;
781 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
782 add_block (b, top_stack->cur_st);
784 /* Not if we only have partial info */
785 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
789 top_stack->cur_block = b;
790 top_stack->blocktype = sh->st;
791 top_stack->cur_type = SYMBOL_TYPE (s);
792 top_stack->cur_field = -1;
793 top_stack->procadr = sh->value;
794 top_stack->numargs = 0;
797 /* Beginning of code for structure, union, and enum definitions.
798 They all share a common set of local variables, defined here. */
800 enum type_code type_code;
806 case stStruct: /* Start a block defining a struct type */
807 type_code = TYPE_CODE_STRUCT;
808 goto structured_common;
810 case stUnion: /* Start a block defining a union type */
811 type_code = TYPE_CODE_UNION;
812 goto structured_common;
814 case stEnum: /* Start a block defining an enum type */
815 type_code = TYPE_CODE_ENUM;
816 goto structured_common;
818 case stBlock: /* Either a lexical block, or some type */
819 if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc))
820 goto case_stBlock_code; /* Lexical block */
822 type_code = TYPE_CODE_UNDEF; /* We have a type. */
824 /* Common code for handling struct, union, enum, and/or as-yet-
825 unknown-type blocks of info about structured data. `type_code'
826 has been set to the proper TYPE_CODE, if we know it. */
828 found_ecoff_debugging_info = 1;
830 top_stack->blocktype = stBlock;
832 /* First count the number of fields and the highest value. */
835 for (ext_tsym = ext_sh + external_sym_size;
837 ext_tsym += external_sym_size)
841 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
846 /* C++ encodes class types as structures where there the
847 methods are encoded as stProc. The scope of stProc
848 symbols also ends with stEnd, thus creating a risk of
849 taking the wrong stEnd symbol record as the end of
850 the current struct, which would cause GDB to undercount
851 the real number of fields in this struct. To make sure
852 we really reached the right stEnd symbol record, we
853 check the associated name, and match it against the
854 struct name. Since method names are mangled while
855 the class name is not, there is no risk of having a
856 method whose name is identical to the class name
857 (in particular constructor method names are different
858 from the class name). There is therefore no risk that
859 this check stops the count on the StEnd of a method.
861 Also, assume that we're really at the end when tsym.iss
863 if (tsym.iss == issNull
864 || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss,
870 if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
872 /* If the type of the member is Nil (or Void),
873 without qualifiers, assume the tag is an
875 Alpha cc -migrate enums are recognized by a zero
876 index and a zero symbol value.
877 DU 4.0 cc enums are recognized by a member type of
878 btEnum without qualifiers and a zero symbol value. */
879 if (tsym.index == indexNil
880 || (tsym.index == 0 && sh->value == 0))
881 type_code = TYPE_CODE_ENUM;
884 (*debug_swap->swap_tir_in) (bigend,
885 &ax[tsym.index].a_ti,
887 if ((tir.bt == btNil || tir.bt == btVoid
888 || (tir.bt == btEnum && sh->value == 0))
890 type_code = TYPE_CODE_ENUM;
894 if (tsym.value > max_value)
895 max_value = tsym.value;
904 /* This is a no-op; is it trying to tell us something
905 we should be checking? */
906 if (tsym.sc == scVariant); /*UNIMPLEMENTED */
910 /* This is something like a struct within a
911 struct. Skip over the fields of the inner
912 struct. The -1 is because the for loop will
913 increment ext_tsym. */
914 ext_tsym = ((char *) debug_info->external_sym
915 + ((cur_fdr->isymBase + tsym.index - 1)
916 * external_sym_size));
922 /* mips cc puts out a typedef for struct x if it is not yet
923 defined when it encounters
924 struct y { struct x *xp; };
929 /* Irix5 cc puts out a stIndirect for struct x if it is not
930 yet defined when it encounters
931 struct y { struct x *xp; };
936 complaint (&symfile_complaints,
937 _("declaration block contains unhandled symbol type %d"),
943 /* In an stBlock, there is no way to distinguish structs,
944 unions, and enums at this point. This is a bug in the
945 original design (that has been fixed with the recent
946 addition of the stStruct, stUnion, and stEnum symbol
947 types.) The way you can tell is if/when you see a variable
948 or field of that type. In that case the variable's type
949 (in the AUX table) says if the type is struct, union, or
950 enum, and points back to the stBlock here. So you can
951 patch the tag kind up later - but only if there actually is
952 a variable or field of that type.
954 So until we know for sure, we will guess at this point.
956 If the first member has index==indexNil or a void type,
957 assume we have an enumeration.
958 Otherwise, if there is more than one member, and all
959 the members have offset 0, assume we have a union.
960 Otherwise, assume we have a struct.
962 The heuristic could guess wrong in the case of of an
963 enumeration with no members or a union with one (or zero)
964 members, or when all except the last field of a struct have
965 width zero. These are uncommon and/or illegal situations,
966 and in any case guessing wrong probably doesn't matter
969 But if we later do find out we were wrong, we fixup the tag
970 kind. Members of an enumeration must be handled
971 differently from struct/union fields, and that is harder to
972 patch up, but luckily we shouldn't need to. (If there are
973 any enumeration members, we can tell for sure it's an enum
976 if (type_code == TYPE_CODE_UNDEF)
978 if (nfields > 1 && max_value == 0)
979 type_code = TYPE_CODE_UNION;
981 type_code = TYPE_CODE_STRUCT;
984 /* Create a new type or use the pending type. */
985 pend = is_pending_symbol (cur_fdr, ext_sh);
986 if (pend == (struct mdebug_pending *) NULL)
989 add_pending (cur_fdr, ext_sh, t);
994 /* Do not set the tag name if it is a compiler generated tag name
995 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
996 Alpha cc puts out an sh->iss of zero for those. */
997 if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
998 TYPE_TAG_NAME (t) = NULL;
1000 TYPE_TAG_NAME (t) = obconcat (¤t_objfile->objfile_obstack,
1003 TYPE_CODE (t) = type_code;
1004 TYPE_LENGTH (t) = sh->value;
1005 TYPE_NFIELDS (t) = nfields;
1006 TYPE_FIELDS (t) = f = ((struct field *)
1008 nfields * sizeof (struct field)));
1010 if (type_code == TYPE_CODE_ENUM)
1012 int unsigned_enum = 1;
1014 /* This is a non-empty enum. */
1016 /* DEC c89 has the number of enumerators in the sh.value field,
1017 not the type length, so we have to compensate for that
1018 incompatibility quirk.
1019 This might do the wrong thing for an enum with one or two
1020 enumerators and gcc -gcoff -fshort-enums, but these cases
1021 are hopefully rare enough.
1022 Alpha cc -migrate has a sh.value field of zero, we adjust
1024 if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
1025 || TYPE_LENGTH (t) == 0)
1026 TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
1027 for (ext_tsym = ext_sh + external_sym_size;
1029 ext_tsym += external_sym_size)
1032 struct symbol *enum_sym;
1034 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
1036 if (tsym.st != stMember)
1039 SET_FIELD_BITPOS (*f, tsym.value);
1040 FIELD_TYPE (*f) = t;
1041 FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
1042 FIELD_BITSIZE (*f) = 0;
1044 enum_sym = ((struct symbol *)
1045 obstack_alloc (¤t_objfile->objfile_obstack,
1046 sizeof (struct symbol)));
1047 memset (enum_sym, 0, sizeof (struct symbol));
1048 SYMBOL_SET_LINKAGE_NAME
1049 (enum_sym, obsavestring (f->name, strlen (f->name),
1050 ¤t_objfile->objfile_obstack));
1051 SYMBOL_CLASS (enum_sym) = LOC_CONST;
1052 SYMBOL_TYPE (enum_sym) = t;
1053 SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
1054 SYMBOL_VALUE (enum_sym) = tsym.value;
1055 if (SYMBOL_VALUE (enum_sym) < 0)
1057 add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block);
1059 /* Skip the stMembers that we've handled. */
1064 TYPE_UNSIGNED (t) = 1;
1066 /* make this the current type */
1067 top_stack->cur_type = t;
1068 top_stack->cur_field = 0;
1070 /* Do not create a symbol for alpha cc unnamed structs. */
1074 /* gcc puts out an empty struct for an opaque struct definitions,
1075 do not create a symbol for it either. */
1076 if (TYPE_NFIELDS (t) == 0)
1082 s = new_symbol (name);
1083 SYMBOL_DOMAIN (s) = STRUCT_DOMAIN;
1084 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1085 SYMBOL_VALUE (s) = 0;
1086 SYMBOL_TYPE (s) = t;
1087 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1090 /* End of local variables shared by struct, union, enum, and
1091 block (as yet unknown struct/union/enum) processing. */
1095 found_ecoff_debugging_info = 1;
1096 /* beginnning of (code) block. Value of symbol
1097 is the displacement from procedure start */
1098 push_parse_stack ();
1100 /* Do not start a new block if this is the outermost block of a
1101 procedure. This allows the LOC_BLOCK symbol to point to the
1102 block with the local variables, so funcname::var works. */
1103 if (top_stack->blocktype == stProc
1104 || top_stack->blocktype == stStaticProc)
1106 top_stack->blocktype = stNil;
1110 top_stack->blocktype = stBlock;
1111 b = new_block (NON_FUNCTION_BLOCK);
1112 BLOCK_START (b) = sh->value + top_stack->procadr;
1113 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1114 top_stack->cur_block = b;
1115 add_block (b, top_stack->cur_st);
1118 case stEnd: /* end (of anything) */
1119 if (sh->sc == scInfo || SC_IS_COMMON (sh->sc))
1121 /* Finished with type */
1122 top_stack->cur_type = 0;
1124 else if (sh->sc == scText &&
1125 (top_stack->blocktype == stProc ||
1126 top_stack->blocktype == stStaticProc))
1128 /* Finished with procedure */
1129 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
1130 struct mdebug_extra_func_info *e;
1131 struct block *b = top_stack->cur_block;
1132 struct type *ftype = top_stack->cur_type;
1135 BLOCK_END (top_stack->cur_block) += sh->value; /* size */
1137 /* Make up special symbol to contain procedure specific info */
1138 s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
1139 SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
1140 SYMBOL_CLASS (s) = LOC_CONST;
1141 SYMBOL_TYPE (s) = builtin_type_void;
1142 e = ((struct mdebug_extra_func_info *)
1143 obstack_alloc (¤t_objfile->objfile_obstack,
1144 sizeof (struct mdebug_extra_func_info)));
1145 memset (e, 0, sizeof (struct mdebug_extra_func_info));
1146 SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
1147 e->numargs = top_stack->numargs;
1148 e->pdr.framereg = -1;
1149 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1151 /* f77 emits proc-level with address bounds==[0,0],
1152 So look for such child blocks, and patch them. */
1153 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
1155 struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
1156 if (BLOCK_SUPERBLOCK (b_bad) == b
1157 && BLOCK_START (b_bad) == top_stack->procadr
1158 && BLOCK_END (b_bad) == top_stack->procadr)
1160 BLOCK_START (b_bad) = BLOCK_START (b);
1161 BLOCK_END (b_bad) = BLOCK_END (b);
1165 if (TYPE_NFIELDS (ftype) <= 0)
1167 /* No parameter type information is recorded with the function's
1168 type. Set that from the type of the parameter symbols. */
1169 int nparams = top_stack->numargs;
1175 struct dict_iterator iter;
1176 TYPE_NFIELDS (ftype) = nparams;
1177 TYPE_FIELDS (ftype) = (struct field *)
1178 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
1181 ALL_BLOCK_SYMBOLS (b, iter, sym)
1183 if (iparams == nparams)
1186 if (SYMBOL_IS_ARGUMENT (sym))
1188 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
1189 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
1196 else if (sh->sc == scText && top_stack->blocktype == stBlock)
1198 /* End of (code) block. The value of the symbol is the
1199 displacement from the procedure`s start address of the
1200 end of this block. */
1201 BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
1203 else if (sh->sc == scText && top_stack->blocktype == stNil)
1205 /* End of outermost block. Pop parse stack and ignore. The
1206 following stEnd of stProc will take care of the block. */
1209 else if (sh->sc == scText && top_stack->blocktype == stFile)
1211 /* End of file. Pop parse stack and ignore. Higher
1212 level code deals with this. */
1216 complaint (&symfile_complaints,
1217 _("stEnd with storage class %d not handled"), sh->sc);
1219 pop_parse_stack (); /* restore previous lexical context */
1222 case stMember: /* member of struct or union */
1223 f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
1224 FIELD_NAME (*f) = name;
1225 SET_FIELD_BITPOS (*f, sh->value);
1227 FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name);
1228 FIELD_BITSIZE (*f) = bitsize;
1231 case stIndirect: /* forward declaration on Irix5 */
1232 /* Forward declarations from Irix5 cc are handled by cross_ref,
1236 case stTypedef: /* type definition */
1237 found_ecoff_debugging_info = 1;
1239 /* Typedefs for forward declarations and opaque structs from alpha cc
1240 are handled by cross_ref, skip them. */
1244 /* Parse the type or use the pending type. */
1245 pend = is_pending_symbol (cur_fdr, ext_sh);
1246 if (pend == (struct mdebug_pending *) NULL)
1248 t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name);
1249 add_pending (cur_fdr, ext_sh, t);
1254 /* mips cc puts out a typedef with the name of the struct for forward
1255 declarations. These should not go into the symbol table and
1256 TYPE_NAME should not be set for them.
1257 They can't be distinguished from an intentional typedef to
1258 the same name however:
1260 struct x { int ix; int jx; };
1264 struct xx {int ixx; int jxx; };
1265 generates a cross referencing stTypedef for x and xx.
1266 The user visible effect of this is that the type of a pointer
1267 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1268 The problem is fixed with alpha cc and Irix5 cc. */
1270 /* However if the typedef cross references to an opaque aggregate, it
1271 is safe to omit it from the symbol table. */
1273 if (has_opaque_xref (cur_fdr, sh))
1275 s = new_symbol (name);
1276 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
1277 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1278 SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
1279 SYMBOL_TYPE (s) = t;
1280 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1282 /* Incomplete definitions of structs should not get a name. */
1283 if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
1284 && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0
1285 || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT
1286 && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION)))
1288 if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR
1289 || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC)
1291 /* If we are giving a name to a type such as "pointer to
1292 foo" or "function returning foo", we better not set
1293 the TYPE_NAME. If the program contains "typedef char
1294 *caddr_t;", we don't want all variables of type char
1295 * to print as caddr_t. This is not just a
1296 consequence of GDB's type management; CC and GCC (at
1297 least through version 2.4) both output variables of
1298 either type char * or caddr_t with the type
1299 refering to the stTypedef symbol for caddr_t. If a future
1300 compiler cleans this up it GDB is not ready for it
1301 yet, but if it becomes ready we somehow need to
1302 disable this check (without breaking the PCC/GCC2.4
1307 Fortunately, this check seems not to be necessary
1308 for anything except pointers or functions. */
1311 TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s);
1315 case stFile: /* file name */
1316 push_parse_stack ();
1317 top_stack->blocktype = sh->st;
1320 /* I`ve never seen these for C */
1322 break; /* register relocation */
1324 break; /* forwarding address */
1326 break; /* constant */
1328 complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
1337 static const struct objfile_data *basic_type_data;
1339 static struct type *
1340 basic_type (int bt, struct objfile *objfile)
1342 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1343 struct type **map_bt = objfile_data (objfile, basic_type_data);
1351 map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack,
1352 btMax, struct type *);
1353 set_objfile_data (objfile, basic_type_data, map_bt);
1362 tp = builtin_type_void;
1366 tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED,
1368 TYPE_TARGET_TYPE (tp) = builtin_type_void;
1372 tp = init_type (TYPE_CODE_INT, 1, 0,
1377 tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
1378 "unsigned char", objfile);
1382 tp = init_type (TYPE_CODE_INT, 2, 0,
1387 tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
1388 "unsigned short", objfile);
1392 tp = init_type (TYPE_CODE_INT, 4, 0,
1397 tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1398 "unsigned int", objfile);
1402 tp = init_type (TYPE_CODE_INT, 4, 0,
1407 tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1408 "unsigned long", objfile);
1412 tp = init_type (TYPE_CODE_FLT,
1413 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1418 tp = init_type (TYPE_CODE_FLT,
1419 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1424 tp = init_type (TYPE_CODE_COMPLEX,
1425 2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1426 "complex", objfile);
1427 TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile);
1431 tp = init_type (TYPE_CODE_COMPLEX,
1432 2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1433 "double complex", objfile);
1434 TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile);
1438 /* We use TYPE_CODE_INT to print these as integers. Does this do any
1439 good? Would we be better off with TYPE_CODE_ERROR? Should
1440 TYPE_CODE_ERROR print things in hex if it knows the size? */
1441 tp = init_type (TYPE_CODE_INT,
1442 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1443 "fixed decimal", objfile);
1447 tp = init_type (TYPE_CODE_ERROR,
1448 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1449 "floating decimal", objfile);
1453 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
1455 tp = init_type (TYPE_CODE_STRING, 1, 0,
1460 tp = builtin_type_void;
1464 tp = init_type (TYPE_CODE_INT, 8, 0,
1469 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1470 "unsigned long", objfile);
1474 tp = init_type (TYPE_CODE_INT, 8, 0,
1475 "long long", objfile);
1479 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1480 "unsigned long long", objfile);
1484 tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED,
1486 TYPE_TARGET_TYPE (tp) = builtin_type_void;
1490 tp = init_type (TYPE_CODE_INT, 8, 0,
1495 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1496 "unsigned int", objfile);
1508 /* Parse the type information provided in the raw AX entries for
1509 the symbol SH. Return the bitfield size in BS, in case.
1510 We must byte-swap the AX entries before we use them; BIGEND says whether
1511 they are big-endian or little-endian (from fh->fBigendian). */
1513 static struct type *
1514 parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
1515 int bigend, char *sym_name)
1518 struct type *tp = 0;
1519 enum type_code type_code = TYPE_CODE_UNDEF;
1521 /* Handle undefined types, they have indexNil. */
1522 if (aux_index == indexNil)
1523 return basic_type (btInt, current_objfile);
1525 /* Handle corrupt aux indices. */
1526 if (aux_index >= (debug_info->fdr + fd)->caux)
1528 index_complaint (sym_name);
1529 return basic_type (btInt, current_objfile);
1533 /* Use aux as a type information record, map its basic type. */
1534 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1535 tp = basic_type (t->bt, current_objfile);
1538 /* Cannot use builtin types -- build our own */
1542 type_code = TYPE_CODE_STRUCT;
1545 type_code = TYPE_CODE_UNION;
1548 type_code = TYPE_CODE_ENUM;
1551 type_code = TYPE_CODE_RANGE;
1554 type_code = TYPE_CODE_SET;
1557 /* alpha cc -migrate uses this for typedefs. The true type will
1558 be obtained by crossreferencing below. */
1559 type_code = TYPE_CODE_ERROR;
1562 /* alpha cc uses this for typedefs. The true type will be
1563 obtained by crossreferencing below. */
1564 type_code = TYPE_CODE_ERROR;
1567 basic_type_complaint (t->bt, sym_name);
1568 return basic_type (btInt, current_objfile);
1572 /* Move on to next aux */
1577 int width = AUX_GET_WIDTH (bigend, ax);
1578 /* Inhibit core dumps if TIR is corrupted. */
1579 if (bs == (int *) NULL)
1581 /* Alpha cc -migrate encodes char and unsigned char types
1582 as short and unsigned short types with a field width of 8.
1583 Enum types also have a field width which we ignore for now. */
1584 if (t->bt == btShort && width == 8)
1585 tp = basic_type (btChar, current_objfile);
1586 else if (t->bt == btUShort && width == 8)
1587 tp = basic_type (btUChar, current_objfile);
1588 else if (t->bt == btEnum)
1591 complaint (&symfile_complaints, _("can't handle TIR fBitfield for %s"),
1599 /* A btIndirect entry cross references to an aux entry containing
1601 if (t->bt == btIndirect)
1608 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
1610 if (rn->rfd == 0xfff)
1612 rf = AUX_GET_ISYM (bigend, ax);
1620 complaint (&symfile_complaints,
1621 _("unable to cross ref btIndirect for %s"), sym_name);
1622 return basic_type (btInt, current_objfile);
1624 xref_fh = get_rfd (fd, rf);
1625 xref_fd = xref_fh - debug_info->fdr;
1626 tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase,
1627 rn->index, (int *) NULL, xref_fh->fBigendian, sym_name);
1630 /* All these types really point to some (common) MIPS type
1631 definition, and only the type-qualifiers fully identify
1632 them. We'll make the same effort at sharing. */
1633 if (t->bt == btStruct ||
1637 /* btSet (I think) implies that the name is a tag name, not a typedef
1638 name. This apparently is a MIPS extension for C sets. */
1643 /* Try to cross reference this type, build new type on failure. */
1644 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1645 if (tp == (struct type *) NULL)
1646 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1648 /* DEC c89 produces cross references to qualified aggregate types,
1649 dereference them. */
1650 while (TYPE_CODE (tp) == TYPE_CODE_PTR
1651 || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
1652 tp = TYPE_TARGET_TYPE (tp);
1654 /* Make sure that TYPE_CODE(tp) has an expected type code.
1655 Any type may be returned from cross_ref if file indirect entries
1657 if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
1658 && TYPE_CODE (tp) != TYPE_CODE_UNION
1659 && TYPE_CODE (tp) != TYPE_CODE_ENUM)
1661 unexpected_type_code_complaint (sym_name);
1666 /* Usually, TYPE_CODE(tp) is already type_code. The main
1667 exception is if we guessed wrong re struct/union/enum.
1668 But for struct vs. union a wrong guess is harmless, so
1669 don't complain(). */
1670 if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
1671 && type_code != TYPE_CODE_ENUM)
1672 || (TYPE_CODE (tp) != TYPE_CODE_ENUM
1673 && type_code == TYPE_CODE_ENUM))
1675 bad_tag_guess_complaint (sym_name);
1678 if (TYPE_CODE (tp) != type_code)
1680 TYPE_CODE (tp) = type_code;
1683 /* Do not set the tag name if it is a compiler generated tag name
1684 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1685 if (name[0] == '.' || name[0] == '\0')
1686 TYPE_TAG_NAME (tp) = NULL;
1687 else if (TYPE_TAG_NAME (tp) == NULL
1688 || strcmp (TYPE_TAG_NAME (tp), name) != 0)
1689 TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name),
1690 ¤t_objfile->objfile_obstack);
1694 /* All these types really point to some (common) MIPS type
1695 definition, and only the type-qualifiers fully identify
1696 them. We'll make the same effort at sharing.
1697 FIXME: We are not doing any guessing on range types. */
1698 if (t->bt == btRange)
1702 /* Try to cross reference this type, build new type on failure. */
1703 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1704 if (tp == (struct type *) NULL)
1705 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1707 /* Make sure that TYPE_CODE(tp) has an expected type code.
1708 Any type may be returned from cross_ref if file indirect entries
1710 if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
1712 unexpected_type_code_complaint (sym_name);
1716 /* Usually, TYPE_CODE(tp) is already type_code. The main
1717 exception is if we guessed wrong re struct/union/enum. */
1718 if (TYPE_CODE (tp) != type_code)
1720 bad_tag_guess_complaint (sym_name);
1721 TYPE_CODE (tp) = type_code;
1723 if (TYPE_NAME (tp) == NULL
1724 || strcmp (TYPE_NAME (tp), name) != 0)
1725 TYPE_NAME (tp) = obsavestring (name, strlen (name),
1726 ¤t_objfile->objfile_obstack);
1729 if (t->bt == btTypedef)
1733 /* Try to cross reference this type, it should succeed. */
1734 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1735 if (tp == (struct type *) NULL)
1737 complaint (&symfile_complaints,
1738 _("unable to cross ref btTypedef for %s"), sym_name);
1739 tp = basic_type (btInt, current_objfile);
1743 /* Deal with range types */
1744 if (t->bt == btRange)
1746 TYPE_NFIELDS (tp) = 2;
1747 TYPE_FIELDS (tp) = ((struct field *)
1748 TYPE_ALLOC (tp, 2 * sizeof (struct field)));
1749 TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
1750 ¤t_objfile->objfile_obstack);
1751 TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
1753 TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
1754 ¤t_objfile->objfile_obstack);
1755 TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
1759 /* Parse all the type qualifiers now. If there are more
1760 than 6 the game will continue in the next aux */
1764 #define PARSE_TQ(tq) \
1765 if (t->tq != tqNil) \
1766 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1778 /* mips cc 2.x and gcc never put out continued aux entries. */
1782 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1786 /* Complain for illegal continuations due to corrupt aux entries. */
1788 complaint (&symfile_complaints, _("illegal TIR continued for %s"), sym_name);
1793 /* Make up a complex type from a basic one. Type is passed by
1794 reference in TPP and side-effected as necessary. The type
1795 qualifier TQ says how to handle the aux symbols at AX for
1796 the symbol SX we are currently analyzing. BIGEND says whether
1797 aux symbols are big-endian or little-endian.
1798 Returns the number of aux symbols we parsed. */
1801 upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
1807 /* Used in array processing */
1818 t = lookup_pointer_type (*tpp);
1823 t = lookup_function_type (*tpp);
1830 /* Determine and record the domain type (type of index) */
1831 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx);
1837 rf = AUX_GET_ISYM (bigend, ax);
1840 fh = get_rfd (fd, rf);
1842 indx = parse_type (fh - debug_info->fdr,
1843 debug_info->external_aux + fh->iauxBase,
1844 id, (int *) NULL, bigend, sym_name);
1846 /* The bounds type should be an integer type, but might be anything
1847 else due to corrupt aux entries. */
1848 if (TYPE_CODE (indx) != TYPE_CODE_INT)
1850 complaint (&symfile_complaints,
1851 _("illegal array index type for %s, assuming int"), sym_name);
1852 indx = builtin_type_int32;
1855 /* Get the bounds, and create the array type. */
1857 lower = AUX_GET_DNLOW (bigend, ax);
1859 upper = AUX_GET_DNHIGH (bigend, ax);
1861 rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */
1863 range = create_range_type ((struct type *) NULL, indx,
1866 t = create_array_type ((struct type *) NULL, *tpp, range);
1868 /* We used to fill in the supplied array element bitsize
1869 here if the TYPE_LENGTH of the target type was zero.
1870 This happens for a `pointer to an array of anonymous structs',
1871 but in this case the array element bitsize is also zero,
1872 so nothing is gained.
1873 And we used to check the TYPE_LENGTH of the target type against
1874 the supplied array element bitsize.
1875 gcc causes a mismatch for `pointer to array of object',
1876 since the sdb directives it uses do not have a way of
1877 specifying the bitsize, but it does no harm (the
1878 TYPE_LENGTH should be correct) and we should be able to
1879 ignore the erroneous bitsize from the auxiliary entry safely.
1880 dbx seems to ignore it too. */
1882 /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */
1883 if (TYPE_LENGTH (*tpp) == 0)
1884 TYPE_TARGET_STUB (t) = 1;
1890 /* Volatile -- currently ignored */
1894 /* Const -- currently ignored */
1898 complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
1904 /* Parse a procedure descriptor record PR. Note that the procedure is
1905 parsed _after_ the local symbols, now we just insert the extra
1906 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1907 already been placed in the procedure's main block. Note also that
1908 images that have been partially stripped (ld -x) have been deprived
1909 of local symbols, and we have to cope with them here. FIRST_OFF is
1910 the offset of the first procedure for this FDR; we adjust the
1911 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1912 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1913 in question, or NULL to use top_stack->cur_block. */
1915 static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *);
1918 parse_procedure (PDR *pr, struct symtab *search_symtab,
1919 struct partial_symtab *pst)
1921 struct gdbarch *gdbarch = get_objfile_arch (pst->objfile);
1922 struct symbol *s, *i;
1926 /* Simple rule to find files linked "-x" */
1927 if (cur_fdr->rss == -1)
1931 /* Static procedure at address pr->adr. Sigh. */
1932 /* FIXME-32x64. assuming pr->adr fits in long. */
1933 complaint (&symfile_complaints,
1934 _("can't handle PDR for static proc at 0x%lx"),
1935 (unsigned long) pr->adr);
1943 (*debug_swap->swap_ext_in) (cur_bfd,
1944 ((char *) debug_info->external_ext
1946 * debug_swap->external_ext_size)),
1948 sh_name = debug_info->ssext + she.asym.iss;
1956 (*debug_swap->swap_sym_in) (cur_bfd,
1957 ((char *) debug_info->external_sym
1958 + ((cur_fdr->isymBase + pr->isym)
1959 * debug_swap->external_sym_size)),
1961 sh_name = debug_info->ss + cur_fdr->issBase + sh.iss;
1964 if (search_symtab != NULL)
1967 /* This loses both in the case mentioned (want a static, find a global),
1968 but also if we are looking up a non-mangled name which happens to
1969 match the name of a mangled function. */
1970 /* We have to save the cur_fdr across the call to lookup_symbol.
1971 If the pdr is for a static function and if a global function with
1972 the same name exists, lookup_symbol will eventually read in the symtab
1973 for the global function and clobber cur_fdr. */
1974 FDR *save_cur_fdr = cur_fdr;
1975 s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
1976 cur_fdr = save_cur_fdr;
1980 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
1986 s = mylookup_symbol (sh_name, top_stack->cur_block,
1987 VAR_DOMAIN, LOC_BLOCK);
1991 b = SYMBOL_BLOCK_VALUE (s);
1995 complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
1999 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
2000 s = new_symbol (sh_name);
2001 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
2002 SYMBOL_CLASS (s) = LOC_BLOCK;
2003 /* Donno its type, hope int is ok */
2005 = lookup_function_type (builtin_type (gdbarch)->builtin_int);
2006 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
2007 /* Wont have symbols for this one */
2009 SYMBOL_BLOCK_VALUE (s) = b;
2010 BLOCK_FUNCTION (b) = s;
2011 BLOCK_START (b) = pr->adr;
2012 /* BOUND used to be the end of procedure's text, but the
2013 argument is no longer passed in. */
2014 BLOCK_END (b) = bound;
2015 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
2016 add_block (b, top_stack->cur_st);
2020 i = mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST);
2024 struct mdebug_extra_func_info *e;
2026 e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i);
2029 /* GDB expects the absolute function start address for the
2030 procedure descriptor in e->pdr.adr.
2031 As the address in the procedure descriptor is usually relative,
2032 we would have to relocate e->pdr.adr with cur_fdr->adr and
2033 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
2034 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2035 in shared libraries on some systems, and on other systems
2036 e->pdr.adr is sometimes offset by a bogus value.
2037 To work around these problems, we replace e->pdr.adr with
2038 the start address of the function. */
2039 e->pdr.adr = BLOCK_START (b);
2042 /* It would be reasonable that functions that have been compiled
2043 without debugging info have a btNil type for their return value,
2044 and functions that are void and are compiled with debugging info
2046 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2047 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2049 The glevel field in cur_fdr could be used to determine the presence
2050 of debugging info, but GCC doesn't always pass the -g switch settings
2051 to the assembler and GAS doesn't set the glevel field from the -g switch
2053 To work around these problems, the return value type of a TYPE_CODE_VOID
2054 function is adjusted accordingly if no debugging info was found in the
2055 compilation unit. */
2057 if (processing_gcc_compilation == 0
2058 && found_ecoff_debugging_info == 0
2059 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
2060 SYMBOL_TYPE (s) = builtin_type (gdbarch)->nodebug_text_symbol;
2063 /* Parse the external symbol ES. Just call parse_symbol() after
2064 making sure we know where the aux are for it.
2065 BIGEND says whether aux entries are big-endian or little-endian.
2067 This routine clobbers top_stack->cur_block and ->cur_st. */
2069 static void parse_external (EXTR *, int, struct section_offsets *,
2073 parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
2074 struct objfile *objfile)
2078 if (es->ifd != ifdNil)
2081 cur_fdr = debug_info->fdr + cur_fd;
2082 ax = debug_info->external_aux + cur_fdr->iauxBase;
2086 cur_fdr = debug_info->fdr;
2090 /* Reading .o files */
2091 if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil)
2094 switch (es->asym.st)
2097 /* These are generated for static symbols in .o files,
2118 /* FIXME: Turn this into a complaint? */
2120 printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
2121 what, debug_info->ssext + es->asym.iss,
2122 fdr_name (cur_fdr));
2126 switch (es->asym.st)
2130 /* There is no need to parse the external procedure symbols.
2131 If they are from objects compiled without -g, their index will
2132 be indexNil, and the symbol definition from the minimal symbol
2133 is preferrable (yielding a function returning int instead of int).
2134 If the index points to a local procedure symbol, the local
2135 symbol already provides the correct type.
2136 Note that the index of the external procedure symbol points
2137 to the local procedure symbol in the local symbol table, and
2138 _not_ to the auxiliary symbol info. */
2142 /* Global common symbols are resolved by the runtime loader,
2144 if (SC_IS_COMMON (es->asym.sc))
2147 /* Note that the case of a symbol with indexNil must be handled
2148 anyways by parse_symbol(). */
2149 parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets, objfile);
2156 /* Parse the line number info for file descriptor FH into
2157 GDB's linetable LT. MIPS' encoding requires a little bit
2158 of magic to get things out. Note also that MIPS' line
2159 numbers can go back and forth, apparently we can live
2160 with that and do not need to reorder our linetables */
2162 static void parse_lines (FDR *, PDR *, struct linetable *, int,
2163 struct partial_symtab *, CORE_ADDR);
2166 parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
2167 struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr)
2169 unsigned char *base;
2171 int delta, count, lineno = 0;
2173 if (fh->cbLine == 0)
2176 /* Scan by procedure descriptors */
2178 for (j = 0; j < fh->cpd; j++, pr++)
2182 unsigned char *halt;
2184 /* No code for this one */
2185 if (pr->iline == ilineNil ||
2186 pr->lnLow == -1 || pr->lnHigh == -1)
2189 /* Determine start and end address of compressed line bytes for
2191 base = debug_info->line + fh->cbLineOffset;
2192 if (j != (fh->cpd - 1))
2193 halt = base + pr[1].cbLineOffset;
2195 halt = base + fh->cbLine;
2196 base += pr->cbLineOffset;
2198 adr = pst->textlow + pr->adr - lowest_pdr_addr;
2200 l = adr >> 2; /* in words */
2201 for (lineno = pr->lnLow; base < halt;)
2203 count = *base & 0x0f;
2204 delta = *base++ >> 4;
2209 delta = (base[0] << 8) | base[1];
2210 if (delta >= 0x8000)
2214 lineno += delta; /* first delta is 0 */
2216 /* Complain if the line table overflows. Could happen
2217 with corrupt binaries. */
2218 if (lt->nitems >= maxlines)
2220 complaint (&symfile_complaints,
2221 _("guessed size of linetable for %s incorrectly"),
2225 k = add_line (lt, lineno, l, k);
2232 function_outside_compilation_unit_complaint (const char *arg1)
2234 complaint (&symfile_complaints,
2235 _("function `%s' appears to be defined outside of all compilation units"),
2239 /* Use the STORAGE_CLASS to compute which section the given symbol
2240 belongs to, and then records this new minimal symbol. */
2243 record_minimal_symbol (const char *name, const CORE_ADDR address,
2244 enum minimal_symbol_type ms_type, int storage_class,
2245 struct objfile *objfile)
2248 asection *bfd_section;
2250 switch (storage_class)
2253 section = SECT_OFF_TEXT (objfile);
2254 bfd_section = bfd_get_section_by_name (cur_bfd, ".text");
2257 section = SECT_OFF_DATA (objfile);
2258 bfd_section = bfd_get_section_by_name (cur_bfd, ".data");
2261 section = SECT_OFF_BSS (objfile);
2262 bfd_section = bfd_get_section_by_name (cur_bfd, ".bss");
2265 section = get_section_index (objfile, ".sdata");
2266 bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata");
2269 section = get_section_index (objfile, ".sbss");
2270 bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss");
2273 section = get_section_index (objfile, ".rdata");
2274 bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata");
2277 section = get_section_index (objfile, ".init");
2278 bfd_section = bfd_get_section_by_name (cur_bfd, ".init");
2281 section = get_section_index (objfile, ".xdata");
2282 bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata");
2285 section = get_section_index (objfile, ".pdata");
2286 bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata");
2289 section = get_section_index (objfile, ".fini");
2290 bfd_section = bfd_get_section_by_name (cur_bfd, ".fini");
2293 section = get_section_index (objfile, ".rconst");
2294 bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst");
2298 section = get_section_index (objfile, ".tlsdata");
2299 bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata");
2304 section = get_section_index (objfile, ".tlsbss");
2305 bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss");
2309 /* This kind of symbol is not associated to a section. */
2314 prim_record_minimal_symbol_and_info (name, address, ms_type,
2315 section, bfd_section, objfile);
2318 /* Master parsing procedure for first-pass reading of file symbols
2319 into a partial_symtab. */
2322 parse_partial_symbols (struct objfile *objfile)
2324 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2325 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
2326 const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
2327 const bfd_size_type external_ext_size = debug_swap->external_ext_size;
2328 void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in;
2329 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
2330 void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in;
2332 HDRR *hdr = &debug_info->symbolic_header;
2333 /* Running pointers */
2341 struct partial_symtab *pst;
2342 int textlow_not_set = 1;
2343 int past_first_source_file = 0;
2345 /* List of current psymtab's include files */
2346 char **psymtab_include_list;
2347 int includes_allocated;
2350 struct pst_map *fdr_to_pst;
2351 /* Index within current psymtab dependency list */
2352 struct partial_symtab **dependency_list;
2353 int dependencies_used, dependencies_allocated;
2354 struct cleanup *old_chain;
2356 enum language prev_language;
2357 asection *text_sect;
2358 int relocatable = 0;
2360 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2361 the shared libraries are prelinked at a high memory address.
2362 We have to adjust the start address of the object file for this case,
2363 by setting it to the start address of the first procedure in the file.
2364 But we should do no adjustments if we are debugging a .o file, where
2365 the text section (and fh->adr) really starts at zero. */
2366 text_sect = bfd_get_section_by_name (cur_bfd, ".text");
2367 if (text_sect != NULL
2368 && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
2371 extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack,
2372 sizeof (EXTR) * hdr->iextMax);
2374 includes_allocated = 30;
2376 psymtab_include_list = (char **) alloca (includes_allocated *
2378 next_symbol_text_func = mdebug_next_symbol_text;
2380 dependencies_allocated = 30;
2381 dependencies_used = 0;
2383 (struct partial_symtab **) alloca (dependencies_allocated *
2384 sizeof (struct partial_symtab *));
2386 last_source_file = NULL;
2391 * Only parse the Local and External symbols, and the Relative FDR.
2392 * Fixup enough of the loader symtab to be able to use it.
2393 * Allocate space only for the file's portions we need to
2398 max_glevel = MIN_GLEVEL;
2400 /* Allocate the map FDR -> PST.
2401 Minor hack: -O3 images might claim some global data belongs
2402 to FDR -1. We`ll go along with that */
2403 fdr_to_pst = (struct pst_map *) xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
2404 old_chain = make_cleanup (xfree, fdr_to_pst);
2407 struct partial_symtab *pst = new_psymtab ("", objfile);
2408 fdr_to_pst[-1].pst = pst;
2412 /* Allocate the global pending list. */
2414 ((struct mdebug_pending **)
2415 obstack_alloc (&objfile->objfile_obstack,
2416 hdr->ifdMax * sizeof (struct mdebug_pending *)));
2417 memset (pending_list, 0,
2418 hdr->ifdMax * sizeof (struct mdebug_pending *));
2420 /* Pass 0 over external syms: swap them in. */
2421 ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
2422 make_cleanup (xfree, ext_block);
2424 ext_out = (char *) debug_info->external_ext;
2425 ext_out_end = ext_out + hdr->iextMax * external_ext_size;
2427 for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
2428 (*swap_ext_in) (cur_bfd, ext_out, ext_in);
2430 /* Pass 1 over external syms: Presize and partition the list */
2432 ext_in_end = ext_in + hdr->iextMax;
2433 for (; ext_in < ext_in_end; ext_in++)
2435 /* See calls to complain below. */
2436 if (ext_in->ifd >= -1
2437 && ext_in->ifd < hdr->ifdMax
2438 && ext_in->asym.iss >= 0
2439 && ext_in->asym.iss < hdr->issExtMax)
2440 fdr_to_pst[ext_in->ifd].n_globals++;
2443 /* Pass 1.5 over files: partition out global symbol space */
2445 for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++)
2447 fdr_to_pst[f_idx].globals_offset = s_idx;
2448 s_idx += fdr_to_pst[f_idx].n_globals;
2449 fdr_to_pst[f_idx].n_globals = 0;
2454 For ECOFF in ELF, we skip the creation of the minimal symbols.
2455 The ECOFF symbols should be a subset of the Elf symbols, and the
2456 section information of the elf symbols will be more accurate.
2457 FIXME! What about Irix 5's native linker?
2459 By default, Elf sections which don't exist in ECOFF
2460 get put in ECOFF's absolute section by the gnu linker.
2461 Since absolute sections don't get relocated, we
2462 end up calculating an address different from that of
2463 the symbol's minimal symbol (created earlier from the
2466 To fix this, either :
2467 1) don't create the duplicate symbol
2468 (assumes ECOFF symtab is a subset of the ELF symtab;
2469 assumes no side-effects result from ignoring ECOFF symbol)
2470 2) create it, only if lookup for existing symbol in ELF's minimal
2473 assumes no side-effects result from ignoring ECOFF symbol)
2474 3) create it, but lookup ELF's minimal symbol and use it's section
2475 during relocation, then modify "uniqify" phase to merge and
2476 eliminate the duplicate symbol
2477 (highly inefficient)
2479 I've implemented #1 here...
2480 Skip the creation of the minimal symbols based on the ECOFF
2483 /* Pass 2 over external syms: fill in external symbols */
2485 ext_in_end = ext_in + hdr->iextMax;
2486 for (; ext_in < ext_in_end; ext_in++)
2488 enum minimal_symbol_type ms_type = mst_text;
2489 CORE_ADDR svalue = ext_in->asym.value;
2491 /* The Irix 5 native tools seem to sometimes generate bogus
2492 external symbols. */
2493 if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
2495 complaint (&symfile_complaints,
2496 _("bad ifd for external symbol: %d (max %ld)"), ext_in->ifd,
2500 if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
2502 complaint (&symfile_complaints,
2503 _("bad iss for external symbol: %ld (max %ld)"),
2504 ext_in->asym.iss, hdr->issExtMax);
2508 extern_tab[fdr_to_pst[ext_in->ifd].globals_offset
2509 + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in;
2512 if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil)
2516 /* Pass 3 over files, over local syms: fill in static symbols */
2517 name = debug_info->ssext + ext_in->asym.iss;
2519 /* Process ECOFF Symbol Types and Storage Classes */
2520 switch (ext_in->asym.st)
2523 /* Beginnning of Procedure */
2524 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2527 /* Load time only static procs */
2528 ms_type = mst_file_text;
2529 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2532 /* External symbol */
2533 if (SC_IS_COMMON (ext_in->asym.sc))
2535 /* The value of a common symbol is its size, not its address.
2539 else if (SC_IS_DATA (ext_in->asym.sc))
2542 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2544 else if (SC_IS_BSS (ext_in->asym.sc))
2547 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2549 else if (SC_IS_SBSS (ext_in->asym.sc))
2552 svalue += ANOFFSET (objfile->section_offsets,
2553 get_section_index (objfile, ".sbss"));
2561 /* On certain platforms, some extra label symbols can be
2562 generated by the linker. One possible usage for this kind
2563 of symbols is to represent the address of the begining of a
2564 given section. For instance, on Tru64 5.1, the address of
2565 the _ftext label is the start address of the .text section.
2567 The storage class of these symbols is usually directly
2568 related to the section to which the symbol refers. For
2569 instance, on Tru64 5.1, the storage class for the _fdata
2570 label is scData, refering to the .data section.
2572 It is actually possible that the section associated to the
2573 storage class of the label does not exist. On True64 5.1
2574 for instance, the libm.so shared library does not contain
2575 any .data section, although it contains a _fpdata label
2576 which storage class is scData... Since these symbols are
2577 usually useless for the debugger user anyway, we just
2578 discard these symbols.
2581 if (SC_IS_TEXT (ext_in->asym.sc))
2583 if (objfile->sect_index_text == -1)
2586 ms_type = mst_file_text;
2587 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2589 else if (SC_IS_DATA (ext_in->asym.sc))
2591 if (objfile->sect_index_data == -1)
2594 ms_type = mst_file_data;
2595 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2597 else if (SC_IS_BSS (ext_in->asym.sc))
2599 if (objfile->sect_index_bss == -1)
2602 ms_type = mst_file_bss;
2603 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2605 else if (SC_IS_SBSS (ext_in->asym.sc))
2607 const int sbss_sect_index = get_section_index (objfile, ".sbss");
2609 if (sbss_sect_index == -1)
2612 ms_type = mst_file_bss;
2613 svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index);
2620 /* The alpha has the section start addresses in stLocal symbols
2621 whose name starts with a `.'. Skip those but complain for all
2622 other stLocal symbols.
2623 Irix6 puts the section start addresses in stNil symbols, skip
2629 ms_type = mst_unknown;
2630 unknown_ext_complaint (name);
2632 if (!ECOFF_IN_ELF (cur_bfd))
2633 record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc,
2637 /* Pass 3 over files, over local syms: fill in static symbols */
2638 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
2640 struct partial_symtab *save_pst;
2644 cur_fdr = fh = debug_info->fdr + f_idx;
2648 fdr_to_pst[f_idx].pst = NULL;
2652 /* Determine the start address for this object file from the
2653 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2657 if (relocatable || textlow != 0)
2658 textlow += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2662 pst = start_psymtab_common (objfile, objfile->section_offsets,
2665 objfile->global_psymbols.next,
2666 objfile->static_psymbols.next);
2667 pst->read_symtab_private = ((char *)
2668 obstack_alloc (&objfile->objfile_obstack,
2669 sizeof (struct symloc)));
2670 memset (pst->read_symtab_private, 0, sizeof (struct symloc));
2673 FDR_IDX (pst) = f_idx;
2674 CUR_BFD (pst) = cur_bfd;
2675 DEBUG_SWAP (pst) = debug_swap;
2676 DEBUG_INFO (pst) = debug_info;
2677 PENDING_LIST (pst) = pending_list;
2679 /* The way to turn this into a symtab is to call... */
2680 pst->read_symtab = mdebug_psymtab_to_symtab;
2682 /* Set up language for the pst.
2683 The language from the FDR is used if it is unambigious (e.g. cfront
2684 with native cc and g++ will set the language to C).
2685 Otherwise we have to deduce the language from the filename.
2686 Native ecoff has every header file in a separate FDR, so
2687 deduce_language_from_filename will return language_unknown for
2688 a header file, which is not what we want.
2689 But the FDRs for the header files are after the FDR for the source
2690 file, so we can assign the language of the source file to the
2691 following header files. Then we save the language in the private
2692 pst data so that we can reuse it when building symtabs. */
2693 prev_language = psymtab_language;
2697 case langCplusplusV2:
2698 psymtab_language = language_cplus;
2701 psymtab_language = deduce_language_from_filename (fdr_name (fh));
2704 if (psymtab_language == language_unknown)
2705 psymtab_language = prev_language;
2706 PST_PRIVATE (pst)->pst_language = psymtab_language;
2708 pst->texthigh = pst->textlow;
2710 /* For stabs-in-ecoff files, the second symbol must be @stab.
2711 This symbol is emitted by mips-tfile to signal that the
2712 current object file uses encapsulated stabs instead of mips
2713 ecoff for local symbols. (It is the second symbol because
2714 the first symbol is the stFile used to signal the start of a
2716 processing_gcc_compilation = 0;
2719 (*swap_sym_in) (cur_bfd,
2720 ((char *) debug_info->external_sym
2721 + (fh->isymBase + 1) * external_sym_size),
2723 if (strcmp (debug_info->ss + fh->issBase + sh.iss,
2725 processing_gcc_compilation = 2;
2728 if (processing_gcc_compilation != 0)
2730 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
2735 (*swap_sym_in) (cur_bfd,
2736 (((char *) debug_info->external_sym)
2737 + (fh->isymBase + cur_sdx) * external_sym_size),
2739 type_code = ECOFF_UNMARK_STAB (sh.index);
2740 if (!ECOFF_IS_STAB (&sh))
2742 if (sh.st == stProc || sh.st == stStaticProc)
2747 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2748 if (sh.st == stStaticProc)
2750 namestring = debug_info->ss + fh->issBase + sh.iss;
2751 record_minimal_symbol (namestring, sh.value,
2752 mst_file_text, sh.sc,
2755 procaddr = sh.value;
2757 isym = AUX_GET_ISYM (fh->fBigendian,
2758 (debug_info->external_aux
2761 (*swap_sym_in) (cur_bfd,
2762 ((char *) debug_info->external_sym
2763 + ((fh->isymBase + isym - 1)
2764 * external_sym_size)),
2768 CORE_ADDR high = procaddr + sh.value;
2770 /* Kludge for Irix 5.2 zero fh->adr. */
2772 && (pst->textlow == 0 || procaddr < pst->textlow))
2773 pst->textlow = procaddr;
2774 if (high > pst->texthigh)
2775 pst->texthigh = high;
2778 else if (sh.st == stStatic)
2793 namestring = debug_info->ss + fh->issBase + sh.iss;
2794 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2795 record_minimal_symbol (namestring, sh.value,
2796 mst_file_data, sh.sc,
2801 /* FIXME! Shouldn't this use cases for bss,
2802 then have the default be abs? */
2803 namestring = debug_info->ss + fh->issBase + sh.iss;
2804 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2805 record_minimal_symbol (namestring, sh.value,
2806 mst_file_bss, sh.sc,
2813 /* Handle stabs continuation */
2815 char *stabstring = debug_info->ss + fh->issBase + sh.iss;
2816 int len = strlen (stabstring);
2817 while (stabstring[len - 1] == '\\')
2820 char *stabstring1 = stabstring;
2824 /* Ignore continuation char from 1st string */
2827 /* Read next stabstring */
2829 (*swap_sym_in) (cur_bfd,
2830 (((char *) debug_info->external_sym)
2831 + (fh->isymBase + cur_sdx)
2832 * external_sym_size),
2834 stabstring2 = debug_info->ss + fh->issBase + sh2.iss;
2835 len2 = strlen (stabstring2);
2837 /* Concatinate stabstring2 with stabstring1 */
2839 && stabstring != debug_info->ss + fh->issBase + sh.iss)
2840 stabstring = xrealloc (stabstring, len + len2 + 1);
2843 stabstring = xmalloc (len + len2 + 1);
2844 strcpy (stabstring, stabstring1);
2846 strcpy (stabstring + len, stabstring2);
2854 * Standard, external, non-debugger, symbols
2857 case N_TEXT | N_EXT:
2858 case N_NBTEXT | N_EXT:
2859 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2862 case N_DATA | N_EXT:
2863 case N_NBDATA | N_EXT:
2864 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2869 case N_NBBSS | N_EXT:
2870 case N_SETV | N_EXT: /* FIXME, is this in BSS? */
2871 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2878 /* Standard, local, non-debugger, symbols */
2882 /* We need to be able to deal with both N_FN or N_TEXT,
2883 because we have no way of knowing whether the sys-supplied ld
2884 or GNU ld was used to make the executable. Sequents throw
2885 in another wrinkle -- they renumbered N_FN. */
2893 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2896 case N_UNDF | N_EXT:
2897 continue; /* Just undefined, not COMMON */
2902 /* Lots of symbol types we can just ignore. */
2909 /* Keep going . . . */
2912 * Special symbol types for GNU
2915 case N_INDR | N_EXT:
2917 case N_SETA | N_EXT:
2919 case N_SETT | N_EXT:
2921 case N_SETD | N_EXT:
2923 case N_SETB | N_EXT:
2934 static int prev_so_symnum = -10;
2935 static int first_so_symnum;
2937 int prev_textlow_not_set;
2939 valu = sh.value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2941 prev_textlow_not_set = textlow_not_set;
2943 /* A zero value is probably an indication for the SunPRO 3.0
2944 compiler. end_psymtab explicitly tests for zero, so
2945 don't relocate it. */
2948 && gdbarch_sofun_address_maybe_missing (gdbarch))
2950 textlow_not_set = 1;
2954 textlow_not_set = 0;
2956 past_first_source_file = 1;
2958 if (prev_so_symnum != symnum - 1)
2959 { /* Here if prev stab wasn't N_SO */
2960 first_so_symnum = symnum;
2964 pst = (struct partial_symtab *) 0;
2966 dependencies_used = 0;
2970 prev_so_symnum = symnum;
2972 /* End the current partial symtab and start a new one */
2974 /* SET_NAMESTRING ();*/
2975 namestring = stabstring;
2977 /* Null name means end of .o file. Don't start a new one. */
2978 if (*namestring == '\000')
2981 /* Some compilers (including gcc) emit a pair of initial N_SOs.
2982 The first one is a directory name; the second the file name.
2983 If pst exists, is empty, and has a filename ending in '/',
2984 we assume the previous N_SO was a directory name. */
2986 p = strrchr (namestring, '/');
2987 if (p && *(p + 1) == '\000')
2988 continue; /* Simply ignore directory name SOs */
2990 /* Some other compilers (C++ ones in particular) emit useless
2991 SOs for non-existant .c files. We ignore all subsequent SOs that
2992 immediately follow the first. */
3004 enum language tmp_language;
3005 /* Mark down an include file in the current psymtab */
3007 /* SET_NAMESTRING ();*/
3008 namestring = stabstring;
3010 tmp_language = deduce_language_from_filename (namestring);
3012 /* Only change the psymtab's language if we've learned
3013 something useful (eg. tmp_language is not language_unknown).
3014 In addition, to match what start_subfile does, never change
3016 if (tmp_language != language_unknown
3017 && (tmp_language != language_c
3018 || psymtab_language != language_cplus))
3019 psymtab_language = tmp_language;
3021 /* In C++, one may expect the same filename to come round many
3022 times, when code is coming alternately from the main file
3023 and from inline functions in other files. So I check to see
3024 if this is a file we've seen before -- either the main
3025 source file, or a previously included file.
3027 This seems to be a lot of time to be spending on N_SOL, but
3028 things like "break c-exp.y:435" need to work (I
3029 suppose the psymtab_include_list could be hashed or put
3030 in a binary tree, if profiling shows this is a major hog). */
3031 if (pst && strcmp (namestring, pst->filename) == 0)
3035 for (i = 0; i < includes_used; i++)
3036 if (strcmp (namestring,
3037 psymtab_include_list[i]) == 0)
3046 psymtab_include_list[includes_used++] = namestring;
3047 if (includes_used >= includes_allocated)
3049 char **orig = psymtab_include_list;
3051 psymtab_include_list = (char **)
3052 alloca ((includes_allocated *= 2) *
3054 memcpy (psymtab_include_list, orig,
3055 includes_used * sizeof (char *));
3059 case N_LSYM: /* Typedef or automatic variable. */
3060 case N_STSYM: /* Data seg var -- static */
3061 case N_LCSYM: /* BSS " */
3062 case N_ROSYM: /* Read-only data seg var -- static. */
3063 case N_NBSTS: /* Gould nobase. */
3064 case N_NBLCS: /* symbols. */
3066 case N_GSYM: /* Global (extern) variable; can be
3067 data or bss (sigh FIXME). */
3069 /* Following may probably be ignored; I'll leave them here
3070 for now (until I do Pascal and Modula 2 extensions). */
3072 case N_PC: /* I may or may not need this; I
3074 case N_M2C: /* I suspect that I can ignore this here. */
3075 case N_SCOPE: /* Same. */
3077 /* SET_NAMESTRING ();*/
3078 namestring = stabstring;
3079 p = (char *) strchr (namestring, ':');
3081 continue; /* Not a debugging symbol. */
3085 /* Main processing section for debugging symbols which
3086 the initial read through the symbol tables needs to worry
3087 about. If we reach this point, the symbol which we are
3088 considering is definitely one we are interested in.
3089 p must also contain the (valid) index into the namestring
3090 which indicates the debugging type symbol. */
3095 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3097 if (gdbarch_static_transform_name_p (gdbarch))
3098 namestring = gdbarch_static_transform_name
3099 (gdbarch, namestring);
3101 add_psymbol_to_list (namestring, p - namestring,
3102 VAR_DOMAIN, LOC_STATIC,
3103 &objfile->static_psymbols,
3105 psymtab_language, objfile);
3108 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3109 /* The addresses in these entries are reported to be
3110 wrong. See the code that reads 'G's for symtabs. */
3111 add_psymbol_to_list (namestring, p - namestring,
3112 VAR_DOMAIN, LOC_STATIC,
3113 &objfile->global_psymbols,
3115 psymtab_language, objfile);
3119 /* When a 'T' entry is defining an anonymous enum, it
3120 may have a name which is the empty string, or a
3121 single space. Since they're not really defining a
3122 symbol, those shouldn't go in the partial symbol
3123 table. We do pick up the elements of such enums at
3124 'check_enum:', below. */
3125 if (p >= namestring + 2
3126 || (p == namestring + 1
3127 && namestring[0] != ' '))
3129 add_psymbol_to_list (namestring, p - namestring,
3130 STRUCT_DOMAIN, LOC_TYPEDEF,
3131 &objfile->static_psymbols,
3133 psymtab_language, objfile);
3136 /* Also a typedef with the same name. */
3137 add_psymbol_to_list (namestring, p - namestring,
3138 VAR_DOMAIN, LOC_TYPEDEF,
3139 &objfile->static_psymbols,
3141 psymtab_language, objfile);
3147 if (p != namestring) /* a name is there, not just :T... */
3149 add_psymbol_to_list (namestring, p - namestring,
3150 VAR_DOMAIN, LOC_TYPEDEF,
3151 &objfile->static_psymbols,
3153 psymtab_language, objfile);
3156 /* If this is an enumerated type, we need to
3157 add all the enum constants to the partial symbol
3158 table. This does not cover enums without names, e.g.
3159 "enum {a, b} c;" in C, but fortunately those are
3160 rare. There is no way for GDB to find those from the
3161 enum type without spending too much time on it. Thus
3162 to solve this problem, the compiler needs to put out the
3163 enum in a nameless type. GCC2 does this. */
3165 /* We are looking for something of the form
3166 <name> ":" ("t" | "T") [<number> "="] "e"
3167 {<constant> ":" <value> ","} ";". */
3169 /* Skip over the colon and the 't' or 'T'. */
3171 /* This type may be given a number. Also, numbers can come
3172 in pairs like (0,26). Skip over it. */
3173 while ((*p >= '0' && *p <= '9')
3174 || *p == '(' || *p == ',' || *p == ')'
3180 /* The aix4 compiler emits extra crud before the members. */
3183 /* Skip over the type (?). */
3187 /* Skip over the colon. */
3191 /* We have found an enumerated type. */
3192 /* According to comments in read_enum_type
3193 a comma could end it instead of a semicolon.
3194 I don't know where that happens.
3196 while (*p && *p != ';' && *p != ',')
3200 /* Check for and handle cretinous dbx symbol name
3202 if (*p == '\\' || (*p == '?' && p[1] == '\0'))
3203 p = next_symbol_text (objfile);
3205 /* Point to the character after the name
3206 of the enum constant. */
3207 for (q = p; *q && *q != ':'; q++)
3209 /* Note that the value doesn't matter for
3210 enum constants in psymtabs, just in symtabs. */
3211 add_psymbol_to_list (p, q - p,
3212 VAR_DOMAIN, LOC_CONST,
3213 &objfile->static_psymbols, 0,
3214 0, psymtab_language, objfile);
3215 /* Point past the name. */
3217 /* Skip over the value. */
3218 while (*p && *p != ',')
3220 /* Advance past the comma. */
3227 /* Constant, e.g. from "const" in Pascal. */
3228 add_psymbol_to_list (namestring, p - namestring,
3229 VAR_DOMAIN, LOC_CONST,
3230 &objfile->static_psymbols, sh.value,
3231 0, psymtab_language, objfile);
3237 int name_len = p - namestring;
3238 char *name = xmalloc (name_len + 1);
3239 memcpy (name, namestring, name_len);
3240 name[name_len] = '\0';
3241 function_outside_compilation_unit_complaint (name);
3244 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3245 add_psymbol_to_list (namestring, p - namestring,
3246 VAR_DOMAIN, LOC_BLOCK,
3247 &objfile->static_psymbols,
3249 psymtab_language, objfile);
3252 /* Global functions were ignored here, but now they
3253 are put into the global psymtab like one would expect.
3254 They're also in the minimal symbol table. */
3258 int name_len = p - namestring;
3259 char *name = xmalloc (name_len + 1);
3260 memcpy (name, namestring, name_len);
3261 name[name_len] = '\0';
3262 function_outside_compilation_unit_complaint (name);
3265 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3266 add_psymbol_to_list (namestring, p - namestring,
3267 VAR_DOMAIN, LOC_BLOCK,
3268 &objfile->global_psymbols,
3270 psymtab_language, objfile);
3273 /* Two things show up here (hopefully); static symbols of
3274 local scope (static used inside braces) or extensions
3275 of structure symbols. We can ignore both. */
3289 case '#': /* for symbol identification (used in live ranges) */
3293 /* It is a C++ nested symbol. We don't need to record it
3294 (I don't think); if we try to look up foo::bar::baz,
3295 then symbols for the symtab containing foo should get
3296 read in, I think. */
3297 /* Someone says sun cc puts out symbols like
3298 /foo/baz/maclib::/usr/local/bin/maclib,
3299 which would get here with a symbol type of ':'. */
3303 /* Unexpected symbol descriptor. The second and subsequent stabs
3304 of a continued stab can show up here. The question is
3305 whether they ever can mimic a normal stab--it would be
3306 nice if not, since we certainly don't want to spend the
3307 time searching to the end of every string looking for
3310 complaint (&symfile_complaints,
3311 _("unknown symbol descriptor `%c'"), p[1]);
3313 /* Ignore it; perhaps it is an extension that we don't
3322 /* Solaris 2 end of module, finish current partial
3323 symbol table. END_PSYMTAB will set
3324 pst->texthigh to the proper value, which is
3325 necessary if a module compiled without
3326 debugging info follows this module. */
3328 && gdbarch_sofun_address_maybe_missing (gdbarch))
3330 pst = (struct partial_symtab *) 0;
3332 dependencies_used = 0;
3337 if (sh.value > save_pst->texthigh)
3338 save_pst->texthigh = sh.value;
3343 case N_SSYM: /* Claim: Structure or union element.
3344 Hopefully, I can ignore this. */
3345 case N_ENTRY: /* Alternate entry point; can ignore. */
3346 case N_MAIN: /* Can definitely ignore this. */
3347 case N_CATCH: /* These are GNU C++ extensions */
3348 case N_EHDECL: /* that can safely be ignored here. */
3358 case N_NSYMS: /* Ultrix 4.0: symbol count */
3359 case N_DEFD: /* GNU Modula-2 */
3360 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */
3362 case N_OBJ: /* useless types from Solaris */
3364 /* These symbols aren't interesting; don't worry about them */
3369 /* If we haven't found it yet, ignore it. It's probably some
3370 new type we don't know about yet. */
3371 complaint (&symfile_complaints, _("unknown symbol type %s"),
3372 hex_string (type_code)); /*CUR_SYMBOL_TYPE*/
3376 && stabstring != debug_info->ss + fh->issBase + sh.iss)
3379 /* end - Handle continuation */
3384 for (cur_sdx = 0; cur_sdx < fh->csym;)
3387 enum address_class class;
3389 (*swap_sym_in) (cur_bfd,
3390 ((char *) debug_info->external_sym
3391 + ((fh->isymBase + cur_sdx)
3392 * external_sym_size)),
3395 if (ECOFF_IS_STAB (&sh))
3401 /* Non absolute static symbols go into the minimal table. */
3402 if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil
3403 || (sh.index == indexNil
3404 && (sh.st != stStatic || sh.sc == scAbs)))
3406 /* FIXME, premature? */
3411 name = debug_info->ss + fh->issBase + sh.iss;
3417 /* The value of a stEnd symbol is the displacement from the
3418 corresponding start symbol value, do not relocate it. */
3420 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3427 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3431 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
3442 prim_record_minimal_symbol_and_info (name, sh.value,
3444 SECT_OFF_TEXT (objfile), NULL,
3450 /* Ignore all parameter symbol records. */
3451 if (sh.index >= hdr->iauxMax)
3453 /* Should not happen, but does when cross-compiling
3454 with the MIPS compiler. FIXME -- pull later. */
3455 index_complaint (name);
3456 new_sdx = cur_sdx + 1; /* Don't skip at all */
3459 new_sdx = AUX_GET_ISYM (fh->fBigendian,
3460 (debug_info->external_aux
3464 if (new_sdx <= cur_sdx)
3466 /* This should not happen either... FIXME. */
3467 complaint (&symfile_complaints,
3468 _("bad proc end in aux found from symbol %s"),
3470 new_sdx = cur_sdx + 1; /* Don't skip backward */
3473 /* For stProc symbol records, we need to check the
3474 storage class as well, as only (stProc, scText)
3475 entries represent "real" procedures - See the
3476 Compaq document titled "Object File / Symbol Table
3477 Format Specification" for more information. If the
3478 storage class is not scText, we discard the whole
3479 block of symbol records for this stProc. */
3480 if (sh.st == stProc && sh.sc != scText)
3483 /* Usually there is a local and a global stProc symbol
3484 for a function. This means that the function name
3485 has already been entered into the mimimal symbol table
3486 while processing the global symbols in pass 2 above.
3487 One notable exception is the PROGRAM name from
3488 f77 compiled executables, it is only put out as
3489 local stProc symbol, and a global MAIN__ stProc symbol
3490 points to it. It doesn't matter though, as gdb is
3491 still able to find the PROGRAM name via the partial
3492 symbol table, and the MAIN__ symbol via the minimal
3494 if (sh.st == stProc)
3495 add_psymbol_to_list (name, strlen (name),
3496 VAR_DOMAIN, LOC_BLOCK,
3497 &objfile->global_psymbols,
3498 0, sh.value, psymtab_language, objfile);
3500 add_psymbol_to_list (name, strlen (name),
3501 VAR_DOMAIN, LOC_BLOCK,
3502 &objfile->static_psymbols,
3503 0, sh.value, psymtab_language, objfile);
3505 procaddr = sh.value;
3508 (*swap_sym_in) (cur_bfd,
3509 ((char *) debug_info->external_sym
3510 + ((fh->isymBase + cur_sdx - 1)
3511 * external_sym_size)),
3516 /* Kludge for Irix 5.2 zero fh->adr. */
3518 && (pst->textlow == 0 || procaddr < pst->textlow))
3519 pst->textlow = procaddr;
3521 high = procaddr + sh.value;
3522 if (high > pst->texthigh)
3523 pst->texthigh = high;
3526 case stStatic: /* Variable */
3527 if (SC_IS_DATA (sh.sc))
3528 prim_record_minimal_symbol_and_info (name, sh.value,
3530 SECT_OFF_DATA (objfile),
3534 prim_record_minimal_symbol_and_info (name, sh.value,
3536 SECT_OFF_BSS (objfile),
3542 case stIndirect: /* Irix5 forward declaration */
3543 /* Skip forward declarations from Irix5 cc */
3546 case stTypedef: /* Typedef */
3547 /* Skip typedefs for forward declarations and opaque
3548 structs from alpha and mips cc. */
3549 if (sh.iss == 0 || has_opaque_xref (fh, &sh))
3551 class = LOC_TYPEDEF;
3554 case stConstant: /* Constant decl */
3561 case stBlock: /* { }, str, un, enum */
3562 /* Do not create a partial symbol for cc unnamed aggregates
3563 and gcc empty aggregates. */
3564 if ((sh.sc == scInfo
3565 || SC_IS_COMMON (sh.sc))
3567 && sh.index != cur_sdx + 2)
3569 add_psymbol_to_list (name, strlen (name),
3570 STRUCT_DOMAIN, LOC_TYPEDEF,
3571 &objfile->static_psymbols,
3573 psymtab_language, objfile);
3575 handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
3577 /* Skip over the block */
3579 if (new_sdx <= cur_sdx)
3581 /* This happens with the Ultrix kernel. */
3582 complaint (&symfile_complaints,
3583 _("bad aux index at block symbol %s"), name);
3584 new_sdx = cur_sdx + 1; /* Don't skip backward */
3589 case stFile: /* File headers */
3590 case stLabel: /* Labels */
3591 case stEnd: /* Ends of files */
3594 case stLocal: /* Local variables */
3595 /* Normally these are skipped because we skip over
3596 all blocks we see. However, these can occur
3597 as visible symbols in a .h file that contains code. */
3601 /* Both complaints are valid: one gives symbol name,
3602 the other the offending symbol type. */
3603 complaint (&symfile_complaints, _("unknown local symbol %s"),
3605 complaint (&symfile_complaints, _("with type %d"), sh.st);
3609 /* Use this gdb symbol */
3610 add_psymbol_to_list (name, strlen (name),
3612 &objfile->static_psymbols,
3613 0, sh.value, psymtab_language, objfile);
3615 cur_sdx++; /* Go to next file symbol */
3618 /* Now do enter the external symbols. */
3619 ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset];
3620 cur_sdx = fdr_to_pst[f_idx].n_globals;
3621 PST_PRIVATE (save_pst)->extern_count = cur_sdx;
3622 PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
3623 for (; --cur_sdx >= 0; ext_ptr++)
3625 enum address_class class;
3630 if (ext_ptr->ifd != f_idx)
3631 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
3632 psh = &ext_ptr->asym;
3634 /* Do not add undefined symbols to the partial symbol table. */
3635 if (SC_IS_UNDEF (psh->sc) || psh->sc == scNil)
3638 svalue = psh->value;
3643 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3650 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3654 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
3661 /* These are generated for static symbols in .o files,
3666 /* External procedure symbols have been entered
3667 into the minimal symbol table in pass 2 above.
3668 Ignore them, as parse_external will ignore them too. */
3674 unknown_ext_complaint (debug_info->ssext + psh->iss);
3675 /* Fall through, pretend it's global. */
3677 /* Global common symbols are resolved by the runtime loader,
3679 if (SC_IS_COMMON (psh->sc))
3685 name = debug_info->ssext + psh->iss;
3686 add_psymbol_to_list (name, strlen (name),
3688 &objfile->global_psymbols,
3690 psymtab_language, objfile);
3694 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3695 empty and put on the free list. */
3696 fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
3697 psymtab_include_list, includes_used,
3698 -1, save_pst->texthigh,
3699 dependency_list, dependencies_used, textlow_not_set);
3701 dependencies_used = 0;
3703 /* The objfile has its functions reordered if this partial symbol
3704 table overlaps any other partial symbol table.
3705 We cannot assume a reordered objfile if a partial symbol table
3706 is contained within another partial symbol table, as partial symbol
3707 tables for include files with executable code are contained
3708 within the partial symbol table for the including source file,
3709 and we do not want to flag the objfile reordered for these cases.
3711 This strategy works well for Irix-5.2 shared libraries, but we
3712 might have to use a more elaborate (and slower) algorithm for
3714 save_pst = fdr_to_pst[f_idx].pst;
3715 if (save_pst != NULL
3716 && save_pst->textlow != 0
3717 && !(objfile->flags & OBJF_REORDERED))
3719 ALL_OBJFILE_PSYMTABS (objfile, pst)
3722 && save_pst->textlow >= pst->textlow
3723 && save_pst->textlow < pst->texthigh
3724 && save_pst->texthigh > pst->texthigh)
3726 objfile->flags |= OBJF_REORDERED;
3733 /* Now scan the FDRs for dependencies */
3734 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
3736 fh = f_idx + debug_info->fdr;
3737 pst = fdr_to_pst[f_idx].pst;
3739 if (pst == (struct partial_symtab *) NULL)
3742 /* This should catch stabs-in-ecoff. */
3746 /* Skip the first file indirect entry as it is a self dependency
3747 for source files or a reverse .h -> .c dependency for header files. */
3748 pst->number_of_dependencies = 0;
3750 ((struct partial_symtab **)
3751 obstack_alloc (&objfile->objfile_obstack,
3753 * sizeof (struct partial_symtab *))));
3754 for (s_idx = 1; s_idx < fh->crfd; s_idx++)
3758 (*swap_rfd_in) (cur_bfd,
3759 ((char *) debug_info->external_rfd
3760 + (fh->rfdBase + s_idx) * external_rfd_size),
3762 if (rh < 0 || rh >= hdr->ifdMax)
3764 complaint (&symfile_complaints, _("bad file number %ld"), rh);
3768 /* Skip self dependencies of header files. */
3772 /* Do not add to dependeny list if psymtab was empty. */
3773 if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL)
3775 pst->dependencies[pst->number_of_dependencies++] = fdr_to_pst[rh].pst;
3779 /* Remove the dummy psymtab created for -O3 images above, if it is
3780 still empty, to enable the detection of stripped executables. */
3781 if (objfile->psymtabs->next == NULL
3782 && objfile->psymtabs->number_of_dependencies == 0
3783 && objfile->psymtabs->n_global_syms == 0
3784 && objfile->psymtabs->n_static_syms == 0)
3785 objfile->psymtabs = NULL;
3786 do_cleanups (old_chain);
3789 /* If the current psymbol has an enumerated type, we need to add
3790 all the the enum constants to the partial symbol table. */
3793 handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
3796 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
3797 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
3798 char *ext_sym = ((char *) debug_info->external_sym
3799 + ((fh->isymBase + cur_sdx + 1) * external_sym_size));
3809 /* It is an enumerated type if the next symbol entry is a stMember
3810 and its auxiliary index is indexNil or its auxiliary entry
3811 is a plain btNil or btVoid.
3812 Alpha cc -migrate enums are recognized by a zero index and
3813 a zero symbol value.
3814 DU 4.0 cc enums are recognized by a member type of btEnum without
3815 qualifiers and a zero symbol value. */
3816 (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3817 if (sh.st != stMember)
3820 if (sh.index == indexNil
3821 || (sh.index == 0 && svalue == 0))
3823 (*debug_swap->swap_tir_in) (fh->fBigendian,
3824 &(debug_info->external_aux
3825 + fh->iauxBase + sh.index)->a_ti,
3827 if ((tir.bt != btNil
3829 && (tir.bt != btEnum || svalue != 0))
3830 || tir.tq0 != tqNil)
3842 (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3843 if (sh.st != stMember)
3845 name = debug_info->ss + cur_fdr->issBase + sh.iss;
3847 /* Note that the value doesn't matter for enum constants
3848 in psymtabs, just in symtabs. */
3849 add_psymbol_to_list (name, strlen (name),
3850 VAR_DOMAIN, LOC_CONST,
3851 &objfile->static_psymbols, 0,
3852 (CORE_ADDR) 0, psymtab_language, objfile);
3853 ext_sym += external_sym_size;
3857 /* Get the next symbol. OBJFILE is unused. */
3860 mdebug_next_symbol_text (struct objfile *objfile)
3865 (*debug_swap->swap_sym_in) (cur_bfd,
3866 ((char *) debug_info->external_sym
3867 + ((cur_fdr->isymBase + cur_sdx)
3868 * debug_swap->external_sym_size)),
3870 return debug_info->ss + cur_fdr->issBase + sh.iss;
3873 /* Ancillary function to psymtab_to_symtab(). Does all the work
3874 for turning the partial symtab PST into a symtab, recurring
3875 first on all dependent psymtabs. The argument FILENAME is
3876 only passed so we can see in debug stack traces what file
3879 This function has a split personality, based on whether the
3880 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3881 The flow of control and even the memory allocation differs. FIXME. */
3884 psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
3886 bfd_size_type external_sym_size;
3887 bfd_size_type external_pdr_size;
3888 void (*swap_sym_in) (bfd *, void *, SYMR *);
3889 void (*swap_pdr_in) (bfd *, void *, PDR *);
3891 struct symtab *st = NULL;
3893 struct linetable *lines;
3894 CORE_ADDR lowest_pdr_addr = 0;
3895 int last_symtab_ended = 0;
3901 /* Read in all partial symbtabs on which this one is dependent.
3902 NOTE that we do have circular dependencies, sigh. We solved
3903 that by setting pst->readin before this point. */
3905 for (i = 0; i < pst->number_of_dependencies; i++)
3906 if (!pst->dependencies[i]->readin)
3908 /* Inform about additional files to be read in. */
3911 fputs_filtered (" ", gdb_stdout);
3913 fputs_filtered ("and ", gdb_stdout);
3915 printf_filtered ("%s...",
3916 pst->dependencies[i]->filename);
3917 wrap_here (""); /* Flush output */
3918 gdb_flush (gdb_stdout);
3920 /* We only pass the filename for debug purposes */
3921 psymtab_to_symtab_1 (pst->dependencies[i],
3922 pst->dependencies[i]->filename);
3925 /* Do nothing if this is a dummy psymtab. */
3927 if (pst->n_global_syms == 0 && pst->n_static_syms == 0
3928 && pst->textlow == 0 && pst->texthigh == 0)
3931 /* Now read the symbols for this symtab */
3933 cur_bfd = CUR_BFD (pst);
3934 debug_swap = DEBUG_SWAP (pst);
3935 debug_info = DEBUG_INFO (pst);
3936 pending_list = PENDING_LIST (pst);
3937 external_sym_size = debug_swap->external_sym_size;
3938 external_pdr_size = debug_swap->external_pdr_size;
3939 swap_sym_in = debug_swap->swap_sym_in;
3940 swap_pdr_in = debug_swap->swap_pdr_in;
3941 current_objfile = pst->objfile;
3942 cur_fd = FDR_IDX (pst);
3943 fh = ((cur_fd == -1)
3945 : debug_info->fdr + cur_fd);
3948 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3949 processing_gcc_compilation = 0;
3950 if (fh != (FDR *) NULL && fh->csym >= 2)
3954 (*swap_sym_in) (cur_bfd,
3955 ((char *) debug_info->external_sym
3956 + (fh->isymBase + 1) * external_sym_size),
3958 if (strcmp (debug_info->ss + fh->issBase + sh.iss,
3961 /* We indicate that this is a GCC compilation so that certain
3962 features will be enabled in stabsread/dbxread. */
3963 processing_gcc_compilation = 2;
3967 if (processing_gcc_compilation != 0)
3970 /* This symbol table contains stabs-in-ecoff entries. */
3972 /* Parse local symbols first */
3974 if (fh->csym <= 2) /* FIXME, this blows psymtab->symtab ptr */
3976 current_objfile = NULL;
3979 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
3985 (*swap_sym_in) (cur_bfd,
3986 (((char *) debug_info->external_sym)
3987 + (fh->isymBase + cur_sdx) * external_sym_size),
3989 name = debug_info->ss + fh->issBase + sh.iss;
3991 /* XXX This is a hack. It will go away! */
3992 if (ECOFF_IS_STAB (&sh) || (name[0] == '#'))
3994 int type_code = ECOFF_UNMARK_STAB (sh.index);
3996 /* We should never get non N_STAB symbols here, but they
3997 should be harmless, so keep process_one_symbol from
3998 complaining about them. */
3999 if (type_code & N_STAB)
4001 /* If we found a trailing N_SO with no name, process
4002 it here instead of in process_one_symbol, so we
4003 can keep a handle to its symtab. The symtab
4004 would otherwise be ended twice, once in
4005 process_one_symbol, and once after this loop. */
4006 if (type_code == N_SO
4008 && previous_stab_code != (unsigned char) N_SO
4011 valu += ANOFFSET (pst->section_offsets,
4012 SECT_OFF_TEXT (pst->objfile));
4013 previous_stab_code = N_SO;
4014 st = end_symtab (valu, pst->objfile,
4015 SECT_OFF_TEXT (pst->objfile));
4017 last_symtab_ended = 1;
4021 last_symtab_ended = 0;
4022 process_one_symbol (type_code, 0, valu, name,
4023 pst->section_offsets, pst->objfile);
4026 /* Similarly a hack. */
4027 else if (name[0] == '#')
4029 process_one_symbol (N_SLINE, 0, valu, name,
4030 pst->section_offsets, pst->objfile);
4032 if (type_code == N_FUN)
4034 /* Make up special symbol to contain
4035 procedure specific info */
4036 struct mdebug_extra_func_info *e =
4037 ((struct mdebug_extra_func_info *)
4038 obstack_alloc (¤t_objfile->objfile_obstack,
4039 sizeof (struct mdebug_extra_func_info)));
4040 struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
4042 memset (e, 0, sizeof (struct mdebug_extra_func_info));
4043 SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
4044 SYMBOL_CLASS (s) = LOC_CONST;
4045 SYMBOL_TYPE (s) = builtin_type_void;
4046 SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
4047 e->pdr.framereg = -1;
4048 add_symbol_to_list (s, &local_symbols);
4051 else if (sh.st == stLabel)
4053 if (sh.index == indexNil)
4055 /* This is what the gcc2_compiled and __gnu_compiled_*
4056 show up as. So don't complain. */
4061 /* Handle encoded stab line number. */
4062 valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile));
4063 record_line (current_subfile, sh.index, valu);
4066 else if (sh.st == stProc || sh.st == stStaticProc
4067 || sh.st == stStatic || sh.st == stEnd)
4068 /* These are generated by gcc-2.x, do not complain */
4071 complaint (&symfile_complaints, _("unknown stabs symbol %s"), name);
4074 if (! last_symtab_ended)
4076 st = end_symtab (pst->texthigh, pst->objfile, SECT_OFF_TEXT (pst->objfile));
4080 /* There used to be a call to sort_blocks here, but this should not
4081 be necessary for stabs symtabs. And as sort_blocks modifies the
4082 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
4083 it did the wrong thing if the first procedure in a file was
4084 generated via asm statements. */
4086 /* Fill in procedure info next. */
4090 struct cleanup *old_chain;
4096 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
4097 old_chain = make_cleanup (xfree, pr_block);
4099 pdr_ptr = ((char *) debug_info->external_pdr
4100 + fh->ipdFirst * external_pdr_size);
4101 pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
4105 pdr_ptr += external_pdr_size, pdr_in++)
4107 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
4109 /* Determine lowest PDR address, the PDRs are not always
4111 if (pdr_in == pr_block)
4112 lowest_pdr_addr = pdr_in->adr;
4113 else if (pdr_in->adr < lowest_pdr_addr)
4114 lowest_pdr_addr = pdr_in->adr;
4118 pdr_in_end = pdr_in + fh->cpd;
4119 for (; pdr_in < pdr_in_end; pdr_in++)
4120 parse_procedure (pdr_in, st, pst);
4122 do_cleanups (old_chain);
4127 /* This symbol table contains ordinary ecoff entries. */
4136 st = new_symtab ("unknown", 0, pst->objfile);
4140 maxlines = 2 * fh->cline;
4141 st = new_symtab (pst->filename, maxlines, pst->objfile);
4143 /* The proper language was already determined when building
4144 the psymtab, use it. */
4145 st->language = PST_PRIVATE (pst)->pst_language;
4148 psymtab_language = st->language;
4150 lines = LINETABLE (st);
4152 /* Get a new lexical context */
4154 push_parse_stack ();
4155 top_stack->cur_st = st;
4156 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
4158 BLOCK_START (top_stack->cur_block) = pst->textlow;
4159 BLOCK_END (top_stack->cur_block) = 0;
4160 top_stack->blocktype = stFile;
4161 top_stack->cur_type = 0;
4162 top_stack->procadr = 0;
4163 top_stack->numargs = 0;
4164 found_ecoff_debugging_info = 0;
4171 /* Parse local symbols first */
4172 sym_ptr = ((char *) debug_info->external_sym
4173 + fh->isymBase * external_sym_size);
4174 sym_end = sym_ptr + fh->csym * external_sym_size;
4175 while (sym_ptr < sym_end)
4180 (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
4181 c = parse_symbol (&sh,
4182 debug_info->external_aux + fh->iauxBase,
4183 sym_ptr, fh->fBigendian, pst->section_offsets, pst->objfile);
4184 sym_ptr += c * external_sym_size;
4187 /* Linenumbers. At the end, check if we can save memory.
4188 parse_lines has to look ahead an arbitrary number of PDR
4189 structures, so we swap them all first. */
4193 struct cleanup *old_chain;
4199 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
4201 old_chain = make_cleanup (xfree, pr_block);
4203 pdr_ptr = ((char *) debug_info->external_pdr
4204 + fh->ipdFirst * external_pdr_size);
4205 pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
4209 pdr_ptr += external_pdr_size, pdr_in++)
4211 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
4213 /* Determine lowest PDR address, the PDRs are not always
4215 if (pdr_in == pr_block)
4216 lowest_pdr_addr = pdr_in->adr;
4217 else if (pdr_in->adr < lowest_pdr_addr)
4218 lowest_pdr_addr = pdr_in->adr;
4221 parse_lines (fh, pr_block, lines, maxlines, pst, lowest_pdr_addr);
4222 if (lines->nitems < fh->cline)
4223 lines = shrink_linetable (lines);
4225 /* Fill in procedure info next. */
4227 pdr_in_end = pdr_in + fh->cpd;
4228 for (; pdr_in < pdr_in_end; pdr_in++)
4229 parse_procedure (pdr_in, 0, pst);
4231 do_cleanups (old_chain);
4235 LINETABLE (st) = lines;
4237 /* .. and our share of externals.
4238 XXX use the global list to speed up things here. how?
4239 FIXME, Maybe quit once we have found the right number of ext's? */
4240 top_stack->cur_st = st;
4241 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
4243 top_stack->blocktype = stFile;
4245 ext_ptr = PST_PRIVATE (pst)->extern_tab;
4246 for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
4247 parse_external (ext_ptr, fh->fBigendian, pst->section_offsets, pst->objfile);
4249 /* If there are undefined symbols, tell the user.
4250 The alpha has an undefined symbol for every symbol that is
4251 from a shared library, so tell the user only if verbose is on. */
4252 if (info_verbose && n_undef_symbols)
4254 printf_filtered (_("File %s contains %d unresolved references:"),
4255 st->filename, n_undef_symbols);
4256 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
4257 n_undef_vars, n_undef_procs, n_undef_labels);
4258 n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0;
4268 /* Now link the psymtab and the symtab. */
4271 current_objfile = NULL;
4274 /* Ancillary parsing procedures. */
4276 /* Return 1 if the symbol pointed to by SH has a cross reference
4277 to an opaque aggregate type, else 0. */
4280 has_opaque_xref (FDR *fh, SYMR *sh)
4287 if (sh->index == indexNil)
4290 ax = debug_info->external_aux + fh->iauxBase + sh->index;
4291 (*debug_swap->swap_tir_in) (fh->fBigendian, &ax->a_ti, &tir);
4292 if (tir.bt != btStruct && tir.bt != btUnion && tir.bt != btEnum)
4296 (*debug_swap->swap_rndx_in) (fh->fBigendian, &ax->a_rndx, rn);
4297 if (rn->rfd == 0xfff)
4298 rf = AUX_GET_ISYM (fh->fBigendian, ax + 1);
4306 /* Lookup the type at relative index RN. Return it in TPP
4307 if found and in any event come up with its name PNAME.
4308 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4309 Return value says how many aux symbols we ate. */
4312 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. */
4313 char **pname, int bigend, char *sym_name)
4322 struct mdebug_pending *pend;
4324 *tpp = (struct type *) NULL;
4326 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
4328 /* Escape index means 'the next one' */
4329 if (rn->rfd == 0xfff)
4332 rf = AUX_GET_ISYM (bigend, ax + 1);
4339 /* mips cc uses a rf of -1 for opaque struct definitions.
4340 Set TYPE_FLAG_STUB for these types so that check_typedef will
4341 resolve them if the struct gets defined in another compilation unit. */
4344 *pname = "<undefined>";
4345 *tpp = init_type (type_code, 0, TYPE_FLAG_STUB, (char *) NULL, current_objfile);
4349 /* mips cc uses an escaped rn->index of 0 for struct return types
4350 of procedures that were compiled without -g. These will always remain
4352 if (rn->rfd == 0xfff && rn->index == 0)
4354 *pname = "<undefined>";
4358 /* Find the relative file descriptor and the symbol in it. */
4359 fh = get_rfd (fd, rf);
4360 xref_fd = fh - debug_info->fdr;
4362 if (rn->index >= fh->csym)
4364 /* File indirect entry is corrupt. */
4365 *pname = "<illegal>";
4366 bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4370 /* If we have processed this symbol then we left a forwarding
4371 pointer to the type in the pending list. If not, we`ll put
4372 it in a list of pending types, to be processed later when
4373 the file will be. In any event, we collect the name for the
4376 esh = ((char *) debug_info->external_sym
4377 + ((fh->isymBase + rn->index)
4378 * debug_swap->external_sym_size));
4379 (*debug_swap->swap_sym_in) (cur_bfd, esh, &sh);
4381 /* Make sure that this type of cross reference can be handled. */
4382 if ((sh.sc != scInfo
4383 || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect
4384 && sh.st != stStruct && sh.st != stUnion
4385 && sh.st != stEnum))
4386 && (sh.st != stBlock || !SC_IS_COMMON (sh.sc)))
4388 /* File indirect entry is corrupt. */
4389 *pname = "<illegal>";
4390 bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4394 *pname = debug_info->ss + fh->issBase + sh.iss;
4396 pend = is_pending_symbol (fh, esh);
4401 /* We have not yet seen this type. */
4403 if ((sh.iss == 0 && sh.st == stTypedef) || sh.st == stIndirect)
4407 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4409 a) forward declarations of structs/unions/enums which are not
4410 defined in this compilation unit.
4411 For these the type will be void. This is a bad design decision
4412 as cross referencing across compilation units is impossible
4413 due to the missing name.
4414 b) forward declarations of structs/unions/enums/typedefs which
4415 are defined later in this file or in another file in the same
4416 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4417 Simply cross reference those again to get the true type.
4418 The forward references are not entered in the pending list and
4419 in the symbol table. */
4421 (*debug_swap->swap_tir_in) (bigend,
4422 &(debug_info->external_aux
4423 + fh->iauxBase + sh.index)->a_ti,
4425 if (tir.tq0 != tqNil)
4426 complaint (&symfile_complaints,
4427 _("illegal tq0 in forward typedef for %s"), sym_name);
4431 *tpp = init_type (type_code, 0, 0, (char *) NULL,
4433 *pname = "<undefined>";
4440 (debug_info->external_aux
4441 + fh->iauxBase + sh.index + 1),
4442 tpp, type_code, pname,
4443 fh->fBigendian, sym_name);
4447 /* Follow a forward typedef. This might recursively
4448 call cross_ref till we get a non typedef'ed type.
4449 FIXME: This is not correct behaviour, but gdb currently
4450 cannot handle typedefs without type copying. Type
4451 copying is impossible as we might have mutual forward
4452 references between two files and the copied type would not
4453 get filled in when we later parse its definition. */
4454 *tpp = parse_type (xref_fd,
4455 debug_info->external_aux + fh->iauxBase,
4459 debug_info->ss + fh->issBase + sh.iss);
4460 add_pending (fh, esh, *tpp);
4464 complaint (&symfile_complaints,
4465 _("illegal bt %d in forward typedef for %s"), tir.bt,
4467 *tpp = init_type (type_code, 0, 0, (char *) NULL,
4473 else if (sh.st == stTypedef)
4475 /* Parse the type for a normal typedef. This might recursively call
4476 cross_ref till we get a non typedef'ed type.
4477 FIXME: This is not correct behaviour, but gdb currently
4478 cannot handle typedefs without type copying. But type copying is
4479 impossible as we might have mutual forward references between
4480 two files and the copied type would not get filled in when
4481 we later parse its definition. */
4482 *tpp = parse_type (xref_fd,
4483 debug_info->external_aux + fh->iauxBase,
4487 debug_info->ss + fh->issBase + sh.iss);
4491 /* Cross reference to a struct/union/enum which is defined
4492 in another file in the same compilation unit but that file
4493 has not been parsed yet.
4494 Initialize the type only, it will be filled in when
4495 it's definition is parsed. */
4496 *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
4498 add_pending (fh, esh, *tpp);
4501 /* We used one auxent normally, two if we got a "next one" rf. */
4506 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4507 keeping the symtab sorted */
4509 static struct symbol *
4510 mylookup_symbol (char *name, struct block *block,
4511 domain_enum domain, enum address_class class)
4513 struct dict_iterator iter;
4518 ALL_BLOCK_SYMBOLS (block, iter, sym)
4520 if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
4521 && SYMBOL_DOMAIN (sym) == domain
4522 && SYMBOL_CLASS (sym) == class
4523 && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0)
4527 block = BLOCK_SUPERBLOCK (block);
4529 return mylookup_symbol (name, block, domain, class);
4534 /* Add a new symbol S to a block B. */
4537 add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
4539 SYMBOL_SYMTAB (s) = symtab;
4540 dict_add_symbol (BLOCK_DICT (b), s);
4543 /* Add a new block B to a symtab S */
4546 add_block (struct block *b, struct symtab *s)
4548 struct blockvector *bv = BLOCKVECTOR (s);
4550 bv = (struct blockvector *) xrealloc ((void *) bv,
4551 (sizeof (struct blockvector)
4552 + BLOCKVECTOR_NBLOCKS (bv)
4553 * sizeof (bv->block)));
4554 if (bv != BLOCKVECTOR (s))
4555 BLOCKVECTOR (s) = bv;
4557 BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b;
4560 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4561 MIPS' linenumber encoding might need more than one byte
4562 to describe it, LAST is used to detect these continuation lines.
4564 Combining lines with the same line number seems like a bad idea.
4565 E.g: There could be a line number entry with the same line number after the
4566 prologue and GDB should not ignore it (this is a better way to find
4567 a prologue than mips_skip_prologue).
4568 But due to the compressed line table format there are line number entries
4569 for the same line which are needed to bridge the gap to the next
4570 line number entry. These entries have a bogus address info with them
4571 and we are unable to tell them from intended duplicate line number
4573 This is another reason why -ggdb debugging format is preferable. */
4576 add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last)
4578 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4579 Change them to something sensible. */
4583 last = -2; /* make sure we record first line */
4585 if (last == lineno) /* skip continuation lines */
4588 lt->item[lt->nitems].line = lineno;
4589 lt->item[lt->nitems++].pc = adr << 2;
4593 /* Sorting and reordering procedures */
4595 /* Blocks with a smaller low bound should come first */
4598 compare_blocks (const void *arg1, const void *arg2)
4601 struct block **b1 = (struct block **) arg1;
4602 struct block **b2 = (struct block **) arg2;
4604 addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2)));
4606 return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1)));
4610 /* Sort the blocks of a symtab S.
4611 Reorder the blocks in the blockvector by code-address,
4612 as required by some MI search routines */
4615 sort_blocks (struct symtab *s)
4617 struct blockvector *bv = BLOCKVECTOR (s);
4619 if (BLOCKVECTOR_NBLOCKS (bv) <= 2)
4622 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0)
4623 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0;
4624 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0)
4625 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0;
4629 * This is very unfortunate: normally all functions are compiled in
4630 * the order they are found, but if the file is compiled -O3 things
4631 * are very different. It would be nice to find a reliable test
4632 * to detect -O3 images in advance.
4634 if (BLOCKVECTOR_NBLOCKS (bv) > 3)
4635 qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
4636 BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK,
4637 sizeof (struct block *),
4642 int i, j = BLOCKVECTOR_NBLOCKS (bv);
4644 for (i = FIRST_LOCAL_BLOCK; i < j; i++)
4645 if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)))
4646 high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i));
4647 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high;
4650 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) =
4651 BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK));
4653 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4654 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4655 BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4656 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4660 /* Constructor/restructor/destructor procedures */
4662 /* Allocate a new symtab for NAME. Needs an estimate of how many
4663 linenumbers MAXLINES we'll put in it */
4665 static struct symtab *
4666 new_symtab (char *name, int maxlines, struct objfile *objfile)
4668 struct symtab *s = allocate_symtab (name, objfile);
4670 LINETABLE (s) = new_linetable (maxlines);
4672 /* All symtabs must have at least two blocks */
4673 BLOCKVECTOR (s) = new_bvect (2);
4674 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK)
4675 = new_block (NON_FUNCTION_BLOCK);
4676 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
4677 = new_block (NON_FUNCTION_BLOCK);
4678 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
4679 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4681 s->free_code = free_linetable;
4682 s->debugformat = obsavestring ("ECOFF", 5,
4683 &objfile->objfile_obstack);
4687 /* Allocate a new partial_symtab NAME */
4689 static struct partial_symtab *
4690 new_psymtab (char *name, struct objfile *objfile)
4692 struct partial_symtab *psymtab;
4694 psymtab = allocate_psymtab (name, objfile);
4695 psymtab->section_offsets = objfile->section_offsets;
4697 /* Keep a backpointer to the file's symbols */
4699 psymtab->read_symtab_private = ((char *)
4700 obstack_alloc (&objfile->objfile_obstack,
4701 sizeof (struct symloc)));
4702 memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
4703 CUR_BFD (psymtab) = cur_bfd;
4704 DEBUG_SWAP (psymtab) = debug_swap;
4705 DEBUG_INFO (psymtab) = debug_info;
4706 PENDING_LIST (psymtab) = pending_list;
4708 /* The way to turn this into a symtab is to call... */
4709 psymtab->read_symtab = mdebug_psymtab_to_symtab;
4714 /* Allocate a linetable array of the given SIZE. Since the struct
4715 already includes one item, we subtract one when calculating the
4716 proper size to allocate. */
4718 static struct linetable *
4719 new_linetable (int size)
4721 struct linetable *l;
4723 size = (size - 1) * sizeof (l->item) + sizeof (struct linetable);
4724 l = (struct linetable *) xmalloc (size);
4729 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4730 I am not so sure about the 3.4 ones.
4732 Since the struct linetable already includes one item, we subtract one when
4733 calculating the proper size to allocate. */
4735 static struct linetable *
4736 shrink_linetable (struct linetable *lt)
4739 return (struct linetable *) xrealloc ((void *) lt,
4740 (sizeof (struct linetable)
4742 * sizeof (lt->item))));
4745 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4747 static struct blockvector *
4748 new_bvect (int nblocks)
4750 struct blockvector *bv;
4753 size = sizeof (struct blockvector) + nblocks * sizeof (struct block *);
4754 bv = (struct blockvector *) xzalloc (size);
4756 BLOCKVECTOR_NBLOCKS (bv) = nblocks;
4761 /* Allocate and zero a new block, and set its BLOCK_DICT. If function
4762 is non-zero, assume the block is associated to a function, and make
4763 sure that the symbols are stored linearly; otherwise, store them
4766 static struct block *
4767 new_block (enum block_type type)
4769 /* FIXME: carlton/2003-09-11: This should use allocate_block to
4770 allocate the block. Which, in turn, suggests that the block
4771 should be allocated on an obstack. */
4772 struct block *retval = xzalloc (sizeof (struct block));
4774 if (type == FUNCTION_BLOCK)
4775 BLOCK_DICT (retval) = dict_create_linear_expandable ();
4777 BLOCK_DICT (retval) = dict_create_hashed_expandable ();
4782 /* Create a new symbol with printname NAME */
4784 static struct symbol *
4785 new_symbol (char *name)
4787 struct symbol *s = ((struct symbol *)
4788 obstack_alloc (¤t_objfile->objfile_obstack,
4789 sizeof (struct symbol)));
4791 memset (s, 0, sizeof (*s));
4792 SYMBOL_LANGUAGE (s) = psymtab_language;
4793 SYMBOL_SET_NAMES (s, name, strlen (name), current_objfile);
4797 /* Create a new type with printname NAME */
4799 static struct type *
4800 new_type (char *name)
4804 t = alloc_type (current_objfile);
4805 TYPE_NAME (t) = name;
4806 TYPE_CPLUS_SPECIFIC (t) = (struct cplus_struct_type *) &cplus_struct_default;
4810 /* Read ECOFF debugging information from a BFD section. This is
4811 called from elfread.c. It parses the section into a
4812 ecoff_debug_info struct, and then lets the rest of the file handle
4816 elfmdebug_build_psymtabs (struct objfile *objfile,
4817 const struct ecoff_debug_swap *swap, asection *sec)
4819 bfd *abfd = objfile->obfd;
4820 struct ecoff_debug_info *info;
4821 struct cleanup *back_to;
4823 /* FIXME: It's not clear whether we should be getting minimal symbol
4824 information from .mdebug in an ELF file, or whether we will.
4825 Re-initialize the minimal symbol reader in case we do. */
4827 init_minimal_symbol_collection ();
4828 back_to = make_cleanup_discard_minimal_symbols ();
4830 info = ((struct ecoff_debug_info *)
4831 obstack_alloc (&objfile->objfile_obstack,
4832 sizeof (struct ecoff_debug_info)));
4834 if (!(*swap->read_debug_info) (abfd, sec, info))
4835 error (_("Error reading ECOFF debugging information: %s"),
4836 bfd_errmsg (bfd_get_error ()));
4838 mdebug_build_psymtabs (objfile, swap, info);
4840 install_minimal_symbols (objfile);
4841 do_cleanups (back_to);
4845 _initialize_mdebugread (void)
4847 basic_type_data = register_objfile_data ();