1 /* Read a symbol table in ECOFF format (Third-Eye).
3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
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 2 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, write to the Free Software
25 Foundation, Inc., 59 Temple Place - Suite 330,
26 Boston, MA 02111-1307, USA. */
28 /* This module provides the function mdebug_build_psymtabs. It reads
29 ECOFF debugging information into partial symbol tables. The
30 debugging information is read from two structures. A struct
31 ecoff_debug_swap includes the sizes of each ECOFF structure and
32 swapping routines; these are fixed for a particular target. A
33 struct ecoff_debug_info points to the debugging information for a
34 particular object file.
36 ECOFF symbol tables are mostly written in the byte order of the
37 target machine. However, one section of the table (the auxiliary
38 symbol information) is written in the host byte order. There is a
39 bit in the other symbol info which describes which host byte order
40 was used. ECOFF thereby takes the trophy from Intel `b.out' for
41 the most brain-dead adaptation of a file format to byte order.
43 This module can read all four of the known byte-order combinations,
44 on any type of host. */
51 #include "gdb_obstack.h"
53 #include "stabsread.h"
54 #include "complaints.h"
56 #include "gdb_assert.h"
58 #include "dictionary.h"
59 #include "mdebugread.h"
61 /* These are needed if the tm.h file does not contain the necessary
62 mips specific definitions. */
64 #ifndef MDEBUG_EFI_SYMBOL_NAME
65 #define MDEBUG_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
69 #include "gdb_string.h"
73 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
75 #include "libaout.h" /* Private BFD a.out information. */
76 #include "aout/aout64.h"
77 #include "aout/stab_gnu.h" /* STABS information */
79 #include "expression.h"
81 extern void _initialize_mdebugread (void);
83 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
84 We use this define in order to know whether we should override a
85 symbol's ECOFF section with its ELF section. This is necessary in
86 case the symbol's ELF section could not be represented in ECOFF. */
87 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
88 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
91 /* We put a pointer to this structure in the read_symtab_private field
96 /* Index of the FDR that this psymtab represents. */
98 /* The BFD that the psymtab was created from. */
100 const struct ecoff_debug_swap
*debug_swap
;
101 struct ecoff_debug_info
*debug_info
;
102 struct mdebug_pending
**pending_list
;
103 /* Pointer to external symbols for this file. */
105 /* Size of extern_tab. */
107 enum language pst_language
;
110 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
111 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
112 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
113 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
114 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
115 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
117 #define SC_IS_TEXT(sc) ((sc) == scText \
118 || (sc) == scRConst \
121 #define SC_IS_DATA(sc) ((sc) == scData \
126 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
127 #define SC_IS_BSS(sc) ((sc) == scBss)
128 #define SC_IS_SBSS(sc) ((sc) == scSBss)
129 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
131 /* Various complaints about symbol reading that don't abort the process */
133 index_complaint (const char *arg1
)
135 complaint (&symfile_complaints
, "bad aux index at symbol %s", arg1
);
139 unknown_ext_complaint (const char *arg1
)
141 complaint (&symfile_complaints
, "unknown external symbol %s", arg1
);
145 basic_type_complaint (int arg1
, const char *arg2
)
147 complaint (&symfile_complaints
, "cannot map ECOFF basic type 0x%x for %s",
152 bad_tag_guess_complaint (const char *arg1
)
154 complaint (&symfile_complaints
, "guessed tag type of %s incorrectly", arg1
);
158 bad_rfd_entry_complaint (const char *arg1
, int arg2
, int arg3
)
160 complaint (&symfile_complaints
, "bad rfd entry for %s: file %d, index %d",
165 unexpected_type_code_complaint (const char *arg1
)
167 complaint (&symfile_complaints
, "unexpected type code for %s", arg1
);
170 /* Macros and extra defs */
172 /* Puns: hard to find whether -g was used and how */
174 #define MIN_GLEVEL GLEVEL_0
175 #define compare_glevel(a,b) \
176 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
177 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
179 /* Things that really are local to this module */
181 /* Remember what we deduced to be the source language of this psymtab. */
183 static enum language psymtab_language
= language_unknown
;
189 /* How to parse debugging information for CUR_BFD. */
191 static const struct ecoff_debug_swap
*debug_swap
;
193 /* Pointers to debugging information for CUR_BFD. */
195 static struct ecoff_debug_info
*debug_info
;
197 /* Pointer to current file decriptor record, and its index */
202 /* Index of current symbol */
206 /* Note how much "debuggable" this image is. We would like
207 to see at least one FDR with full symbols */
209 static int max_gdbinfo
;
210 static int max_glevel
;
212 /* When examining .o files, report on undefined symbols */
214 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
216 /* Pseudo symbol to use when putting stabs into the symbol table. */
218 static char stabs_symbol
[] = STABS_SYMBOL
;
220 /* Types corresponding to mdebug format bt* basic types. */
222 static struct type
*mdebug_type_void
;
223 static struct type
*mdebug_type_char
;
224 static struct type
*mdebug_type_short
;
225 static struct type
*mdebug_type_int_32
;
226 #define mdebug_type_int mdebug_type_int_32
227 static struct type
*mdebug_type_int_64
;
228 static struct type
*mdebug_type_long_32
;
229 static struct type
*mdebug_type_long_64
;
230 static struct type
*mdebug_type_long_long_64
;
231 static struct type
*mdebug_type_unsigned_char
;
232 static struct type
*mdebug_type_unsigned_short
;
233 static struct type
*mdebug_type_unsigned_int_32
;
234 static struct type
*mdebug_type_unsigned_int_64
;
235 static struct type
*mdebug_type_unsigned_long_32
;
236 static struct type
*mdebug_type_unsigned_long_64
;
237 static struct type
*mdebug_type_unsigned_long_long_64
;
238 static struct type
*mdebug_type_adr_32
;
239 static struct type
*mdebug_type_adr_64
;
240 static struct type
*mdebug_type_float
;
241 static struct type
*mdebug_type_double
;
242 static struct type
*mdebug_type_complex
;
243 static struct type
*mdebug_type_double_complex
;
244 static struct type
*mdebug_type_fixed_dec
;
245 static struct type
*mdebug_type_float_dec
;
246 static struct type
*mdebug_type_string
;
248 /* Types for symbols from files compiled without debugging info. */
250 static struct type
*nodebug_func_symbol_type
;
251 static struct type
*nodebug_var_symbol_type
;
253 /* Nonzero if we have seen ecoff debugging info for a file. */
255 static int found_ecoff_debugging_info
;
257 /* Forward declarations */
259 static int upgrade_type (int, struct type
**, int, union aux_ext
*,
262 static void parse_partial_symbols (struct objfile
*);
264 static int has_opaque_xref (FDR
*, SYMR
*);
266 static int cross_ref (int, union aux_ext
*, struct type
**, enum type_code
,
267 char **, int, char *);
269 static struct symbol
*new_symbol (char *);
271 static struct type
*new_type (char *);
273 enum block_type
{ FUNCTION_BLOCK
, NON_FUNCTION_BLOCK
};
275 static struct block
*new_block (enum block_type
);
277 static struct symtab
*new_symtab (char *, int, struct objfile
*);
279 static struct linetable
*new_linetable (int);
281 static struct blockvector
*new_bvect (int);
283 static struct type
*parse_type (int, union aux_ext
*, unsigned int, int *,
286 static struct symbol
*mylookup_symbol (char *, struct block
*, domain_enum
,
289 static void sort_blocks (struct symtab
*);
291 static struct partial_symtab
*new_psymtab (char *, struct objfile
*);
293 static void psymtab_to_symtab_1 (struct partial_symtab
*, char *);
295 static void add_block (struct block
*, struct symtab
*);
297 static void add_symbol (struct symbol
*, struct block
*);
299 static int add_line (struct linetable
*, int, CORE_ADDR
, int);
301 static struct linetable
*shrink_linetable (struct linetable
*);
303 static void handle_psymbol_enumerators (struct objfile
*, FDR
*, int,
306 static char *mdebug_next_symbol_text (struct objfile
*);
308 /* Allocate zeroed memory */
311 xzalloc (unsigned int size
)
313 void *p
= xmalloc (size
);
319 /* Exported procedure: Builds a symtab from the PST partial one.
320 Restores the environment in effect when PST was created, delegates
321 most of the work to an ancillary procedure, and sorts
322 and reorders the symtab list at the end */
325 mdebug_psymtab_to_symtab (struct partial_symtab
*pst
)
333 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
334 gdb_flush (gdb_stdout
);
337 next_symbol_text_func
= mdebug_next_symbol_text
;
339 psymtab_to_symtab_1 (pst
, pst
->filename
);
341 /* Match with global symbols. This only needs to be done once,
342 after all of the symtabs and dependencies have been read in. */
343 scan_file_globals (pst
->objfile
);
346 printf_filtered ("done.\n");
349 /* File-level interface functions */
351 /* Find a file descriptor given its index RF relative to a file CF */
354 get_rfd (int cf
, int rf
)
360 fdrs
= debug_info
->fdr
;
362 /* Object files do not have the RFD table, all refs are absolute */
365 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
366 ((char *) debug_info
->external_rfd
368 * debug_swap
->external_rfd_size
)),
373 /* Return a safer print NAME for a file descriptor */
379 return "<stripped file>";
382 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
386 /* Read in and parse the symtab of the file OBJFILE. Symbols from
387 different sections are relocated via the SECTION_OFFSETS. */
390 mdebug_build_psymtabs (struct objfile
*objfile
,
391 const struct ecoff_debug_swap
*swap
,
392 struct ecoff_debug_info
*info
)
394 cur_bfd
= objfile
->obfd
;
398 stabsread_new_init ();
399 buildsym_new_init ();
400 free_header_files ();
401 init_header_files ();
403 /* Make sure all the FDR information is swapped in. */
404 if (info
->fdr
== (FDR
*) NULL
)
410 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->objfile_obstack
,
411 (info
->symbolic_header
.ifdMax
413 fdr_src
= info
->external_fdr
;
415 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
417 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
418 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
421 parse_partial_symbols (objfile
);
424 /* Check to make sure file was compiled with -g. If not, warn the
425 user of this limitation. */
426 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
428 if (max_gdbinfo
== 0)
429 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
431 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
432 gdb_flush (gdb_stdout
);
437 /* Local utilities */
439 /* Map of FDR indexes to partial symtabs */
443 struct partial_symtab
*pst
; /* the psymtab proper */
444 long n_globals
; /* exported globals (external symbols) */
445 long globals_offset
; /* cumulative */
449 /* Utility stack, used to nest procedures and blocks properly.
450 It is a doubly linked list, to avoid too many alloc/free.
451 Since we might need it quite a few times it is NOT deallocated
454 static struct parse_stack
456 struct parse_stack
*next
, *prev
;
457 struct symtab
*cur_st
; /* Current symtab. */
458 struct block
*cur_block
; /* Block in it. */
460 /* What are we parsing. stFile, or stBlock are for files and
461 blocks. stProc or stStaticProc means we have seen the start of a
462 procedure, but not the start of the block within in. When we see
463 the start of that block, we change it to stNil, without pushing a
464 new block, i.e. stNil means both a procedure and a block. */
468 struct type
*cur_type
; /* Type we parse fields for. */
469 int cur_field
; /* Field number in cur_type. */
470 CORE_ADDR procadr
; /* Start addres of this procedure */
471 int numargs
; /* Its argument count */
474 *top_stack
; /* Top stack ptr */
477 /* Enter a new lexical context */
480 push_parse_stack (void)
482 struct parse_stack
*new;
484 /* Reuse frames if possible */
485 if (top_stack
&& top_stack
->prev
)
486 new = top_stack
->prev
;
488 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
489 /* Initialize new frame with previous content */
492 struct parse_stack
*prev
= new->prev
;
495 top_stack
->prev
= new;
497 new->next
= top_stack
;
502 /* Exit a lexical context */
505 pop_parse_stack (void)
510 top_stack
= top_stack
->next
;
514 /* Cross-references might be to things we haven't looked at
515 yet, e.g. type references. To avoid too many type
516 duplications we keep a quick fixup table, an array
517 of lists of references indexed by file descriptor */
519 struct mdebug_pending
521 struct mdebug_pending
*next
; /* link */
522 char *s
; /* the unswapped symbol */
523 struct type
*t
; /* its partial type descriptor */
527 /* The pending information is kept for an entire object file, and used
528 to be in the deprecated_sym_private field. I took it out when I
529 split mdebugread from mipsread, because this might not be the only
530 type of symbols read from an object file. Instead, we allocate the
531 pending information table when we create the partial symbols, and
532 we store a pointer to the single table in each psymtab. */
534 static struct mdebug_pending
**pending_list
;
536 /* Check whether we already saw symbol SH in file FH */
538 static struct mdebug_pending
*
539 is_pending_symbol (FDR
*fh
, char *sh
)
541 int f_idx
= fh
- debug_info
->fdr
;
542 struct mdebug_pending
*p
;
544 /* Linear search is ok, list is typically no more than 10 deep */
545 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
551 /* Add a new symbol SH of type T */
554 add_pending (FDR
*fh
, char *sh
, struct type
*t
)
556 int f_idx
= fh
- debug_info
->fdr
;
557 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
559 /* Make sure we do not make duplicates */
562 p
= ((struct mdebug_pending
*)
563 obstack_alloc (¤t_objfile
->objfile_obstack
,
564 sizeof (struct mdebug_pending
)));
567 p
->next
= pending_list
[f_idx
];
568 pending_list
[f_idx
] = p
;
573 /* Parsing Routines proper. */
575 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
576 For blocks, procedures and types we open a new lexical context.
577 This is basically just a big switch on the symbol's type. Argument
578 AX is the base pointer of aux symbols for this file (fh->iauxBase).
579 EXT_SH points to the unswapped symbol, which is needed for struct,
580 union, etc., types; it is NULL for an EXTR. BIGEND says whether
581 aux symbols are big-endian or little-endian. Return count of
582 SYMR's handled (normally one). */
585 parse_symbol (SYMR
*sh
, union aux_ext
*ax
, char *ext_sh
, int bigend
,
586 struct section_offsets
*section_offsets
, struct objfile
*objfile
)
588 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
589 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
593 struct mdebug_pending
*pend
;
597 enum address_class
class;
599 long svalue
= sh
->value
;
602 if (ext_sh
== (char *) NULL
)
603 name
= debug_info
->ssext
+ sh
->iss
;
605 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
611 /* Do not relocate relative values.
612 The value of a stEnd symbol is the displacement from the
613 corresponding start symbol value.
614 The value of a stBlock symbol is the displacement from the
615 procedure address. */
616 if (sh
->st
!= stEnd
&& sh
->st
!= stBlock
)
617 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
624 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
628 sh
->value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS (objfile
));
637 case stGlobal
: /* external symbol, goes into global block */
639 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
641 s
= new_symbol (name
);
642 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
645 case stStatic
: /* static data, goes into current block. */
647 b
= top_stack
->cur_block
;
648 s
= new_symbol (name
);
649 if (SC_IS_COMMON (sh
->sc
))
651 /* It is a FORTRAN common block. At least for SGI Fortran the
652 address is not in the symbol; we need to fix it later in
653 scan_file_globals. */
654 int bucket
= hashname (DEPRECATED_SYMBOL_NAME (s
));
655 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
656 global_sym_chain
[bucket
] = s
;
659 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
662 case stLocal
: /* local variable, goes into current block */
663 if (sh
->sc
== scRegister
)
665 class = LOC_REGISTER
;
666 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
670 b
= top_stack
->cur_block
;
671 s
= new_symbol (name
);
672 SYMBOL_VALUE (s
) = svalue
;
674 data
: /* Common code for symbols describing data */
675 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
676 SYMBOL_CLASS (s
) = class;
679 /* Type could be missing if file is compiled without debugging info. */
680 if (SC_IS_UNDEF (sh
->sc
)
681 || sh
->sc
== scNil
|| sh
->index
== indexNil
)
682 SYMBOL_TYPE (s
) = nodebug_var_symbol_type
;
684 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
685 /* Value of a data symbol is its memory address */
688 case stParam
: /* arg to procedure, goes into current block */
690 found_ecoff_debugging_info
= 1;
691 top_stack
->numargs
++;
693 /* Special GNU C++ name. */
694 if (is_cplus_marker (name
[0]) && name
[1] == 't' && name
[2] == 0)
695 name
= "this"; /* FIXME, not alloc'd in obstack */
696 s
= new_symbol (name
);
698 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
702 /* Pass by value in register. */
703 SYMBOL_CLASS (s
) = LOC_REGPARM
;
704 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
707 /* Pass by reference on stack. */
708 SYMBOL_CLASS (s
) = LOC_REF_ARG
;
711 /* Pass by reference in register. */
712 SYMBOL_CLASS (s
) = LOC_REGPARM_ADDR
;
713 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
716 /* Pass by value on stack. */
717 SYMBOL_CLASS (s
) = LOC_ARG
;
720 SYMBOL_VALUE (s
) = svalue
;
721 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
722 add_symbol (s
, top_stack
->cur_block
);
725 case stLabel
: /* label, goes into current block */
726 s
= new_symbol (name
);
727 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
; /* so that it can be used */
728 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
729 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
730 SYMBOL_TYPE (s
) = mdebug_type_int
;
731 add_symbol (s
, top_stack
->cur_block
);
734 case stProc
: /* Procedure, usually goes into global block */
735 case stStaticProc
: /* Static procedure, goes into current block */
736 /* For stProc symbol records, we need to check the storage class
737 as well, as only (stProc, scText) entries represent "real"
738 procedures - See the Compaq document titled "Object File /
739 Symbol Table Format Specification" for more information.
740 If the storage class is not scText, we discard the whole block
741 of symbol records for this stProc. */
742 if (sh
->st
== stProc
&& sh
->sc
!= scText
)
744 char *ext_tsym
= ext_sh
;
745 int keep_counting
= 1;
748 while (keep_counting
)
750 ext_tsym
+= external_sym_size
;
751 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
761 complaint (&symfile_complaints
,
762 "unknown symbol type 0x%x", sh
->st
);
768 s
= new_symbol (name
);
769 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
770 SYMBOL_CLASS (s
) = LOC_BLOCK
;
771 /* Type of the return value */
772 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
776 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
777 if (strcmp (name
, "malloc") == 0
778 && TYPE_CODE (t
) == TYPE_CODE_VOID
)
780 /* I don't know why, but, at least under Alpha GNU/Linux,
781 when linking against a malloc without debugging
782 symbols, its read as a function returning void---this
783 is bad because it means we cannot call functions with
784 string arguments interactively; i.e., "call
785 printf("howdy\n")" would fail with the error message
786 "program has no memory available". To avoid this, we
787 patch up the type and make it void*
788 instead. (davidm@azstarnet.com)
790 t
= make_pointer_type (t
, NULL
);
793 b
= top_stack
->cur_block
;
794 if (sh
->st
== stProc
)
796 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
797 /* The next test should normally be true, but provides a
798 hook for nested functions (which we don't want to make
800 if (b
== BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
801 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
802 /* Irix 5 sometimes has duplicate names for the same
803 function. We want to add such names up at the global
804 level, not as a nested function. */
805 else if (sh
->value
== top_stack
->procadr
)
806 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
810 /* Make a type for the procedure itself */
811 SYMBOL_TYPE (s
) = lookup_function_type (t
);
813 /* All functions in C++ have prototypes. For C we don't have enough
814 information in the debug info. */
815 if (SYMBOL_LANGUAGE (s
) == language_cplus
)
816 TYPE_FLAGS (SYMBOL_TYPE (s
)) |= TYPE_FLAG_PROTOTYPED
;
818 /* Create and enter a new lexical context */
819 b
= new_block (FUNCTION_BLOCK
);
820 SYMBOL_BLOCK_VALUE (s
) = b
;
821 BLOCK_FUNCTION (b
) = s
;
822 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
823 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
824 add_block (b
, top_stack
->cur_st
);
826 /* Not if we only have partial info */
827 if (SC_IS_UNDEF (sh
->sc
) || sh
->sc
== scNil
)
831 top_stack
->cur_block
= b
;
832 top_stack
->blocktype
= sh
->st
;
833 top_stack
->cur_type
= SYMBOL_TYPE (s
);
834 top_stack
->cur_field
= -1;
835 top_stack
->procadr
= sh
->value
;
836 top_stack
->numargs
= 0;
839 /* Beginning of code for structure, union, and enum definitions.
840 They all share a common set of local variables, defined here. */
842 enum type_code type_code
;
848 case stStruct
: /* Start a block defining a struct type */
849 type_code
= TYPE_CODE_STRUCT
;
850 goto structured_common
;
852 case stUnion
: /* Start a block defining a union type */
853 type_code
= TYPE_CODE_UNION
;
854 goto structured_common
;
856 case stEnum
: /* Start a block defining an enum type */
857 type_code
= TYPE_CODE_ENUM
;
858 goto structured_common
;
860 case stBlock
: /* Either a lexical block, or some type */
861 if (sh
->sc
!= scInfo
&& !SC_IS_COMMON (sh
->sc
))
862 goto case_stBlock_code
; /* Lexical block */
864 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
866 /* Common code for handling struct, union, enum, and/or as-yet-
867 unknown-type blocks of info about structured data. `type_code'
868 has been set to the proper TYPE_CODE, if we know it. */
870 found_ecoff_debugging_info
= 1;
872 top_stack
->blocktype
= stBlock
;
874 /* First count the number of fields and the highest value. */
877 for (ext_tsym
= ext_sh
+ external_sym_size
;
879 ext_tsym
+= external_sym_size
)
883 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
888 /* C++ encodes class types as structures where there the
889 methods are encoded as stProc. The scope of stProc
890 symbols also ends with stEnd, thus creating a risk of
891 taking the wrong stEnd symbol record as the end of
892 the current struct, which would cause GDB to undercount
893 the real number of fields in this struct. To make sure
894 we really reached the right stEnd symbol record, we
895 check the associated name, and match it against the
896 struct name. Since method names are mangled while
897 the class name is not, there is no risk of having a
898 method whose name is identical to the class name
899 (in particular constructor method names are different
900 from the class name). There is therefore no risk that
901 this check stops the count on the StEnd of a method.
903 Also, assume that we're really at the end when tsym.iss
905 if (tsym
.iss
== issNull
906 || strcmp (debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
,
912 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
914 /* If the type of the member is Nil (or Void),
915 without qualifiers, assume the tag is an
917 Alpha cc -migrate enums are recognized by a zero
918 index and a zero symbol value.
919 DU 4.0 cc enums are recognized by a member type of
920 btEnum without qualifiers and a zero symbol value. */
921 if (tsym
.index
== indexNil
922 || (tsym
.index
== 0 && sh
->value
== 0))
923 type_code
= TYPE_CODE_ENUM
;
926 (*debug_swap
->swap_tir_in
) (bigend
,
927 &ax
[tsym
.index
].a_ti
,
929 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
930 || (tir
.bt
== btEnum
&& sh
->value
== 0))
932 type_code
= TYPE_CODE_ENUM
;
936 if (tsym
.value
> max_value
)
937 max_value
= tsym
.value
;
946 /* This is a no-op; is it trying to tell us something
947 we should be checking? */
948 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED */
952 /* This is something like a struct within a
953 struct. Skip over the fields of the inner
954 struct. The -1 is because the for loop will
955 increment ext_tsym. */
956 ext_tsym
= ((char *) debug_info
->external_sym
957 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
958 * external_sym_size
));
964 /* mips cc puts out a typedef for struct x if it is not yet
965 defined when it encounters
966 struct y { struct x *xp; };
971 /* Irix5 cc puts out a stIndirect for struct x if it is not
972 yet defined when it encounters
973 struct y { struct x *xp; };
978 complaint (&symfile_complaints
,
979 "declaration block contains unhandled symbol type %d",
985 /* In an stBlock, there is no way to distinguish structs,
986 unions, and enums at this point. This is a bug in the
987 original design (that has been fixed with the recent
988 addition of the stStruct, stUnion, and stEnum symbol
989 types.) The way you can tell is if/when you see a variable
990 or field of that type. In that case the variable's type
991 (in the AUX table) says if the type is struct, union, or
992 enum, and points back to the stBlock here. So you can
993 patch the tag kind up later - but only if there actually is
994 a variable or field of that type.
996 So until we know for sure, we will guess at this point.
998 If the first member has index==indexNil or a void type,
999 assume we have an enumeration.
1000 Otherwise, if there is more than one member, and all
1001 the members have offset 0, assume we have a union.
1002 Otherwise, assume we have a struct.
1004 The heuristic could guess wrong in the case of of an
1005 enumeration with no members or a union with one (or zero)
1006 members, or when all except the last field of a struct have
1007 width zero. These are uncommon and/or illegal situations,
1008 and in any case guessing wrong probably doesn't matter
1011 But if we later do find out we were wrong, we fixup the tag
1012 kind. Members of an enumeration must be handled
1013 differently from struct/union fields, and that is harder to
1014 patch up, but luckily we shouldn't need to. (If there are
1015 any enumeration members, we can tell for sure it's an enum
1018 if (type_code
== TYPE_CODE_UNDEF
)
1020 if (nfields
> 1 && max_value
== 0)
1021 type_code
= TYPE_CODE_UNION
;
1023 type_code
= TYPE_CODE_STRUCT
;
1026 /* Create a new type or use the pending type. */
1027 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1028 if (pend
== (struct mdebug_pending
*) NULL
)
1030 t
= new_type (NULL
);
1031 add_pending (cur_fdr
, ext_sh
, t
);
1036 /* Do not set the tag name if it is a compiler generated tag name
1037 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1038 Alpha cc puts out an sh->iss of zero for those. */
1039 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1040 TYPE_TAG_NAME (t
) = NULL
;
1042 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->objfile_obstack
,
1045 TYPE_CODE (t
) = type_code
;
1046 TYPE_LENGTH (t
) = sh
->value
;
1047 TYPE_NFIELDS (t
) = nfields
;
1048 TYPE_FIELDS (t
) = f
= ((struct field
*)
1050 nfields
* sizeof (struct field
)));
1052 if (type_code
== TYPE_CODE_ENUM
)
1054 int unsigned_enum
= 1;
1056 /* This is a non-empty enum. */
1058 /* DEC c89 has the number of enumerators in the sh.value field,
1059 not the type length, so we have to compensate for that
1060 incompatibility quirk.
1061 This might do the wrong thing for an enum with one or two
1062 enumerators and gcc -gcoff -fshort-enums, but these cases
1063 are hopefully rare enough.
1064 Alpha cc -migrate has a sh.value field of zero, we adjust
1066 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
)
1067 || TYPE_LENGTH (t
) == 0)
1068 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1069 for (ext_tsym
= ext_sh
+ external_sym_size
;
1071 ext_tsym
+= external_sym_size
)
1074 struct symbol
*enum_sym
;
1076 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1078 if (tsym
.st
!= stMember
)
1081 FIELD_BITPOS (*f
) = tsym
.value
;
1082 FIELD_TYPE (*f
) = t
;
1083 FIELD_NAME (*f
) = debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1084 FIELD_BITSIZE (*f
) = 0;
1085 FIELD_STATIC_KIND (*f
) = 0;
1087 enum_sym
= ((struct symbol
*)
1088 obstack_alloc (¤t_objfile
->objfile_obstack
,
1089 sizeof (struct symbol
)));
1090 memset (enum_sym
, 0, sizeof (struct symbol
));
1091 DEPRECATED_SYMBOL_NAME (enum_sym
) =
1092 obsavestring (f
->name
, strlen (f
->name
),
1093 ¤t_objfile
->objfile_obstack
);
1094 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1095 SYMBOL_TYPE (enum_sym
) = t
;
1096 SYMBOL_DOMAIN (enum_sym
) = VAR_DOMAIN
;
1097 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1098 if (SYMBOL_VALUE (enum_sym
) < 0)
1100 add_symbol (enum_sym
, top_stack
->cur_block
);
1102 /* Skip the stMembers that we've handled. */
1107 TYPE_FLAGS (t
) |= TYPE_FLAG_UNSIGNED
;
1109 /* make this the current type */
1110 top_stack
->cur_type
= t
;
1111 top_stack
->cur_field
= 0;
1113 /* Do not create a symbol for alpha cc unnamed structs. */
1117 /* gcc puts out an empty struct for an opaque struct definitions,
1118 do not create a symbol for it either. */
1119 if (TYPE_NFIELDS (t
) == 0)
1121 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1125 s
= new_symbol (name
);
1126 SYMBOL_DOMAIN (s
) = STRUCT_DOMAIN
;
1127 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1128 SYMBOL_VALUE (s
) = 0;
1129 SYMBOL_TYPE (s
) = t
;
1130 add_symbol (s
, top_stack
->cur_block
);
1133 /* End of local variables shared by struct, union, enum, and
1134 block (as yet unknown struct/union/enum) processing. */
1138 found_ecoff_debugging_info
= 1;
1139 /* beginnning of (code) block. Value of symbol
1140 is the displacement from procedure start */
1141 push_parse_stack ();
1143 /* Do not start a new block if this is the outermost block of a
1144 procedure. This allows the LOC_BLOCK symbol to point to the
1145 block with the local variables, so funcname::var works. */
1146 if (top_stack
->blocktype
== stProc
1147 || top_stack
->blocktype
== stStaticProc
)
1149 top_stack
->blocktype
= stNil
;
1153 top_stack
->blocktype
= stBlock
;
1154 b
= new_block (NON_FUNCTION_BLOCK
);
1155 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1156 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1157 top_stack
->cur_block
= b
;
1158 add_block (b
, top_stack
->cur_st
);
1161 case stEnd
: /* end (of anything) */
1162 if (sh
->sc
== scInfo
|| SC_IS_COMMON (sh
->sc
))
1164 /* Finished with type */
1165 top_stack
->cur_type
= 0;
1167 else if (sh
->sc
== scText
&&
1168 (top_stack
->blocktype
== stProc
||
1169 top_stack
->blocktype
== stStaticProc
))
1171 /* Finished with procedure */
1172 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1173 struct mdebug_extra_func_info
*e
;
1174 struct block
*b
= top_stack
->cur_block
;
1175 struct type
*ftype
= top_stack
->cur_type
;
1178 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1180 /* Make up special symbol to contain procedure specific info */
1181 s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
1182 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
1183 SYMBOL_CLASS (s
) = LOC_CONST
;
1184 SYMBOL_TYPE (s
) = mdebug_type_void
;
1185 e
= ((struct mdebug_extra_func_info
*)
1186 obstack_alloc (¤t_objfile
->objfile_obstack
,
1187 sizeof (struct mdebug_extra_func_info
)));
1188 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
1189 SYMBOL_VALUE (s
) = (long) e
;
1190 e
->numargs
= top_stack
->numargs
;
1191 e
->pdr
.framereg
= -1;
1192 add_symbol (s
, top_stack
->cur_block
);
1194 /* f77 emits proc-level with address bounds==[0,0],
1195 So look for such child blocks, and patch them. */
1196 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1198 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1199 if (BLOCK_SUPERBLOCK (b_bad
) == b
1200 && BLOCK_START (b_bad
) == top_stack
->procadr
1201 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1203 BLOCK_START (b_bad
) = BLOCK_START (b
);
1204 BLOCK_END (b_bad
) = BLOCK_END (b
);
1208 if (TYPE_NFIELDS (ftype
) <= 0)
1210 /* No parameter type information is recorded with the function's
1211 type. Set that from the type of the parameter symbols. */
1212 int nparams
= top_stack
->numargs
;
1218 struct dict_iterator iter
;
1219 TYPE_NFIELDS (ftype
) = nparams
;
1220 TYPE_FIELDS (ftype
) = (struct field
*)
1221 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
1224 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1226 if (iparams
== nparams
)
1229 switch (SYMBOL_CLASS (sym
))
1234 case LOC_REGPARM_ADDR
:
1235 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
1236 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
1246 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1248 /* End of (code) block. The value of the symbol is the
1249 displacement from the procedure`s start address of the
1250 end of this block. */
1251 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1253 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1255 /* End of outermost block. Pop parse stack and ignore. The
1256 following stEnd of stProc will take care of the block. */
1259 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1261 /* End of file. Pop parse stack and ignore. Higher
1262 level code deals with this. */
1266 complaint (&symfile_complaints
,
1267 "stEnd with storage class %d not handled", sh
->sc
);
1269 pop_parse_stack (); /* restore previous lexical context */
1272 case stMember
: /* member of struct or union */
1273 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1274 FIELD_NAME (*f
) = name
;
1275 FIELD_BITPOS (*f
) = sh
->value
;
1277 FIELD_TYPE (*f
) = parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1278 FIELD_BITSIZE (*f
) = bitsize
;
1279 FIELD_STATIC_KIND (*f
) = 0;
1282 case stIndirect
: /* forward declaration on Irix5 */
1283 /* Forward declarations from Irix5 cc are handled by cross_ref,
1287 case stTypedef
: /* type definition */
1288 found_ecoff_debugging_info
= 1;
1290 /* Typedefs for forward declarations and opaque structs from alpha cc
1291 are handled by cross_ref, skip them. */
1295 /* Parse the type or use the pending type. */
1296 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1297 if (pend
== (struct mdebug_pending
*) NULL
)
1299 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *) NULL
, bigend
, name
);
1300 add_pending (cur_fdr
, ext_sh
, t
);
1305 /* mips cc puts out a typedef with the name of the struct for forward
1306 declarations. These should not go into the symbol table and
1307 TYPE_NAME should not be set for them.
1308 They can't be distinguished from an intentional typedef to
1309 the same name however:
1311 struct x { int ix; int jx; };
1315 struct xx {int ixx; int jxx; };
1316 generates a cross referencing stTypedef for x and xx.
1317 The user visible effect of this is that the type of a pointer
1318 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1319 The problem is fixed with alpha cc and Irix5 cc. */
1321 /* However if the typedef cross references to an opaque aggregate, it
1322 is safe to omit it from the symbol table. */
1324 if (has_opaque_xref (cur_fdr
, sh
))
1326 s
= new_symbol (name
);
1327 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1328 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1329 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1330 SYMBOL_TYPE (s
) = t
;
1331 add_symbol (s
, top_stack
->cur_block
);
1333 /* Incomplete definitions of structs should not get a name. */
1334 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1335 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1336 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1337 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1339 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1340 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1342 /* If we are giving a name to a type such as "pointer to
1343 foo" or "function returning foo", we better not set
1344 the TYPE_NAME. If the program contains "typedef char
1345 *caddr_t;", we don't want all variables of type char
1346 * to print as caddr_t. This is not just a
1347 consequence of GDB's type management; CC and GCC (at
1348 least through version 2.4) both output variables of
1349 either type char * or caddr_t with the type
1350 refering to the stTypedef symbol for caddr_t. If a future
1351 compiler cleans this up it GDB is not ready for it
1352 yet, but if it becomes ready we somehow need to
1353 disable this check (without breaking the PCC/GCC2.4
1358 Fortunately, this check seems not to be necessary
1359 for anything except pointers or functions. */
1362 TYPE_NAME (SYMBOL_TYPE (s
)) = DEPRECATED_SYMBOL_NAME (s
);
1366 case stFile
: /* file name */
1367 push_parse_stack ();
1368 top_stack
->blocktype
= sh
->st
;
1371 /* I`ve never seen these for C */
1373 break; /* register relocation */
1375 break; /* forwarding address */
1377 break; /* constant */
1379 complaint (&symfile_complaints
, "unknown symbol type 0x%x", sh
->st
);
1386 /* Parse the type information provided in the raw AX entries for
1387 the symbol SH. Return the bitfield size in BS, in case.
1388 We must byte-swap the AX entries before we use them; BIGEND says whether
1389 they are big-endian or little-endian (from fh->fBigendian). */
1391 static struct type
*
1392 parse_type (int fd
, union aux_ext
*ax
, unsigned int aux_index
, int *bs
,
1393 int bigend
, char *sym_name
)
1395 /* Null entries in this map are treated specially */
1396 static struct type
**map_bt
[] =
1398 &mdebug_type_void
, /* btNil */
1399 &mdebug_type_adr_32
, /* btAdr */
1400 &mdebug_type_char
, /* btChar */
1401 &mdebug_type_unsigned_char
, /* btUChar */
1402 &mdebug_type_short
, /* btShort */
1403 &mdebug_type_unsigned_short
, /* btUShort */
1404 &mdebug_type_int_32
, /* btInt */
1405 &mdebug_type_unsigned_int_32
, /* btUInt */
1406 &mdebug_type_long_32
, /* btLong */
1407 &mdebug_type_unsigned_long_32
, /* btULong */
1408 &mdebug_type_float
, /* btFloat */
1409 &mdebug_type_double
, /* btDouble */
1416 &mdebug_type_complex
, /* btComplex */
1417 &mdebug_type_double_complex
, /* btDComplex */
1419 &mdebug_type_fixed_dec
, /* btFixedDec */
1420 &mdebug_type_float_dec
, /* btFloatDec */
1421 &mdebug_type_string
, /* btString */
1424 &mdebug_type_void
, /* btVoid */
1425 0, /* DEC C++: Pointer to member */
1426 0, /* DEC C++: Virtual function table */
1427 0, /* DEC C++: Class (Record) */
1428 &mdebug_type_long_64
, /* btLong64 */
1429 &mdebug_type_unsigned_long_64
, /* btULong64 */
1430 &mdebug_type_long_long_64
, /* btLongLong64 */
1431 &mdebug_type_unsigned_long_long_64
, /* btULongLong64 */
1432 &mdebug_type_adr_64
, /* btAdr64 */
1433 &mdebug_type_int_64
, /* btInt64 */
1434 &mdebug_type_unsigned_int_64
, /* btUInt64 */
1438 struct type
*tp
= 0;
1439 enum type_code type_code
= TYPE_CODE_UNDEF
;
1441 /* Handle undefined types, they have indexNil. */
1442 if (aux_index
== indexNil
)
1443 return mdebug_type_int
;
1445 /* Handle corrupt aux indices. */
1446 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1448 index_complaint (sym_name
);
1449 return mdebug_type_int
;
1453 /* Use aux as a type information record, map its basic type. */
1454 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1455 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1457 basic_type_complaint (t
->bt
, sym_name
);
1458 return mdebug_type_int
;
1462 tp
= *map_bt
[t
->bt
];
1467 /* Cannot use builtin types -- build our own */
1471 type_code
= TYPE_CODE_STRUCT
;
1474 type_code
= TYPE_CODE_UNION
;
1477 type_code
= TYPE_CODE_ENUM
;
1480 type_code
= TYPE_CODE_RANGE
;
1483 type_code
= TYPE_CODE_SET
;
1486 /* alpha cc -migrate uses this for typedefs. The true type will
1487 be obtained by crossreferencing below. */
1488 type_code
= TYPE_CODE_ERROR
;
1491 /* alpha cc uses this for typedefs. The true type will be
1492 obtained by crossreferencing below. */
1493 type_code
= TYPE_CODE_ERROR
;
1496 basic_type_complaint (t
->bt
, sym_name
);
1497 return mdebug_type_int
;
1501 /* Move on to next aux */
1506 int width
= AUX_GET_WIDTH (bigend
, ax
);
1507 /* Inhibit core dumps if TIR is corrupted. */
1508 if (bs
== (int *) NULL
)
1510 /* Alpha cc -migrate encodes char and unsigned char types
1511 as short and unsigned short types with a field width of 8.
1512 Enum types also have a field width which we ignore for now. */
1513 if (t
->bt
== btShort
&& width
== 8)
1514 tp
= mdebug_type_char
;
1515 else if (t
->bt
== btUShort
&& width
== 8)
1516 tp
= mdebug_type_unsigned_char
;
1517 else if (t
->bt
== btEnum
)
1520 complaint (&symfile_complaints
, "can't handle TIR fBitfield for %s",
1528 /* A btIndirect entry cross references to an aux entry containing
1530 if (t
->bt
== btIndirect
)
1537 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
1539 if (rn
->rfd
== 0xfff)
1541 rf
= AUX_GET_ISYM (bigend
, ax
);
1549 complaint (&symfile_complaints
,
1550 "unable to cross ref btIndirect for %s", sym_name
);
1551 return mdebug_type_int
;
1553 xref_fh
= get_rfd (fd
, rf
);
1554 xref_fd
= xref_fh
- debug_info
->fdr
;
1555 tp
= parse_type (xref_fd
, debug_info
->external_aux
+ xref_fh
->iauxBase
,
1556 rn
->index
, (int *) NULL
, xref_fh
->fBigendian
, sym_name
);
1559 /* All these types really point to some (common) MIPS type
1560 definition, and only the type-qualifiers fully identify
1561 them. We'll make the same effort at sharing. */
1562 if (t
->bt
== btStruct
||
1566 /* btSet (I think) implies that the name is a tag name, not a typedef
1567 name. This apparently is a MIPS extension for C sets. */
1572 /* Try to cross reference this type, build new type on failure. */
1573 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1574 if (tp
== (struct type
*) NULL
)
1575 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1577 /* DEC c89 produces cross references to qualified aggregate types,
1578 dereference them. */
1579 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1580 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1581 tp
= TYPE_TARGET_TYPE (tp
);
1583 /* Make sure that TYPE_CODE(tp) has an expected type code.
1584 Any type may be returned from cross_ref if file indirect entries
1586 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1587 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1588 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1590 unexpected_type_code_complaint (sym_name
);
1595 /* Usually, TYPE_CODE(tp) is already type_code. The main
1596 exception is if we guessed wrong re struct/union/enum.
1597 But for struct vs. union a wrong guess is harmless, so
1598 don't complain(). */
1599 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1600 && type_code
!= TYPE_CODE_ENUM
)
1601 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1602 && type_code
== TYPE_CODE_ENUM
))
1604 bad_tag_guess_complaint (sym_name
);
1607 if (TYPE_CODE (tp
) != type_code
)
1609 TYPE_CODE (tp
) = type_code
;
1612 /* Do not set the tag name if it is a compiler generated tag name
1613 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1614 if (name
[0] == '.' || name
[0] == '\0')
1615 TYPE_TAG_NAME (tp
) = NULL
;
1616 else if (TYPE_TAG_NAME (tp
) == NULL
1617 || strcmp (TYPE_TAG_NAME (tp
), name
) != 0)
1618 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1619 ¤t_objfile
->objfile_obstack
);
1623 /* All these types really point to some (common) MIPS type
1624 definition, and only the type-qualifiers fully identify
1625 them. We'll make the same effort at sharing.
1626 FIXME: We are not doing any guessing on range types. */
1627 if (t
->bt
== btRange
)
1631 /* Try to cross reference this type, build new type on failure. */
1632 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1633 if (tp
== (struct type
*) NULL
)
1634 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1636 /* Make sure that TYPE_CODE(tp) has an expected type code.
1637 Any type may be returned from cross_ref if file indirect entries
1639 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1641 unexpected_type_code_complaint (sym_name
);
1645 /* Usually, TYPE_CODE(tp) is already type_code. The main
1646 exception is if we guessed wrong re struct/union/enum. */
1647 if (TYPE_CODE (tp
) != type_code
)
1649 bad_tag_guess_complaint (sym_name
);
1650 TYPE_CODE (tp
) = type_code
;
1652 if (TYPE_NAME (tp
) == NULL
1653 || strcmp (TYPE_NAME (tp
), name
) != 0)
1654 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1655 ¤t_objfile
->objfile_obstack
);
1658 if (t
->bt
== btTypedef
)
1662 /* Try to cross reference this type, it should succeed. */
1663 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1664 if (tp
== (struct type
*) NULL
)
1666 complaint (&symfile_complaints
,
1667 "unable to cross ref btTypedef for %s", sym_name
);
1668 tp
= mdebug_type_int
;
1672 /* Deal with range types */
1673 if (t
->bt
== btRange
)
1675 TYPE_NFIELDS (tp
) = 2;
1676 TYPE_FIELDS (tp
) = ((struct field
*)
1677 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1678 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1679 ¤t_objfile
->objfile_obstack
);
1680 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1682 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1683 ¤t_objfile
->objfile_obstack
);
1684 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1688 /* Parse all the type qualifiers now. If there are more
1689 than 6 the game will continue in the next aux */
1693 #define PARSE_TQ(tq) \
1694 if (t->tq != tqNil) \
1695 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1707 /* mips cc 2.x and gcc never put out continued aux entries. */
1711 (*debug_swap
->swap_tir_in
) (bigend
, &ax
->a_ti
, t
);
1715 /* Complain for illegal continuations due to corrupt aux entries. */
1717 complaint (&symfile_complaints
, "illegal TIR continued for %s", sym_name
);
1722 /* Make up a complex type from a basic one. Type is passed by
1723 reference in TPP and side-effected as necessary. The type
1724 qualifier TQ says how to handle the aux symbols at AX for
1725 the symbol SX we are currently analyzing. BIGEND says whether
1726 aux symbols are big-endian or little-endian.
1727 Returns the number of aux symbols we parsed. */
1730 upgrade_type (int fd
, struct type
**tpp
, int tq
, union aux_ext
*ax
, int bigend
,
1736 /* Used in array processing */
1747 t
= lookup_pointer_type (*tpp
);
1752 t
= lookup_function_type (*tpp
);
1759 /* Determine and record the domain type (type of index) */
1760 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, &rndx
);
1766 rf
= AUX_GET_ISYM (bigend
, ax
);
1769 fh
= get_rfd (fd
, rf
);
1771 indx
= parse_type (fh
- debug_info
->fdr
,
1772 debug_info
->external_aux
+ fh
->iauxBase
,
1773 id
, (int *) NULL
, bigend
, sym_name
);
1775 /* The bounds type should be an integer type, but might be anything
1776 else due to corrupt aux entries. */
1777 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1779 complaint (&symfile_complaints
,
1780 "illegal array index type for %s, assuming int", sym_name
);
1781 indx
= mdebug_type_int
;
1784 /* Get the bounds, and create the array type. */
1786 lower
= AUX_GET_DNLOW (bigend
, ax
);
1788 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1790 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1792 range
= create_range_type ((struct type
*) NULL
, indx
,
1795 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1797 /* We used to fill in the supplied array element bitsize
1798 here if the TYPE_LENGTH of the target type was zero.
1799 This happens for a `pointer to an array of anonymous structs',
1800 but in this case the array element bitsize is also zero,
1801 so nothing is gained.
1802 And we used to check the TYPE_LENGTH of the target type against
1803 the supplied array element bitsize.
1804 gcc causes a mismatch for `pointer to array of object',
1805 since the sdb directives it uses do not have a way of
1806 specifying the bitsize, but it does no harm (the
1807 TYPE_LENGTH should be correct) and we should be able to
1808 ignore the erroneous bitsize from the auxiliary entry safely.
1809 dbx seems to ignore it too. */
1811 /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
1813 if (TYPE_LENGTH (*tpp
) == 0)
1815 TYPE_FLAGS (t
) |= TYPE_FLAG_TARGET_STUB
;
1822 /* Volatile -- currently ignored */
1826 /* Const -- currently ignored */
1830 complaint (&symfile_complaints
, "unknown type qualifier 0x%x", tq
);
1836 /* Parse a procedure descriptor record PR. Note that the procedure is
1837 parsed _after_ the local symbols, now we just insert the extra
1838 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1839 already been placed in the procedure's main block. Note also that
1840 images that have been partially stripped (ld -x) have been deprived
1841 of local symbols, and we have to cope with them here. FIRST_OFF is
1842 the offset of the first procedure for this FDR; we adjust the
1843 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1844 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1845 in question, or NULL to use top_stack->cur_block. */
1847 static void parse_procedure (PDR
*, struct symtab
*, struct partial_symtab
*);
1850 parse_procedure (PDR
*pr
, struct symtab
*search_symtab
,
1851 struct partial_symtab
*pst
)
1853 struct symbol
*s
, *i
;
1855 struct mdebug_extra_func_info
*e
;
1858 /* Simple rule to find files linked "-x" */
1859 if (cur_fdr
->rss
== -1)
1863 /* Static procedure at address pr->adr. Sigh. */
1864 /* FIXME-32x64. assuming pr->adr fits in long. */
1865 complaint (&symfile_complaints
,
1866 "can't handle PDR for static proc at 0x%lx",
1867 (unsigned long) pr
->adr
);
1875 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1876 ((char *) debug_info
->external_ext
1878 * debug_swap
->external_ext_size
)),
1880 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1888 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1889 ((char *) debug_info
->external_sym
1890 + ((cur_fdr
->isymBase
+ pr
->isym
)
1891 * debug_swap
->external_sym_size
)),
1893 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1896 if (search_symtab
!= NULL
)
1899 /* This loses both in the case mentioned (want a static, find a global),
1900 but also if we are looking up a non-mangled name which happens to
1901 match the name of a mangled function. */
1902 /* We have to save the cur_fdr across the call to lookup_symbol.
1903 If the pdr is for a static function and if a global function with
1904 the same name exists, lookup_symbol will eventually read in the symtab
1905 for the global function and clobber cur_fdr. */
1906 FDR
*save_cur_fdr
= cur_fdr
;
1907 s
= lookup_symbol (sh_name
, NULL
, VAR_DOMAIN
, 0, NULL
);
1908 cur_fdr
= save_cur_fdr
;
1912 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1918 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1919 VAR_DOMAIN
, LOC_BLOCK
);
1923 b
= SYMBOL_BLOCK_VALUE (s
);
1927 complaint (&symfile_complaints
, "PDR for %s, but no symbol", sh_name
);
1931 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1932 s
= new_symbol (sh_name
);
1933 SYMBOL_DOMAIN (s
) = VAR_DOMAIN
;
1934 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1935 /* Donno its type, hope int is ok */
1936 SYMBOL_TYPE (s
) = lookup_function_type (mdebug_type_int
);
1937 add_symbol (s
, top_stack
->cur_block
);
1938 /* Wont have symbols for this one */
1940 SYMBOL_BLOCK_VALUE (s
) = b
;
1941 BLOCK_FUNCTION (b
) = s
;
1942 BLOCK_START (b
) = pr
->adr
;
1943 /* BOUND used to be the end of procedure's text, but the
1944 argument is no longer passed in. */
1945 BLOCK_END (b
) = bound
;
1946 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1947 add_block (b
, top_stack
->cur_st
);
1951 i
= mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME
, b
, LABEL_DOMAIN
, LOC_CONST
);
1955 e
= (struct mdebug_extra_func_info
*) SYMBOL_VALUE (i
);
1957 e
->pdr
.isym
= (long) s
;
1959 /* GDB expects the absolute function start address for the
1960 procedure descriptor in e->pdr.adr.
1961 As the address in the procedure descriptor is usually relative,
1962 we would have to relocate e->pdr.adr with cur_fdr->adr and
1963 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
1964 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
1965 in shared libraries on some systems, and on other systems
1966 e->pdr.adr is sometimes offset by a bogus value.
1967 To work around these problems, we replace e->pdr.adr with
1968 the start address of the function. */
1969 e
->pdr
.adr
= BLOCK_START (b
);
1971 /* Correct incorrect setjmp procedure descriptor from the library
1972 to make backtrace through setjmp work. */
1973 if (e
->pdr
.pcreg
== 0
1974 && strcmp (sh_name
, "setjmp") == 0)
1976 complaint (&symfile_complaints
, "fixing bad setjmp PDR from libc");
1978 e
->pdr
.pcreg
= RA_REGNUM
;
1982 e
->pdr
.regmask
= 0x80000000;
1983 e
->pdr
.regoffset
= -4;
1987 /* It would be reasonable that functions that have been compiled
1988 without debugging info have a btNil type for their return value,
1989 and functions that are void and are compiled with debugging info
1991 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
1992 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
1994 The glevel field in cur_fdr could be used to determine the presence
1995 of debugging info, but GCC doesn't always pass the -g switch settings
1996 to the assembler and GAS doesn't set the glevel field from the -g switch
1998 To work around these problems, the return value type of a TYPE_CODE_VOID
1999 function is adjusted accordingly if no debugging info was found in the
2000 compilation unit. */
2002 if (processing_gcc_compilation
== 0
2003 && found_ecoff_debugging_info
== 0
2004 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s
))) == TYPE_CODE_VOID
)
2005 SYMBOL_TYPE (s
) = nodebug_func_symbol_type
;
2008 /* Parse the external symbol ES. Just call parse_symbol() after
2009 making sure we know where the aux are for it.
2010 BIGEND says whether aux entries are big-endian or little-endian.
2012 This routine clobbers top_stack->cur_block and ->cur_st. */
2014 static void parse_external (EXTR
*, int, struct section_offsets
*,
2018 parse_external (EXTR
*es
, int bigend
, struct section_offsets
*section_offsets
,
2019 struct objfile
*objfile
)
2023 if (es
->ifd
!= ifdNil
)
2026 cur_fdr
= debug_info
->fdr
+ cur_fd
;
2027 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
2031 cur_fdr
= debug_info
->fdr
;
2035 /* Reading .o files */
2036 if (SC_IS_UNDEF (es
->asym
.sc
) || es
->asym
.sc
== scNil
)
2039 switch (es
->asym
.st
)
2042 /* These are generated for static symbols in .o files,
2063 /* FIXME: Turn this into a complaint? */
2065 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
2066 what
, debug_info
->ssext
+ es
->asym
.iss
,
2067 fdr_name (cur_fdr
));
2071 switch (es
->asym
.st
)
2075 /* There is no need to parse the external procedure symbols.
2076 If they are from objects compiled without -g, their index will
2077 be indexNil, and the symbol definition from the minimal symbol
2078 is preferrable (yielding a function returning int instead of int).
2079 If the index points to a local procedure symbol, the local
2080 symbol already provides the correct type.
2081 Note that the index of the external procedure symbol points
2082 to the local procedure symbol in the local symbol table, and
2083 _not_ to the auxiliary symbol info. */
2087 /* Global common symbols are resolved by the runtime loader,
2089 if (SC_IS_COMMON (es
->asym
.sc
))
2092 /* Note that the case of a symbol with indexNil must be handled
2093 anyways by parse_symbol(). */
2094 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
, section_offsets
, objfile
);
2101 /* Parse the line number info for file descriptor FH into
2102 GDB's linetable LT. MIPS' encoding requires a little bit
2103 of magic to get things out. Note also that MIPS' line
2104 numbers can go back and forth, apparently we can live
2105 with that and do not need to reorder our linetables */
2107 static void parse_lines (FDR
*, PDR
*, struct linetable
*, int,
2108 struct partial_symtab
*, CORE_ADDR
);
2111 parse_lines (FDR
*fh
, PDR
*pr
, struct linetable
*lt
, int maxlines
,
2112 struct partial_symtab
*pst
, CORE_ADDR lowest_pdr_addr
)
2114 unsigned char *base
;
2116 int delta
, count
, lineno
= 0;
2118 if (fh
->cbLine
== 0)
2121 /* Scan by procedure descriptors */
2123 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
2127 unsigned char *halt
;
2129 /* No code for this one */
2130 if (pr
->iline
== ilineNil
||
2131 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
2134 /* Determine start and end address of compressed line bytes for
2136 base
= debug_info
->line
+ fh
->cbLineOffset
;
2137 if (j
!= (fh
->cpd
- 1))
2138 halt
= base
+ pr
[1].cbLineOffset
;
2140 halt
= base
+ fh
->cbLine
;
2141 base
+= pr
->cbLineOffset
;
2143 adr
= pst
->textlow
+ pr
->adr
- lowest_pdr_addr
;
2145 l
= adr
>> 2; /* in words */
2146 for (lineno
= pr
->lnLow
; base
< halt
;)
2148 count
= *base
& 0x0f;
2149 delta
= *base
++ >> 4;
2154 delta
= (base
[0] << 8) | base
[1];
2155 if (delta
>= 0x8000)
2159 lineno
+= delta
; /* first delta is 0 */
2161 /* Complain if the line table overflows. Could happen
2162 with corrupt binaries. */
2163 if (lt
->nitems
>= maxlines
)
2165 complaint (&symfile_complaints
,
2166 "guessed size of linetable for %s incorrectly",
2170 k
= add_line (lt
, lineno
, l
, k
);
2177 function_outside_compilation_unit_complaint (const char *arg1
)
2179 complaint (&symfile_complaints
,
2180 "function `%s' appears to be defined outside of all compilation units",
2184 /* Master parsing procedure for first-pass reading of file symbols
2185 into a partial_symtab. */
2188 parse_partial_symbols (struct objfile
*objfile
)
2190 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2191 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
2192 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2193 void (*const swap_ext_in
) (bfd
*, void *, EXTR
*) = debug_swap
->swap_ext_in
;
2194 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
2195 void (*const swap_rfd_in
) (bfd
*, void *, RFDT
*) = debug_swap
->swap_rfd_in
;
2197 HDRR
*hdr
= &debug_info
->symbolic_header
;
2198 /* Running pointers */
2206 struct partial_symtab
*pst
;
2207 int textlow_not_set
= 1;
2208 int past_first_source_file
= 0;
2210 /* List of current psymtab's include files */
2211 char **psymtab_include_list
;
2212 int includes_allocated
;
2215 struct pst_map
*fdr_to_pst
;
2216 /* Index within current psymtab dependency list */
2217 struct partial_symtab
**dependency_list
;
2218 int dependencies_used
, dependencies_allocated
;
2219 struct cleanup
*old_chain
;
2221 enum language prev_language
;
2222 asection
*text_sect
;
2223 int relocatable
= 0;
2225 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2226 the shared libraries are prelinked at a high memory address.
2227 We have to adjust the start address of the object file for this case,
2228 by setting it to the start address of the first procedure in the file.
2229 But we should do no adjustments if we are debugging a .o file, where
2230 the text section (and fh->adr) really starts at zero. */
2231 text_sect
= bfd_get_section_by_name (cur_bfd
, ".text");
2232 if (text_sect
!= NULL
2233 && (bfd_get_section_flags (cur_bfd
, text_sect
) & SEC_RELOC
))
2236 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->objfile_obstack
,
2237 sizeof (EXTR
) * hdr
->iextMax
);
2239 includes_allocated
= 30;
2241 psymtab_include_list
= (char **) alloca (includes_allocated
*
2243 next_symbol_text_func
= mdebug_next_symbol_text
;
2245 dependencies_allocated
= 30;
2246 dependencies_used
= 0;
2248 (struct partial_symtab
**) alloca (dependencies_allocated
*
2249 sizeof (struct partial_symtab
*));
2251 last_source_file
= NULL
;
2256 * Only parse the Local and External symbols, and the Relative FDR.
2257 * Fixup enough of the loader symtab to be able to use it.
2258 * Allocate space only for the file's portions we need to
2263 max_glevel
= MIN_GLEVEL
;
2265 /* Allocate the map FDR -> PST.
2266 Minor hack: -O3 images might claim some global data belongs
2267 to FDR -1. We`ll go along with that */
2268 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2269 old_chain
= make_cleanup (xfree
, fdr_to_pst
);
2272 struct partial_symtab
*pst
= new_psymtab ("", objfile
);
2273 fdr_to_pst
[-1].pst
= pst
;
2277 /* Allocate the global pending list. */
2279 ((struct mdebug_pending
**)
2280 obstack_alloc (&objfile
->objfile_obstack
,
2281 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2282 memset (pending_list
, 0,
2283 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2285 /* Pass 0 over external syms: swap them in. */
2286 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2287 make_cleanup (xfree
, ext_block
);
2289 ext_out
= (char *) debug_info
->external_ext
;
2290 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2292 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2293 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2295 /* Pass 1 over external syms: Presize and partition the list */
2297 ext_in_end
= ext_in
+ hdr
->iextMax
;
2298 for (; ext_in
< ext_in_end
; ext_in
++)
2300 /* See calls to complain below. */
2301 if (ext_in
->ifd
>= -1
2302 && ext_in
->ifd
< hdr
->ifdMax
2303 && ext_in
->asym
.iss
>= 0
2304 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2305 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2308 /* Pass 1.5 over files: partition out global symbol space */
2310 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2312 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2313 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2314 fdr_to_pst
[f_idx
].n_globals
= 0;
2319 For ECOFF in ELF, we skip the creation of the minimal symbols.
2320 The ECOFF symbols should be a subset of the Elf symbols, and the
2321 section information of the elf symbols will be more accurate.
2322 FIXME! What about Irix 5's native linker?
2324 By default, Elf sections which don't exist in ECOFF
2325 get put in ECOFF's absolute section by the gnu linker.
2326 Since absolute sections don't get relocated, we
2327 end up calculating an address different from that of
2328 the symbol's minimal symbol (created earlier from the
2331 To fix this, either :
2332 1) don't create the duplicate symbol
2333 (assumes ECOFF symtab is a subset of the ELF symtab;
2334 assumes no side-effects result from ignoring ECOFF symbol)
2335 2) create it, only if lookup for existing symbol in ELF's minimal
2338 assumes no side-effects result from ignoring ECOFF symbol)
2339 3) create it, but lookup ELF's minimal symbol and use it's section
2340 during relocation, then modify "uniqify" phase to merge and
2341 eliminate the duplicate symbol
2342 (highly inefficient)
2344 I've implemented #1 here...
2345 Skip the creation of the minimal symbols based on the ECOFF
2348 /* Pass 2 over external syms: fill in external symbols */
2350 ext_in_end
= ext_in
+ hdr
->iextMax
;
2351 for (; ext_in
< ext_in_end
; ext_in
++)
2353 enum minimal_symbol_type ms_type
= mst_text
;
2354 CORE_ADDR svalue
= ext_in
->asym
.value
;
2356 /* The Irix 5 native tools seem to sometimes generate bogus
2357 external symbols. */
2358 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2360 complaint (&symfile_complaints
,
2361 "bad ifd for external symbol: %d (max %ld)", ext_in
->ifd
,
2365 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2367 complaint (&symfile_complaints
,
2368 "bad iss for external symbol: %ld (max %ld)",
2369 ext_in
->asym
.iss
, hdr
->issExtMax
);
2373 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2374 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2377 if (SC_IS_UNDEF (ext_in
->asym
.sc
) || ext_in
->asym
.sc
== scNil
)
2381 /* Pass 3 over files, over local syms: fill in static symbols */
2382 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2384 /* Process ECOFF Symbol Types and Storage Classes */
2385 switch (ext_in
->asym
.st
)
2388 /* Beginnning of Procedure */
2389 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2392 /* Load time only static procs */
2393 ms_type
= mst_file_text
;
2394 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2397 /* External symbol */
2398 if (SC_IS_COMMON (ext_in
->asym
.sc
))
2400 /* The value of a common symbol is its size, not its address.
2404 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2407 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2409 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2412 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2414 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2417 svalue
+= ANOFFSET (objfile
->section_offsets
,
2418 get_section_index (objfile
, ".sbss"));
2426 /* On certain platforms, some extra label symbols can be
2427 generated by the linker. One possible usage for this kind
2428 of symbols is to represent the address of the begining of a
2429 given section. For instance, on Tru64 5.1, the address of
2430 the _ftext label is the start address of the .text section.
2432 The storage class of these symbols is usually directly
2433 related to the section to which the symbol refers. For
2434 instance, on Tru64 5.1, the storage class for the _fdata
2435 label is scData, refering to the .data section.
2437 It is actually possible that the section associated to the
2438 storage class of the label does not exist. On True64 5.1
2439 for instance, the libm.so shared library does not contain
2440 any .data section, although it contains a _fpdata label
2441 which storage class is scData... Since these symbols are
2442 usually useless for the debugger user anyway, we just
2443 discard these symbols.
2446 if (SC_IS_TEXT (ext_in
->asym
.sc
))
2448 if (objfile
->sect_index_text
== -1)
2451 ms_type
= mst_file_text
;
2452 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2454 else if (SC_IS_DATA (ext_in
->asym
.sc
))
2456 if (objfile
->sect_index_data
== -1)
2459 ms_type
= mst_file_data
;
2460 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2462 else if (SC_IS_BSS (ext_in
->asym
.sc
))
2464 if (objfile
->sect_index_bss
== -1)
2467 ms_type
= mst_file_bss
;
2468 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2470 else if (SC_IS_SBSS (ext_in
->asym
.sc
))
2472 const int sbss_sect_index
= get_section_index (objfile
, ".sbss");
2474 if (sbss_sect_index
== -1)
2477 ms_type
= mst_file_bss
;
2478 svalue
+= ANOFFSET (objfile
->section_offsets
, sbss_sect_index
);
2485 /* The alpha has the section start addresses in stLocal symbols
2486 whose name starts with a `.'. Skip those but complain for all
2487 other stLocal symbols.
2488 Irix6 puts the section start addresses in stNil symbols, skip
2494 ms_type
= mst_unknown
;
2495 unknown_ext_complaint (name
);
2497 if (!ECOFF_IN_ELF (cur_bfd
))
2498 prim_record_minimal_symbol (name
, svalue
, ms_type
, objfile
);
2501 /* Pass 3 over files, over local syms: fill in static symbols */
2502 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2504 struct partial_symtab
*save_pst
;
2508 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2512 fdr_to_pst
[f_idx
].pst
= NULL
;
2516 /* Determine the start address for this object file from the
2517 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2521 if (relocatable
|| textlow
!= 0)
2522 textlow
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2526 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
2529 objfile
->global_psymbols
.next
,
2530 objfile
->static_psymbols
.next
);
2531 pst
->read_symtab_private
= ((char *)
2532 obstack_alloc (&objfile
->objfile_obstack
,
2533 sizeof (struct symloc
)));
2534 memset (pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2537 FDR_IDX (pst
) = f_idx
;
2538 CUR_BFD (pst
) = cur_bfd
;
2539 DEBUG_SWAP (pst
) = debug_swap
;
2540 DEBUG_INFO (pst
) = debug_info
;
2541 PENDING_LIST (pst
) = pending_list
;
2543 /* The way to turn this into a symtab is to call... */
2544 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2546 /* Set up language for the pst.
2547 The language from the FDR is used if it is unambigious (e.g. cfront
2548 with native cc and g++ will set the language to C).
2549 Otherwise we have to deduce the language from the filename.
2550 Native ecoff has every header file in a separate FDR, so
2551 deduce_language_from_filename will return language_unknown for
2552 a header file, which is not what we want.
2553 But the FDRs for the header files are after the FDR for the source
2554 file, so we can assign the language of the source file to the
2555 following header files. Then we save the language in the private
2556 pst data so that we can reuse it when building symtabs. */
2557 prev_language
= psymtab_language
;
2561 case langCplusplusV2
:
2562 psymtab_language
= language_cplus
;
2565 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2568 if (psymtab_language
== language_unknown
)
2569 psymtab_language
= prev_language
;
2570 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2572 pst
->texthigh
= pst
->textlow
;
2574 /* For stabs-in-ecoff files, the second symbol must be @stab.
2575 This symbol is emitted by mips-tfile to signal that the
2576 current object file uses encapsulated stabs instead of mips
2577 ecoff for local symbols. (It is the second symbol because
2578 the first symbol is the stFile used to signal the start of a
2580 processing_gcc_compilation
= 0;
2583 (*swap_sym_in
) (cur_bfd
,
2584 ((char *) debug_info
->external_sym
2585 + (fh
->isymBase
+ 1) * external_sym_size
),
2587 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2589 processing_gcc_compilation
= 2;
2592 if (processing_gcc_compilation
!= 0)
2594 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2599 (*swap_sym_in
) (cur_bfd
,
2600 (((char *) debug_info
->external_sym
)
2601 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2603 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2604 if (!ECOFF_IS_STAB (&sh
))
2606 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2611 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2612 if (sh
.st
== stStaticProc
)
2614 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2615 prim_record_minimal_symbol_and_info (namestring
,
2619 SECT_OFF_TEXT (objfile
),
2623 procaddr
= sh
.value
;
2625 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2626 (debug_info
->external_aux
2629 (*swap_sym_in
) (cur_bfd
,
2630 ((char *) debug_info
->external_sym
2631 + ((fh
->isymBase
+ isym
- 1)
2632 * external_sym_size
)),
2636 CORE_ADDR high
= procaddr
+ sh
.value
;
2638 /* Kludge for Irix 5.2 zero fh->adr. */
2640 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
2641 pst
->textlow
= procaddr
;
2642 if (high
> pst
->texthigh
)
2643 pst
->texthigh
= high
;
2646 else if (sh
.st
== stStatic
)
2661 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2662 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2663 prim_record_minimal_symbol_and_info (namestring
,
2667 SECT_OFF_DATA (objfile
),
2673 /* FIXME! Shouldn't this use cases for bss,
2674 then have the default be abs? */
2675 namestring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2676 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2677 prim_record_minimal_symbol_and_info (namestring
,
2681 SECT_OFF_BSS (objfile
),
2689 /* Handle stabs continuation */
2691 char *stabstring
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2692 int len
= strlen (stabstring
);
2693 while (stabstring
[len
- 1] == '\\')
2696 char *stabstring1
= stabstring
;
2700 /* Ignore continuation char from 1st string */
2703 /* Read next stabstring */
2705 (*swap_sym_in
) (cur_bfd
,
2706 (((char *) debug_info
->external_sym
)
2707 + (fh
->isymBase
+ cur_sdx
)
2708 * external_sym_size
),
2710 stabstring2
= debug_info
->ss
+ fh
->issBase
+ sh2
.iss
;
2711 len2
= strlen (stabstring2
);
2713 /* Concatinate stabstring2 with stabstring1 */
2715 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
2716 stabstring
= xrealloc (stabstring
, len
+ len2
+ 1);
2719 stabstring
= xmalloc (len
+ len2
+ 1);
2720 strcpy (stabstring
, stabstring1
);
2722 strcpy (stabstring
+ len
, stabstring2
);
2730 * Standard, external, non-debugger, symbols
2733 case N_TEXT
| N_EXT
:
2734 case N_NBTEXT
| N_EXT
:
2735 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2738 case N_DATA
| N_EXT
:
2739 case N_NBDATA
| N_EXT
:
2740 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2745 case N_NBBSS
| N_EXT
:
2746 case N_SETV
| N_EXT
: /* FIXME, is this in BSS? */
2747 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
2754 /* Standard, local, non-debugger, symbols */
2758 /* We need to be able to deal with both N_FN or N_TEXT,
2759 because we have no way of knowing whether the sys-supplied ld
2760 or GNU ld was used to make the executable. Sequents throw
2761 in another wrinkle -- they renumbered N_FN. */
2769 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2772 case N_UNDF
| N_EXT
:
2773 continue; /* Just undefined, not COMMON */
2778 /* Lots of symbol types we can just ignore. */
2785 /* Keep going . . . */
2788 * Special symbol types for GNU
2791 case N_INDR
| N_EXT
:
2793 case N_SETA
| N_EXT
:
2795 case N_SETT
| N_EXT
:
2797 case N_SETD
| N_EXT
:
2799 case N_SETB
| N_EXT
:
2810 static int prev_so_symnum
= -10;
2811 static int first_so_symnum
;
2813 int prev_textlow_not_set
;
2815 valu
= sh
.value
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2817 prev_textlow_not_set
= textlow_not_set
;
2819 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2820 /* A zero value is probably an indication for the SunPRO 3.0
2821 compiler. end_psymtab explicitly tests for zero, so
2822 don't relocate it. */
2826 textlow_not_set
= 1;
2830 textlow_not_set
= 0;
2832 textlow_not_set
= 0;
2834 past_first_source_file
= 1;
2836 if (prev_so_symnum
!= symnum
- 1)
2837 { /* Here if prev stab wasn't N_SO */
2838 first_so_symnum
= symnum
;
2842 pst
= (struct partial_symtab
*) 0;
2844 dependencies_used
= 0;
2848 prev_so_symnum
= symnum
;
2850 /* End the current partial symtab and start a new one */
2852 /* SET_NAMESTRING ();*/
2853 namestring
= stabstring
;
2855 /* Null name means end of .o file. Don't start a new one. */
2856 if (*namestring
== '\000')
2859 /* Some compilers (including gcc) emit a pair of initial N_SOs.
2860 The first one is a directory name; the second the file name.
2861 If pst exists, is empty, and has a filename ending in '/',
2862 we assume the previous N_SO was a directory name. */
2864 p
= strrchr (namestring
, '/');
2865 if (p
&& *(p
+ 1) == '\000')
2866 continue; /* Simply ignore directory name SOs */
2868 /* Some other compilers (C++ ones in particular) emit useless
2869 SOs for non-existant .c files. We ignore all subsequent SOs that
2870 immediately follow the first. */
2882 enum language tmp_language
;
2883 /* Mark down an include file in the current psymtab */
2885 /* SET_NAMESTRING ();*/
2886 namestring
= stabstring
;
2888 tmp_language
= deduce_language_from_filename (namestring
);
2890 /* Only change the psymtab's language if we've learned
2891 something useful (eg. tmp_language is not language_unknown).
2892 In addition, to match what start_subfile does, never change
2894 if (tmp_language
!= language_unknown
2895 && (tmp_language
!= language_c
2896 || psymtab_language
!= language_cplus
))
2897 psymtab_language
= tmp_language
;
2899 /* In C++, one may expect the same filename to come round many
2900 times, when code is coming alternately from the main file
2901 and from inline functions in other files. So I check to see
2902 if this is a file we've seen before -- either the main
2903 source file, or a previously included file.
2905 This seems to be a lot of time to be spending on N_SOL, but
2906 things like "break c-exp.y:435" need to work (I
2907 suppose the psymtab_include_list could be hashed or put
2908 in a binary tree, if profiling shows this is a major hog). */
2909 if (pst
&& strcmp (namestring
, pst
->filename
) == 0)
2913 for (i
= 0; i
< includes_used
; i
++)
2914 if (strcmp (namestring
,
2915 psymtab_include_list
[i
]) == 0)
2924 psymtab_include_list
[includes_used
++] = namestring
;
2925 if (includes_used
>= includes_allocated
)
2927 char **orig
= psymtab_include_list
;
2929 psymtab_include_list
= (char **)
2930 alloca ((includes_allocated
*= 2) *
2932 memcpy (psymtab_include_list
, orig
,
2933 includes_used
* sizeof (char *));
2937 case N_LSYM
: /* Typedef or automatic variable. */
2938 case N_STSYM
: /* Data seg var -- static */
2939 case N_LCSYM
: /* BSS " */
2940 case N_ROSYM
: /* Read-only data seg var -- static. */
2941 case N_NBSTS
: /* Gould nobase. */
2942 case N_NBLCS
: /* symbols. */
2944 case N_GSYM
: /* Global (extern) variable; can be
2945 data or bss (sigh FIXME). */
2947 /* Following may probably be ignored; I'll leave them here
2948 for now (until I do Pascal and Modula 2 extensions). */
2950 case N_PC
: /* I may or may not need this; I
2952 case N_M2C
: /* I suspect that I can ignore this here. */
2953 case N_SCOPE
: /* Same. */
2955 /* SET_NAMESTRING ();*/
2956 namestring
= stabstring
;
2957 p
= (char *) strchr (namestring
, ':');
2959 continue; /* Not a debugging symbol. */
2963 /* Main processing section for debugging symbols which
2964 the initial read through the symbol tables needs to worry
2965 about. If we reach this point, the symbol which we are
2966 considering is definitely one we are interested in.
2967 p must also contain the (valid) index into the namestring
2968 which indicates the debugging type symbol. */
2973 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2974 #ifdef STATIC_TRANSFORM_NAME
2975 namestring
= STATIC_TRANSFORM_NAME (namestring
);
2977 add_psymbol_to_list (namestring
, p
- namestring
,
2978 VAR_DOMAIN
, LOC_STATIC
,
2979 &objfile
->static_psymbols
,
2981 psymtab_language
, objfile
);
2984 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2985 /* The addresses in these entries are reported to be
2986 wrong. See the code that reads 'G's for symtabs. */
2987 add_psymbol_to_list (namestring
, p
- namestring
,
2988 VAR_DOMAIN
, LOC_STATIC
,
2989 &objfile
->global_psymbols
,
2991 psymtab_language
, objfile
);
2995 /* When a 'T' entry is defining an anonymous enum, it
2996 may have a name which is the empty string, or a
2997 single space. Since they're not really defining a
2998 symbol, those shouldn't go in the partial symbol
2999 table. We do pick up the elements of such enums at
3000 'check_enum:', below. */
3001 if (p
>= namestring
+ 2
3002 || (p
== namestring
+ 1
3003 && namestring
[0] != ' '))
3005 add_psymbol_to_list (namestring
, p
- namestring
,
3006 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3007 &objfile
->static_psymbols
,
3009 psymtab_language
, objfile
);
3012 /* Also a typedef with the same name. */
3013 add_psymbol_to_list (namestring
, p
- namestring
,
3014 VAR_DOMAIN
, LOC_TYPEDEF
,
3015 &objfile
->static_psymbols
,
3017 psymtab_language
, objfile
);
3023 if (p
!= namestring
) /* a name is there, not just :T... */
3025 add_psymbol_to_list (namestring
, p
- namestring
,
3026 VAR_DOMAIN
, LOC_TYPEDEF
,
3027 &objfile
->static_psymbols
,
3029 psymtab_language
, objfile
);
3032 /* If this is an enumerated type, we need to
3033 add all the enum constants to the partial symbol
3034 table. This does not cover enums without names, e.g.
3035 "enum {a, b} c;" in C, but fortunately those are
3036 rare. There is no way for GDB to find those from the
3037 enum type without spending too much time on it. Thus
3038 to solve this problem, the compiler needs to put out the
3039 enum in a nameless type. GCC2 does this. */
3041 /* We are looking for something of the form
3042 <name> ":" ("t" | "T") [<number> "="] "e"
3043 {<constant> ":" <value> ","} ";". */
3045 /* Skip over the colon and the 't' or 'T'. */
3047 /* This type may be given a number. Also, numbers can come
3048 in pairs like (0,26). Skip over it. */
3049 while ((*p
>= '0' && *p
<= '9')
3050 || *p
== '(' || *p
== ',' || *p
== ')'
3056 /* The aix4 compiler emits extra crud before the members. */
3059 /* Skip over the type (?). */
3063 /* Skip over the colon. */
3067 /* We have found an enumerated type. */
3068 /* According to comments in read_enum_type
3069 a comma could end it instead of a semicolon.
3070 I don't know where that happens.
3072 while (*p
&& *p
!= ';' && *p
!= ',')
3076 /* Check for and handle cretinous dbx symbol name
3078 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
3079 p
= next_symbol_text (objfile
);
3081 /* Point to the character after the name
3082 of the enum constant. */
3083 for (q
= p
; *q
&& *q
!= ':'; q
++)
3085 /* Note that the value doesn't matter for
3086 enum constants in psymtabs, just in symtabs. */
3087 add_psymbol_to_list (p
, q
- p
,
3088 VAR_DOMAIN
, LOC_CONST
,
3089 &objfile
->static_psymbols
, 0,
3090 0, psymtab_language
, objfile
);
3091 /* Point past the name. */
3093 /* Skip over the value. */
3094 while (*p
&& *p
!= ',')
3096 /* Advance past the comma. */
3103 /* Constant, e.g. from "const" in Pascal. */
3104 add_psymbol_to_list (namestring
, p
- namestring
,
3105 VAR_DOMAIN
, LOC_CONST
,
3106 &objfile
->static_psymbols
, sh
.value
,
3107 0, psymtab_language
, objfile
);
3113 int name_len
= p
- namestring
;
3114 char *name
= xmalloc (name_len
+ 1);
3115 memcpy (name
, namestring
, name_len
);
3116 name
[name_len
] = '\0';
3117 function_outside_compilation_unit_complaint (name
);
3120 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3121 add_psymbol_to_list (namestring
, p
- namestring
,
3122 VAR_DOMAIN
, LOC_BLOCK
,
3123 &objfile
->static_psymbols
,
3125 psymtab_language
, objfile
);
3128 /* Global functions were ignored here, but now they
3129 are put into the global psymtab like one would expect.
3130 They're also in the minimal symbol table. */
3134 int name_len
= p
- namestring
;
3135 char *name
= xmalloc (name_len
+ 1);
3136 memcpy (name
, namestring
, name_len
);
3137 name
[name_len
] = '\0';
3138 function_outside_compilation_unit_complaint (name
);
3141 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3142 add_psymbol_to_list (namestring
, p
- namestring
,
3143 VAR_DOMAIN
, LOC_BLOCK
,
3144 &objfile
->global_psymbols
,
3146 psymtab_language
, objfile
);
3149 /* Two things show up here (hopefully); static symbols of
3150 local scope (static used inside braces) or extensions
3151 of structure symbols. We can ignore both. */
3165 case '#': /* for symbol identification (used in live ranges) */
3169 /* It is a C++ nested symbol. We don't need to record it
3170 (I don't think); if we try to look up foo::bar::baz,
3171 then symbols for the symtab containing foo should get
3172 read in, I think. */
3173 /* Someone says sun cc puts out symbols like
3174 /foo/baz/maclib::/usr/local/bin/maclib,
3175 which would get here with a symbol type of ':'. */
3179 /* Unexpected symbol descriptor. The second and subsequent stabs
3180 of a continued stab can show up here. The question is
3181 whether they ever can mimic a normal stab--it would be
3182 nice if not, since we certainly don't want to spend the
3183 time searching to the end of every string looking for
3186 complaint (&symfile_complaints
,
3187 "unknown symbol descriptor `%c'", p
[1]);
3189 /* Ignore it; perhaps it is an extension that we don't
3198 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
3199 /* Solaris 2 end of module, finish current partial
3200 symbol table. END_PSYMTAB will set
3201 pst->texthigh to the proper value, which is
3202 necessary if a module compiled without
3203 debugging info follows this module. */
3206 pst
= (struct partial_symtab
*) 0;
3208 dependencies_used
= 0;
3214 if (sh
.value
> save_pst
->texthigh
)
3215 save_pst
->texthigh
= sh
.value
;
3220 case N_SSYM
: /* Claim: Structure or union element.
3221 Hopefully, I can ignore this. */
3222 case N_ENTRY
: /* Alternate entry point; can ignore. */
3223 case N_MAIN
: /* Can definitely ignore this. */
3224 case N_CATCH
: /* These are GNU C++ extensions */
3225 case N_EHDECL
: /* that can safely be ignored here. */
3235 case N_NSYMS
: /* Ultrix 4.0: symbol count */
3236 case N_DEFD
: /* GNU Modula-2 */
3237 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
3239 case N_OBJ
: /* useless types from Solaris */
3241 /* These symbols aren't interesting; don't worry about them */
3246 /* If we haven't found it yet, ignore it. It's probably some
3247 new type we don't know about yet. */
3248 complaint (&symfile_complaints
, "unknown symbol type %s",
3249 hex_string (type_code
)); /*CUR_SYMBOL_TYPE*/
3253 && stabstring
!= debug_info
->ss
+ fh
->issBase
+ sh
.iss
)
3256 /* end - Handle continuation */
3261 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
3264 enum address_class
class;
3266 (*swap_sym_in
) (cur_bfd
,
3267 ((char *) debug_info
->external_sym
3268 + ((fh
->isymBase
+ cur_sdx
)
3269 * external_sym_size
)),
3272 if (ECOFF_IS_STAB (&sh
))
3278 /* Non absolute static symbols go into the minimal table. */
3279 if (SC_IS_UNDEF (sh
.sc
) || sh
.sc
== scNil
3280 || (sh
.index
== indexNil
3281 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
3283 /* FIXME, premature? */
3288 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3294 /* The value of a stEnd symbol is the displacement from the
3295 corresponding start symbol value, do not relocate it. */
3297 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3304 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3308 sh
.value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3319 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3320 mst_file_text
, NULL
,
3321 SECT_OFF_TEXT (objfile
), NULL
,
3327 /* Ignore all parameter symbol records. */
3328 if (sh
.index
>= hdr
->iauxMax
)
3330 /* Should not happen, but does when cross-compiling
3331 with the MIPS compiler. FIXME -- pull later. */
3332 index_complaint (name
);
3333 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
3336 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
3337 (debug_info
->external_aux
3341 if (new_sdx
<= cur_sdx
)
3343 /* This should not happen either... FIXME. */
3344 complaint (&symfile_complaints
,
3345 "bad proc end in aux found from symbol %s",
3347 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3350 /* For stProc symbol records, we need to check the
3351 storage class as well, as only (stProc, scText)
3352 entries represent "real" procedures - See the
3353 Compaq document titled "Object File / Symbol Table
3354 Format Specification" for more information. If the
3355 storage class is not scText, we discard the whole
3356 block of symbol records for this stProc. */
3357 if (sh
.st
== stProc
&& sh
.sc
!= scText
)
3360 /* Usually there is a local and a global stProc symbol
3361 for a function. This means that the function name
3362 has already been entered into the mimimal symbol table
3363 while processing the global symbols in pass 2 above.
3364 One notable exception is the PROGRAM name from
3365 f77 compiled executables, it is only put out as
3366 local stProc symbol, and a global MAIN__ stProc symbol
3367 points to it. It doesn't matter though, as gdb is
3368 still able to find the PROGRAM name via the partial
3369 symbol table, and the MAIN__ symbol via the minimal
3371 if (sh
.st
== stProc
)
3372 add_psymbol_to_list (name
, strlen (name
),
3373 VAR_DOMAIN
, LOC_BLOCK
,
3374 &objfile
->global_psymbols
,
3375 0, sh
.value
, psymtab_language
, objfile
);
3377 add_psymbol_to_list (name
, strlen (name
),
3378 VAR_DOMAIN
, LOC_BLOCK
,
3379 &objfile
->static_psymbols
,
3380 0, sh
.value
, psymtab_language
, objfile
);
3382 procaddr
= sh
.value
;
3385 (*swap_sym_in
) (cur_bfd
,
3386 ((char *) debug_info
->external_sym
3387 + ((fh
->isymBase
+ cur_sdx
- 1)
3388 * external_sym_size
)),
3393 /* Kludge for Irix 5.2 zero fh->adr. */
3395 && (pst
->textlow
== 0 || procaddr
< pst
->textlow
))
3396 pst
->textlow
= procaddr
;
3398 high
= procaddr
+ sh
.value
;
3399 if (high
> pst
->texthigh
)
3400 pst
->texthigh
= high
;
3403 case stStatic
: /* Variable */
3404 if (SC_IS_DATA (sh
.sc
))
3405 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3406 mst_file_data
, NULL
,
3407 SECT_OFF_DATA (objfile
),
3411 prim_record_minimal_symbol_and_info (name
, sh
.value
,
3413 SECT_OFF_BSS (objfile
),
3419 case stIndirect
: /* Irix5 forward declaration */
3420 /* Skip forward declarations from Irix5 cc */
3423 case stTypedef
: /* Typedef */
3424 /* Skip typedefs for forward declarations and opaque
3425 structs from alpha and mips cc. */
3426 if (sh
.iss
== 0 || has_opaque_xref (fh
, &sh
))
3428 class = LOC_TYPEDEF
;
3431 case stConstant
: /* Constant decl */
3438 case stBlock
: /* { }, str, un, enum */
3439 /* Do not create a partial symbol for cc unnamed aggregates
3440 and gcc empty aggregates. */
3441 if ((sh
.sc
== scInfo
3442 || SC_IS_COMMON (sh
.sc
))
3444 && sh
.index
!= cur_sdx
+ 2)
3446 add_psymbol_to_list (name
, strlen (name
),
3447 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3448 &objfile
->static_psymbols
,
3450 psymtab_language
, objfile
);
3452 handle_psymbol_enumerators (objfile
, fh
, sh
.st
, sh
.value
);
3454 /* Skip over the block */
3456 if (new_sdx
<= cur_sdx
)
3458 /* This happens with the Ultrix kernel. */
3459 complaint (&symfile_complaints
,
3460 "bad aux index at block symbol %s", name
);
3461 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
3466 case stFile
: /* File headers */
3467 case stLabel
: /* Labels */
3468 case stEnd
: /* Ends of files */
3471 case stLocal
: /* Local variables */
3472 /* Normally these are skipped because we skip over
3473 all blocks we see. However, these can occur
3474 as visible symbols in a .h file that contains code. */
3478 /* Both complaints are valid: one gives symbol name,
3479 the other the offending symbol type. */
3480 complaint (&symfile_complaints
, "unknown local symbol %s",
3482 complaint (&symfile_complaints
, "with type %d", sh
.st
);
3486 /* Use this gdb symbol */
3487 add_psymbol_to_list (name
, strlen (name
),
3489 &objfile
->static_psymbols
,
3490 0, sh
.value
, psymtab_language
, objfile
);
3492 cur_sdx
++; /* Go to next file symbol */
3495 /* Now do enter the external symbols. */
3496 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
3497 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
3498 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
3499 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
3500 for (; --cur_sdx
>= 0; ext_ptr
++)
3502 enum address_class
class;
3507 if (ext_ptr
->ifd
!= f_idx
)
3508 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
3509 psh
= &ext_ptr
->asym
;
3511 /* Do not add undefined symbols to the partial symbol table. */
3512 if (SC_IS_UNDEF (psh
->sc
) || psh
->sc
== scNil
)
3515 svalue
= psh
->value
;
3520 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3527 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
3531 svalue
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
3538 /* These are generated for static symbols in .o files,
3543 /* External procedure symbols have been entered
3544 into the minimal symbol table in pass 2 above.
3545 Ignore them, as parse_external will ignore them too. */
3551 unknown_ext_complaint (debug_info
->ssext
+ psh
->iss
);
3552 /* Fall through, pretend it's global. */
3554 /* Global common symbols are resolved by the runtime loader,
3556 if (SC_IS_COMMON (psh
->sc
))
3562 name
= debug_info
->ssext
+ psh
->iss
;
3563 add_psymbol_to_list (name
, strlen (name
),
3565 &objfile
->global_psymbols
,
3567 psymtab_language
, objfile
);
3571 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3572 empty and put on the free list. */
3573 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
3574 psymtab_include_list
, includes_used
,
3575 -1, save_pst
->texthigh
,
3576 dependency_list
, dependencies_used
, textlow_not_set
);
3578 dependencies_used
= 0;
3580 /* The objfile has its functions reordered if this partial symbol
3581 table overlaps any other partial symbol table.
3582 We cannot assume a reordered objfile if a partial symbol table
3583 is contained within another partial symbol table, as partial symbol
3584 tables for include files with executable code are contained
3585 within the partial symbol table for the including source file,
3586 and we do not want to flag the objfile reordered for these cases.
3588 This strategy works well for Irix-5.2 shared libraries, but we
3589 might have to use a more elaborate (and slower) algorithm for
3591 save_pst
= fdr_to_pst
[f_idx
].pst
;
3592 if (save_pst
!= NULL
3593 && save_pst
->textlow
!= 0
3594 && !(objfile
->flags
& OBJF_REORDERED
))
3596 ALL_OBJFILE_PSYMTABS (objfile
, pst
)
3599 && save_pst
->textlow
>= pst
->textlow
3600 && save_pst
->textlow
< pst
->texthigh
3601 && save_pst
->texthigh
> pst
->texthigh
)
3603 objfile
->flags
|= OBJF_REORDERED
;
3610 /* Now scan the FDRs for dependencies */
3611 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
3613 fh
= f_idx
+ debug_info
->fdr
;
3614 pst
= fdr_to_pst
[f_idx
].pst
;
3616 if (pst
== (struct partial_symtab
*) NULL
)
3619 /* This should catch stabs-in-ecoff. */
3623 /* Skip the first file indirect entry as it is a self dependency
3624 for source files or a reverse .h -> .c dependency for header files. */
3625 pst
->number_of_dependencies
= 0;
3627 ((struct partial_symtab
**)
3628 obstack_alloc (&objfile
->objfile_obstack
,
3630 * sizeof (struct partial_symtab
*))));
3631 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
3635 (*swap_rfd_in
) (cur_bfd
,
3636 ((char *) debug_info
->external_rfd
3637 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
3639 if (rh
< 0 || rh
>= hdr
->ifdMax
)
3641 complaint (&symfile_complaints
, "bad file number %ld", rh
);
3645 /* Skip self dependencies of header files. */
3649 /* Do not add to dependeny list if psymtab was empty. */
3650 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*) NULL
)
3652 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
3656 /* Remove the dummy psymtab created for -O3 images above, if it is
3657 still empty, to enable the detection of stripped executables. */
3658 if (objfile
->psymtabs
->next
== NULL
3659 && objfile
->psymtabs
->number_of_dependencies
== 0
3660 && objfile
->psymtabs
->n_global_syms
== 0
3661 && objfile
->psymtabs
->n_static_syms
== 0)
3662 objfile
->psymtabs
= NULL
;
3663 do_cleanups (old_chain
);
3666 /* If the current psymbol has an enumerated type, we need to add
3667 all the the enum constants to the partial symbol table. */
3670 handle_psymbol_enumerators (struct objfile
*objfile
, FDR
*fh
, int stype
,
3673 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
3674 void (*const swap_sym_in
) (bfd
*, void *, SYMR
*) = debug_swap
->swap_sym_in
;
3675 char *ext_sym
= ((char *) debug_info
->external_sym
3676 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
3686 /* It is an enumerated type if the next symbol entry is a stMember
3687 and its auxiliary index is indexNil or its auxiliary entry
3688 is a plain btNil or btVoid.
3689 Alpha cc -migrate enums are recognized by a zero index and
3690 a zero symbol value.
3691 DU 4.0 cc enums are recognized by a member type of btEnum without
3692 qualifiers and a zero symbol value. */
3693 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3694 if (sh
.st
!= stMember
)
3697 if (sh
.index
== indexNil
3698 || (sh
.index
== 0 && svalue
== 0))
3700 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
,
3701 &(debug_info
->external_aux
3702 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3704 if ((tir
.bt
!= btNil
3706 && (tir
.bt
!= btEnum
|| svalue
!= 0))
3707 || tir
.tq0
!= tqNil
)
3719 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
3720 if (sh
.st
!= stMember
)
3722 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3724 /* Note that the value doesn't matter for enum constants
3725 in psymtabs, just in symtabs. */
3726 add_psymbol_to_list (name
, strlen (name
),
3727 VAR_DOMAIN
, LOC_CONST
,
3728 &objfile
->static_psymbols
, 0,
3729 (CORE_ADDR
) 0, psymtab_language
, objfile
);
3730 ext_sym
+= external_sym_size
;
3734 /* Get the next symbol. OBJFILE is unused. */
3737 mdebug_next_symbol_text (struct objfile
*objfile
)
3742 (*debug_swap
->swap_sym_in
) (cur_bfd
,
3743 ((char *) debug_info
->external_sym
3744 + ((cur_fdr
->isymBase
+ cur_sdx
)
3745 * debug_swap
->external_sym_size
)),
3747 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
3750 /* Ancillary function to psymtab_to_symtab(). Does all the work
3751 for turning the partial symtab PST into a symtab, recurring
3752 first on all dependent psymtabs. The argument FILENAME is
3753 only passed so we can see in debug stack traces what file
3756 This function has a split personality, based on whether the
3757 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3758 The flow of control and even the memory allocation differs. FIXME. */
3761 psymtab_to_symtab_1 (struct partial_symtab
*pst
, char *filename
)
3763 bfd_size_type external_sym_size
;
3764 bfd_size_type external_pdr_size
;
3765 void (*swap_sym_in
) (bfd
*, void *, SYMR
*);
3766 void (*swap_pdr_in
) (bfd
*, void *, PDR
*);
3768 struct symtab
*st
= NULL
;
3770 struct linetable
*lines
;
3771 CORE_ADDR lowest_pdr_addr
= 0;
3772 int last_symtab_ended
= 0;
3778 /* Read in all partial symbtabs on which this one is dependent.
3779 NOTE that we do have circular dependencies, sigh. We solved
3780 that by setting pst->readin before this point. */
3782 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
3783 if (!pst
->dependencies
[i
]->readin
)
3785 /* Inform about additional files to be read in. */
3788 fputs_filtered (" ", gdb_stdout
);
3790 fputs_filtered ("and ", gdb_stdout
);
3792 printf_filtered ("%s...",
3793 pst
->dependencies
[i
]->filename
);
3794 wrap_here (""); /* Flush output */
3795 gdb_flush (gdb_stdout
);
3797 /* We only pass the filename for debug purposes */
3798 psymtab_to_symtab_1 (pst
->dependencies
[i
],
3799 pst
->dependencies
[i
]->filename
);
3802 /* Do nothing if this is a dummy psymtab. */
3804 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
3805 && pst
->textlow
== 0 && pst
->texthigh
== 0)
3808 /* Now read the symbols for this symtab */
3810 cur_bfd
= CUR_BFD (pst
);
3811 debug_swap
= DEBUG_SWAP (pst
);
3812 debug_info
= DEBUG_INFO (pst
);
3813 pending_list
= PENDING_LIST (pst
);
3814 external_sym_size
= debug_swap
->external_sym_size
;
3815 external_pdr_size
= debug_swap
->external_pdr_size
;
3816 swap_sym_in
= debug_swap
->swap_sym_in
;
3817 swap_pdr_in
= debug_swap
->swap_pdr_in
;
3818 current_objfile
= pst
->objfile
;
3819 cur_fd
= FDR_IDX (pst
);
3820 fh
= ((cur_fd
== -1)
3822 : debug_info
->fdr
+ cur_fd
);
3825 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3826 processing_gcc_compilation
= 0;
3827 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
3831 (*swap_sym_in
) (cur_bfd
,
3832 ((char *) debug_info
->external_sym
3833 + (fh
->isymBase
+ 1) * external_sym_size
),
3835 if (strcmp (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
3838 /* We indicate that this is a GCC compilation so that certain
3839 features will be enabled in stabsread/dbxread. */
3840 processing_gcc_compilation
= 2;
3844 if (processing_gcc_compilation
!= 0)
3847 /* This symbol table contains stabs-in-ecoff entries. */
3849 /* Parse local symbols first */
3851 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
3853 current_objfile
= NULL
;
3856 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
3862 (*swap_sym_in
) (cur_bfd
,
3863 (((char *) debug_info
->external_sym
)
3864 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
3866 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3868 /* XXX This is a hack. It will go away! */
3869 if (ECOFF_IS_STAB (&sh
) || (name
[0] == '#'))
3871 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
3873 /* We should never get non N_STAB symbols here, but they
3874 should be harmless, so keep process_one_symbol from
3875 complaining about them. */
3876 if (type_code
& N_STAB
)
3878 /* If we found a trailing N_SO with no name, process
3879 it here instead of in process_one_symbol, so we
3880 can keep a handle to its symtab. The symtab
3881 would otherwise be ended twice, once in
3882 process_one_symbol, and once after this loop. */
3883 if (type_code
== N_SO
3885 && previous_stab_code
!= (unsigned char) N_SO
3888 valu
+= ANOFFSET (pst
->section_offsets
,
3889 SECT_OFF_TEXT (pst
->objfile
));
3890 previous_stab_code
= N_SO
;
3891 st
= end_symtab (valu
, pst
->objfile
,
3892 SECT_OFF_TEXT (pst
->objfile
));
3894 last_symtab_ended
= 1;
3898 last_symtab_ended
= 0;
3899 process_one_symbol (type_code
, 0, valu
, name
,
3900 pst
->section_offsets
, pst
->objfile
);
3903 /* Similarly a hack. */
3904 else if (name
[0] == '#')
3906 process_one_symbol (N_SLINE
, 0, valu
, name
,
3907 pst
->section_offsets
, pst
->objfile
);
3909 if (type_code
== N_FUN
)
3911 /* Make up special symbol to contain
3912 procedure specific info */
3913 struct mdebug_extra_func_info
*e
=
3914 ((struct mdebug_extra_func_info
*)
3915 obstack_alloc (¤t_objfile
->objfile_obstack
,
3916 sizeof (struct mdebug_extra_func_info
)));
3917 struct symbol
*s
= new_symbol (MDEBUG_EFI_SYMBOL_NAME
);
3919 memset (e
, 0, sizeof (struct mdebug_extra_func_info
));
3920 SYMBOL_DOMAIN (s
) = LABEL_DOMAIN
;
3921 SYMBOL_CLASS (s
) = LOC_CONST
;
3922 SYMBOL_TYPE (s
) = mdebug_type_void
;
3923 SYMBOL_VALUE (s
) = (long) e
;
3924 e
->pdr
.framereg
= -1;
3925 add_symbol_to_list (s
, &local_symbols
);
3928 else if (sh
.st
== stLabel
)
3930 if (sh
.index
== indexNil
)
3932 /* This is what the gcc2_compiled and __gnu_compiled_*
3933 show up as. So don't complain. */
3938 /* Handle encoded stab line number. */
3939 valu
+= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (pst
->objfile
));
3940 record_line (current_subfile
, sh
.index
, valu
);
3943 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
3944 || sh
.st
== stStatic
|| sh
.st
== stEnd
)
3945 /* These are generated by gcc-2.x, do not complain */
3948 complaint (&symfile_complaints
, "unknown stabs symbol %s", name
);
3951 if (! last_symtab_ended
)
3953 st
= end_symtab (pst
->texthigh
, pst
->objfile
, SECT_OFF_TEXT (pst
->objfile
));
3957 /* There used to be a call to sort_blocks here, but this should not
3958 be necessary for stabs symtabs. And as sort_blocks modifies the
3959 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3960 it did the wrong thing if the first procedure in a file was
3961 generated via asm statements. */
3963 /* Fill in procedure info next. */
3967 struct cleanup
*old_chain
;
3973 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
3974 old_chain
= make_cleanup (xfree
, pr_block
);
3976 pdr_ptr
= ((char *) debug_info
->external_pdr
3977 + fh
->ipdFirst
* external_pdr_size
);
3978 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
3982 pdr_ptr
+= external_pdr_size
, pdr_in
++)
3984 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
3986 /* Determine lowest PDR address, the PDRs are not always
3988 if (pdr_in
== pr_block
)
3989 lowest_pdr_addr
= pdr_in
->adr
;
3990 else if (pdr_in
->adr
< lowest_pdr_addr
)
3991 lowest_pdr_addr
= pdr_in
->adr
;
3995 pdr_in_end
= pdr_in
+ fh
->cpd
;
3996 for (; pdr_in
< pdr_in_end
; pdr_in
++)
3997 parse_procedure (pdr_in
, st
, pst
);
3999 do_cleanups (old_chain
);
4004 /* This symbol table contains ordinary ecoff entries. */
4013 st
= new_symtab ("unknown", 0, pst
->objfile
);
4017 maxlines
= 2 * fh
->cline
;
4018 st
= new_symtab (pst
->filename
, maxlines
, pst
->objfile
);
4020 /* The proper language was already determined when building
4021 the psymtab, use it. */
4022 st
->language
= PST_PRIVATE (pst
)->pst_language
;
4025 psymtab_language
= st
->language
;
4027 lines
= LINETABLE (st
);
4029 /* Get a new lexical context */
4031 push_parse_stack ();
4032 top_stack
->cur_st
= st
;
4033 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
4035 BLOCK_START (top_stack
->cur_block
) = pst
->textlow
;
4036 BLOCK_END (top_stack
->cur_block
) = 0;
4037 top_stack
->blocktype
= stFile
;
4038 top_stack
->cur_type
= 0;
4039 top_stack
->procadr
= 0;
4040 top_stack
->numargs
= 0;
4041 found_ecoff_debugging_info
= 0;
4048 /* Parse local symbols first */
4049 sym_ptr
= ((char *) debug_info
->external_sym
4050 + fh
->isymBase
* external_sym_size
);
4051 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
4052 while (sym_ptr
< sym_end
)
4057 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
4058 c
= parse_symbol (&sh
,
4059 debug_info
->external_aux
+ fh
->iauxBase
,
4060 sym_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4061 sym_ptr
+= c
* external_sym_size
;
4064 /* Linenumbers. At the end, check if we can save memory.
4065 parse_lines has to look ahead an arbitrary number of PDR
4066 structures, so we swap them all first. */
4070 struct cleanup
*old_chain
;
4076 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
4078 old_chain
= make_cleanup (xfree
, pr_block
);
4080 pdr_ptr
= ((char *) debug_info
->external_pdr
4081 + fh
->ipdFirst
* external_pdr_size
);
4082 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
4086 pdr_ptr
+= external_pdr_size
, pdr_in
++)
4088 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
4090 /* Determine lowest PDR address, the PDRs are not always
4092 if (pdr_in
== pr_block
)
4093 lowest_pdr_addr
= pdr_in
->adr
;
4094 else if (pdr_in
->adr
< lowest_pdr_addr
)
4095 lowest_pdr_addr
= pdr_in
->adr
;
4098 parse_lines (fh
, pr_block
, lines
, maxlines
, pst
, lowest_pdr_addr
);
4099 if (lines
->nitems
< fh
->cline
)
4100 lines
= shrink_linetable (lines
);
4102 /* Fill in procedure info next. */
4104 pdr_in_end
= pdr_in
+ fh
->cpd
;
4105 for (; pdr_in
< pdr_in_end
; pdr_in
++)
4106 parse_procedure (pdr_in
, 0, pst
);
4108 do_cleanups (old_chain
);
4112 LINETABLE (st
) = lines
;
4114 /* .. and our share of externals.
4115 XXX use the global list to speed up things here. how?
4116 FIXME, Maybe quit once we have found the right number of ext's? */
4117 top_stack
->cur_st
= st
;
4118 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
4120 top_stack
->blocktype
= stFile
;
4122 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
4123 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
4124 parse_external (ext_ptr
, fh
->fBigendian
, pst
->section_offsets
, pst
->objfile
);
4126 /* If there are undefined symbols, tell the user.
4127 The alpha has an undefined symbol for every symbol that is
4128 from a shared library, so tell the user only if verbose is on. */
4129 if (info_verbose
&& n_undef_symbols
)
4131 printf_filtered ("File %s contains %d unresolved references:",
4132 st
->filename
, n_undef_symbols
);
4133 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
4134 n_undef_vars
, n_undef_procs
, n_undef_labels
);
4135 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
4145 /* Now link the psymtab and the symtab. */
4148 current_objfile
= NULL
;
4151 /* Ancillary parsing procedures. */
4153 /* Return 1 if the symbol pointed to by SH has a cross reference
4154 to an opaque aggregate type, else 0. */
4157 has_opaque_xref (FDR
*fh
, SYMR
*sh
)
4164 if (sh
->index
== indexNil
)
4167 ax
= debug_info
->external_aux
+ fh
->iauxBase
+ sh
->index
;
4168 (*debug_swap
->swap_tir_in
) (fh
->fBigendian
, &ax
->a_ti
, &tir
);
4169 if (tir
.bt
!= btStruct
&& tir
.bt
!= btUnion
&& tir
.bt
!= btEnum
)
4173 (*debug_swap
->swap_rndx_in
) (fh
->fBigendian
, &ax
->a_rndx
, rn
);
4174 if (rn
->rfd
== 0xfff)
4175 rf
= AUX_GET_ISYM (fh
->fBigendian
, ax
+ 1);
4183 /* Lookup the type at relative index RN. Return it in TPP
4184 if found and in any event come up with its name PNAME.
4185 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4186 Return value says how many aux symbols we ate. */
4189 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. */
4190 char **pname
, int bigend
, char *sym_name
)
4199 struct mdebug_pending
*pend
;
4201 *tpp
= (struct type
*) NULL
;
4203 (*debug_swap
->swap_rndx_in
) (bigend
, &ax
->a_rndx
, rn
);
4205 /* Escape index means 'the next one' */
4206 if (rn
->rfd
== 0xfff)
4209 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
4216 /* mips cc uses a rf of -1 for opaque struct definitions.
4217 Set TYPE_FLAG_STUB for these types so that check_typedef will
4218 resolve them if the struct gets defined in another compilation unit. */
4221 *pname
= "<undefined>";
4222 *tpp
= init_type (type_code
, 0, TYPE_FLAG_STUB
, (char *) NULL
, current_objfile
);
4226 /* mips cc uses an escaped rn->index of 0 for struct return types
4227 of procedures that were compiled without -g. These will always remain
4229 if (rn
->rfd
== 0xfff && rn
->index
== 0)
4231 *pname
= "<undefined>";
4235 /* Find the relative file descriptor and the symbol in it. */
4236 fh
= get_rfd (fd
, rf
);
4237 xref_fd
= fh
- debug_info
->fdr
;
4239 if (rn
->index
>= fh
->csym
)
4241 /* File indirect entry is corrupt. */
4242 *pname
= "<illegal>";
4243 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4247 /* If we have processed this symbol then we left a forwarding
4248 pointer to the type in the pending list. If not, we`ll put
4249 it in a list of pending types, to be processed later when
4250 the file will be. In any event, we collect the name for the
4253 esh
= ((char *) debug_info
->external_sym
4254 + ((fh
->isymBase
+ rn
->index
)
4255 * debug_swap
->external_sym_size
));
4256 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
4258 /* Make sure that this type of cross reference can be handled. */
4259 if ((sh
.sc
!= scInfo
4260 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
&& sh
.st
!= stIndirect
4261 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
4262 && sh
.st
!= stEnum
))
4263 && (sh
.st
!= stBlock
|| !SC_IS_COMMON (sh
.sc
)))
4265 /* File indirect entry is corrupt. */
4266 *pname
= "<illegal>";
4267 bad_rfd_entry_complaint (sym_name
, xref_fd
, rn
->index
);
4271 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
4273 pend
= is_pending_symbol (fh
, esh
);
4278 /* We have not yet seen this type. */
4280 if ((sh
.iss
== 0 && sh
.st
== stTypedef
) || sh
.st
== stIndirect
)
4284 /* alpha cc puts out a stTypedef with a sh.iss of zero for
4286 a) forward declarations of structs/unions/enums which are not
4287 defined in this compilation unit.
4288 For these the type will be void. This is a bad design decision
4289 as cross referencing across compilation units is impossible
4290 due to the missing name.
4291 b) forward declarations of structs/unions/enums/typedefs which
4292 are defined later in this file or in another file in the same
4293 compilation unit. Irix5 cc uses a stIndirect symbol for this.
4294 Simply cross reference those again to get the true type.
4295 The forward references are not entered in the pending list and
4296 in the symbol table. */
4298 (*debug_swap
->swap_tir_in
) (bigend
,
4299 &(debug_info
->external_aux
4300 + fh
->iauxBase
+ sh
.index
)->a_ti
,
4302 if (tir
.tq0
!= tqNil
)
4303 complaint (&symfile_complaints
,
4304 "illegal tq0 in forward typedef for %s", sym_name
);
4308 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4310 *pname
= "<undefined>";
4317 (debug_info
->external_aux
4318 + fh
->iauxBase
+ sh
.index
+ 1),
4319 tpp
, type_code
, pname
,
4320 fh
->fBigendian
, sym_name
);
4324 /* Follow a forward typedef. This might recursively
4325 call cross_ref till we get a non typedef'ed type.
4326 FIXME: This is not correct behaviour, but gdb currently
4327 cannot handle typedefs without type copying. Type
4328 copying is impossible as we might have mutual forward
4329 references between two files and the copied type would not
4330 get filled in when we later parse its definition. */
4331 *tpp
= parse_type (xref_fd
,
4332 debug_info
->external_aux
+ fh
->iauxBase
,
4336 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4337 add_pending (fh
, esh
, *tpp
);
4341 complaint (&symfile_complaints
,
4342 "illegal bt %d in forward typedef for %s", tir
.bt
,
4344 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
4350 else if (sh
.st
== stTypedef
)
4352 /* Parse the type for a normal typedef. This might recursively call
4353 cross_ref till we get a non typedef'ed type.
4354 FIXME: This is not correct behaviour, but gdb currently
4355 cannot handle typedefs without type copying. But type copying is
4356 impossible as we might have mutual forward references between
4357 two files and the copied type would not get filled in when
4358 we later parse its definition. */
4359 *tpp
= parse_type (xref_fd
,
4360 debug_info
->external_aux
+ fh
->iauxBase
,
4364 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
4368 /* Cross reference to a struct/union/enum which is defined
4369 in another file in the same compilation unit but that file
4370 has not been parsed yet.
4371 Initialize the type only, it will be filled in when
4372 it's definition is parsed. */
4373 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
4375 add_pending (fh
, esh
, *tpp
);
4378 /* We used one auxent normally, two if we got a "next one" rf. */
4383 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4384 keeping the symtab sorted */
4386 static struct symbol
*
4387 mylookup_symbol (char *name
, struct block
*block
,
4388 domain_enum domain
, enum address_class
class)
4390 struct dict_iterator iter
;
4395 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
4397 if (DEPRECATED_SYMBOL_NAME (sym
)[0] == inc
4398 && SYMBOL_DOMAIN (sym
) == domain
4399 && SYMBOL_CLASS (sym
) == class
4400 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), name
) == 0)
4404 block
= BLOCK_SUPERBLOCK (block
);
4406 return mylookup_symbol (name
, block
, domain
, class);
4411 /* Add a new symbol S to a block B. */
4414 add_symbol (struct symbol
*s
, struct block
*b
)
4416 dict_add_symbol (BLOCK_DICT (b
), s
);
4419 /* Add a new block B to a symtab S */
4422 add_block (struct block
*b
, struct symtab
*s
)
4424 struct blockvector
*bv
= BLOCKVECTOR (s
);
4426 bv
= (struct blockvector
*) xrealloc ((void *) bv
,
4427 (sizeof (struct blockvector
)
4428 + BLOCKVECTOR_NBLOCKS (bv
)
4429 * sizeof (bv
->block
)));
4430 if (bv
!= BLOCKVECTOR (s
))
4431 BLOCKVECTOR (s
) = bv
;
4433 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
4436 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4437 MIPS' linenumber encoding might need more than one byte
4438 to describe it, LAST is used to detect these continuation lines.
4440 Combining lines with the same line number seems like a bad idea.
4441 E.g: There could be a line number entry with the same line number after the
4442 prologue and GDB should not ignore it (this is a better way to find
4443 a prologue than mips_skip_prologue).
4444 But due to the compressed line table format there are line number entries
4445 for the same line which are needed to bridge the gap to the next
4446 line number entry. These entries have a bogus address info with them
4447 and we are unable to tell them from intended duplicate line number
4449 This is another reason why -ggdb debugging format is preferable. */
4452 add_line (struct linetable
*lt
, int lineno
, CORE_ADDR adr
, int last
)
4454 /* DEC c89 sometimes produces zero linenos which confuse gdb.
4455 Change them to something sensible. */
4459 last
= -2; /* make sure we record first line */
4461 if (last
== lineno
) /* skip continuation lines */
4464 lt
->item
[lt
->nitems
].line
= lineno
;
4465 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
4469 /* Sorting and reordering procedures */
4471 /* Blocks with a smaller low bound should come first */
4474 compare_blocks (const void *arg1
, const void *arg2
)
4477 struct block
**b1
= (struct block
**) arg1
;
4478 struct block
**b2
= (struct block
**) arg2
;
4480 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
4482 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
4486 /* Sort the blocks of a symtab S.
4487 Reorder the blocks in the blockvector by code-address,
4488 as required by some MI search routines */
4491 sort_blocks (struct symtab
*s
)
4493 struct blockvector
*bv
= BLOCKVECTOR (s
);
4495 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
4498 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
4499 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
4500 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
4501 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
4505 * This is very unfortunate: normally all functions are compiled in
4506 * the order they are found, but if the file is compiled -O3 things
4507 * are very different. It would be nice to find a reliable test
4508 * to detect -O3 images in advance.
4510 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
4511 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
4512 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
4513 sizeof (struct block
*),
4518 int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
4520 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
4521 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
4522 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
4523 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
4526 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
4527 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
4529 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4530 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4531 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
4532 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
4536 /* Constructor/restructor/destructor procedures */
4538 /* Allocate a new symtab for NAME. Needs an estimate of how many
4539 linenumbers MAXLINES we'll put in it */
4541 static struct symtab
*
4542 new_symtab (char *name
, int maxlines
, struct objfile
*objfile
)
4544 struct symtab
*s
= allocate_symtab (name
, objfile
);
4546 LINETABLE (s
) = new_linetable (maxlines
);
4548 /* All symtabs must have at least two blocks */
4549 BLOCKVECTOR (s
) = new_bvect (2);
4550 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
)
4551 = new_block (NON_FUNCTION_BLOCK
);
4552 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
4553 = new_block (NON_FUNCTION_BLOCK
);
4554 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
4555 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4557 s
->free_code
= free_linetable
;
4558 s
->debugformat
= obsavestring ("ECOFF", 5,
4559 &objfile
->objfile_obstack
);
4563 /* Allocate a new partial_symtab NAME */
4565 static struct partial_symtab
*
4566 new_psymtab (char *name
, struct objfile
*objfile
)
4568 struct partial_symtab
*psymtab
;
4570 psymtab
= allocate_psymtab (name
, objfile
);
4571 psymtab
->section_offsets
= objfile
->section_offsets
;
4573 /* Keep a backpointer to the file's symbols */
4575 psymtab
->read_symtab_private
= ((char *)
4576 obstack_alloc (&objfile
->objfile_obstack
,
4577 sizeof (struct symloc
)));
4578 memset (psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
4579 CUR_BFD (psymtab
) = cur_bfd
;
4580 DEBUG_SWAP (psymtab
) = debug_swap
;
4581 DEBUG_INFO (psymtab
) = debug_info
;
4582 PENDING_LIST (psymtab
) = pending_list
;
4584 /* The way to turn this into a symtab is to call... */
4585 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
4590 /* Allocate a linetable array of the given SIZE. Since the struct
4591 already includes one item, we subtract one when calculating the
4592 proper size to allocate. */
4594 static struct linetable
*
4595 new_linetable (int size
)
4597 struct linetable
*l
;
4599 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
4600 l
= (struct linetable
*) xmalloc (size
);
4605 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
4606 I am not so sure about the 3.4 ones.
4608 Since the struct linetable already includes one item, we subtract one when
4609 calculating the proper size to allocate. */
4611 static struct linetable
*
4612 shrink_linetable (struct linetable
*lt
)
4615 return (struct linetable
*) xrealloc ((void *) lt
,
4616 (sizeof (struct linetable
)
4618 * sizeof (lt
->item
))));
4621 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
4623 static struct blockvector
*
4624 new_bvect (int nblocks
)
4626 struct blockvector
*bv
;
4629 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
4630 bv
= (struct blockvector
*) xzalloc (size
);
4632 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
4637 /* Allocate and zero a new block, and set its BLOCK_DICT. If function
4638 is non-zero, assume the block is associated to a function, and make
4639 sure that the symbols are stored linearly; otherwise, store them
4642 static struct block
*
4643 new_block (enum block_type type
)
4645 /* FIXME: carlton/2003-09-11: This should use allocate_block to
4646 allocate the block. Which, in turn, suggests that the block
4647 should be allocated on an obstack. */
4648 struct block
*retval
= xzalloc (sizeof (struct block
));
4650 if (type
== FUNCTION_BLOCK
)
4651 BLOCK_DICT (retval
) = dict_create_linear_expandable ();
4653 BLOCK_DICT (retval
) = dict_create_hashed_expandable ();
4658 /* Create a new symbol with printname NAME */
4660 static struct symbol
*
4661 new_symbol (char *name
)
4663 struct symbol
*s
= ((struct symbol
*)
4664 obstack_alloc (¤t_objfile
->objfile_obstack
,
4665 sizeof (struct symbol
)));
4667 memset (s
, 0, sizeof (*s
));
4668 SYMBOL_LANGUAGE (s
) = psymtab_language
;
4669 SYMBOL_SET_NAMES (s
, name
, strlen (name
), current_objfile
);
4673 /* Create a new type with printname NAME */
4675 static struct type
*
4676 new_type (char *name
)
4680 t
= alloc_type (current_objfile
);
4681 TYPE_NAME (t
) = name
;
4682 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
4686 /* Read ECOFF debugging information from a BFD section. This is
4687 called from elfread.c. It parses the section into a
4688 ecoff_debug_info struct, and then lets the rest of the file handle
4692 elfmdebug_build_psymtabs (struct objfile
*objfile
,
4693 const struct ecoff_debug_swap
*swap
, asection
*sec
)
4695 bfd
*abfd
= objfile
->obfd
;
4696 struct ecoff_debug_info
*info
;
4697 struct cleanup
*back_to
;
4699 /* FIXME: It's not clear whether we should be getting minimal symbol
4700 information from .mdebug in an ELF file, or whether we will.
4701 Re-initialize the minimal symbol reader in case we do. */
4703 init_minimal_symbol_collection ();
4704 back_to
= make_cleanup_discard_minimal_symbols ();
4706 info
= ((struct ecoff_debug_info
*)
4707 obstack_alloc (&objfile
->objfile_obstack
,
4708 sizeof (struct ecoff_debug_info
)));
4710 if (!(*swap
->read_debug_info
) (abfd
, sec
, info
))
4711 error ("Error reading ECOFF debugging information: %s",
4712 bfd_errmsg (bfd_get_error ()));
4714 mdebug_build_psymtabs (objfile
, swap
, info
);
4716 install_minimal_symbols (objfile
);
4717 do_cleanups (back_to
);
4721 _initialize_mdebugread (void)
4724 init_type (TYPE_CODE_VOID
, 1,
4726 "void", (struct objfile
*) NULL
);
4728 init_type (TYPE_CODE_INT
, 1,
4730 "char", (struct objfile
*) NULL
);
4731 mdebug_type_unsigned_char
=
4732 init_type (TYPE_CODE_INT
, 1,
4734 "unsigned char", (struct objfile
*) NULL
);
4736 init_type (TYPE_CODE_INT
, 2,
4738 "short", (struct objfile
*) NULL
);
4739 mdebug_type_unsigned_short
=
4740 init_type (TYPE_CODE_INT
, 2,
4742 "unsigned short", (struct objfile
*) NULL
);
4743 mdebug_type_int_32
=
4744 init_type (TYPE_CODE_INT
, 4,
4746 "int", (struct objfile
*) NULL
);
4747 mdebug_type_unsigned_int_32
=
4748 init_type (TYPE_CODE_INT
, 4,
4750 "unsigned int", (struct objfile
*) NULL
);
4751 mdebug_type_int_64
=
4752 init_type (TYPE_CODE_INT
, 8,
4754 "int", (struct objfile
*) NULL
);
4755 mdebug_type_unsigned_int_64
=
4756 init_type (TYPE_CODE_INT
, 8,
4758 "unsigned int", (struct objfile
*) NULL
);
4759 mdebug_type_long_32
=
4760 init_type (TYPE_CODE_INT
, 4,
4762 "long", (struct objfile
*) NULL
);
4763 mdebug_type_unsigned_long_32
=
4764 init_type (TYPE_CODE_INT
, 4,
4766 "unsigned long", (struct objfile
*) NULL
);
4767 mdebug_type_long_64
=
4768 init_type (TYPE_CODE_INT
, 8,
4770 "long", (struct objfile
*) NULL
);
4771 mdebug_type_unsigned_long_64
=
4772 init_type (TYPE_CODE_INT
, 8,
4774 "unsigned long", (struct objfile
*) NULL
);
4775 mdebug_type_long_long_64
=
4776 init_type (TYPE_CODE_INT
, 8,
4778 "long long", (struct objfile
*) NULL
);
4779 mdebug_type_unsigned_long_long_64
=
4780 init_type (TYPE_CODE_INT
, 8,
4782 "unsigned long long", (struct objfile
*) NULL
);
4783 mdebug_type_adr_32
=
4784 init_type (TYPE_CODE_PTR
, 4,
4786 "adr_32", (struct objfile
*) NULL
);
4787 TYPE_TARGET_TYPE (mdebug_type_adr_32
) = mdebug_type_void
;
4788 mdebug_type_adr_64
=
4789 init_type (TYPE_CODE_PTR
, 8,
4791 "adr_64", (struct objfile
*) NULL
);
4792 TYPE_TARGET_TYPE (mdebug_type_adr_64
) = mdebug_type_void
;
4794 init_type (TYPE_CODE_FLT
, TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4796 "float", (struct objfile
*) NULL
);
4797 mdebug_type_double
=
4798 init_type (TYPE_CODE_FLT
, TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4800 "double", (struct objfile
*) NULL
);
4801 mdebug_type_complex
=
4802 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
4804 "complex", (struct objfile
*) NULL
);
4805 TYPE_TARGET_TYPE (mdebug_type_complex
) = mdebug_type_float
;
4806 mdebug_type_double_complex
=
4807 init_type (TYPE_CODE_COMPLEX
, 2 * TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4809 "double complex", (struct objfile
*) NULL
);
4810 TYPE_TARGET_TYPE (mdebug_type_double_complex
) = mdebug_type_double
;
4812 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4814 mdebug_type_string
=
4815 init_type (TYPE_CODE_STRING
,
4816 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
4818 (struct objfile
*) NULL
);
4820 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4821 good? Would we be better off with TYPE_CODE_ERROR? Should
4822 TYPE_CODE_ERROR print things in hex if it knows the size? */
4823 mdebug_type_fixed_dec
=
4824 init_type (TYPE_CODE_INT
,
4825 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4827 (struct objfile
*) NULL
);
4829 mdebug_type_float_dec
=
4830 init_type (TYPE_CODE_ERROR
,
4831 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
4832 0, "floating decimal",
4833 (struct objfile
*) NULL
);
4835 nodebug_func_symbol_type
= init_type (TYPE_CODE_FUNC
, 1, 0,
4836 "<function, no debug info>", NULL
);
4837 TYPE_TARGET_TYPE (nodebug_func_symbol_type
) = mdebug_type_int
;
4838 nodebug_var_symbol_type
=
4839 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
4840 "<variable, no debug info>", NULL
);