1 /* Read a symbol table in ECOFF format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
4 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
5 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 /* This module provides the function mdebug_build_psymtabs. It reads
25 ECOFF debugging information into partial symbol tables. The
26 debugging information is read from two structures. A struct
27 ecoff_debug_swap includes the sizes of each ECOFF structure and
28 swapping routines; these are fixed for a particular target. A
29 struct ecoff_debug_info points to the debugging information for a
30 particular object file.
32 ECOFF symbol tables are mostly written in the byte order of the
33 target machine. However, one section of the table (the auxiliary
34 symbol information) is written in the host byte order. There is a
35 bit in the other symbol info which describes which host byte order
36 was used. ECOFF thereby takes the trophy from Intel `b.out' for
37 the most brain-dead adaptation of a file format to byte order.
39 This module can read all four of the known byte-order combinations,
40 on any type of host. */
50 #include "stabsread.h"
51 #include "complaints.h"
53 #if !defined (SEEK_SET)
58 /* These are needed if the tm.h file does not contain the necessary
59 mips specific definitions. */
61 #ifndef MIPS_EFI_SYMBOL_NAME
62 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
64 #include "coff/symconst.h"
65 typedef struct mips_extra_func_info
{
68 } *mips_extra_func_info_t
;
75 #include <sys/types.h>
78 #include <sys/param.h>
83 #include "gdb-stabs.h"
87 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
89 #include "libaout.h" /* Private BFD a.out information. */
90 #include "aout/aout64.h"
91 #include "aout/stab_gnu.h" /* STABS information */
93 #include "expression.h"
94 #include "language.h" /* Needed inside partial-stab.h */
96 /* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
97 #ifndef ECOFF_REG_TO_REGNUM
98 #define ECOFF_REG_TO_REGNUM(num) (num)
101 /* Each partial symbol table entry contains a pointer to private data
102 for the read_symtab() function to use when expanding a partial
103 symbol table entry to a full symbol table entry.
105 For mdebugread this structure contains the index of the FDR that this
106 psymtab represents and a pointer to the BFD that the psymtab was
109 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
110 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
111 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
112 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
113 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
114 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
120 const struct ecoff_debug_swap
*debug_swap
;
121 struct ecoff_debug_info
*debug_info
;
122 struct mdebug_pending
**pending_list
;
123 EXTR
*extern_tab
; /* Pointer to external symbols for this file. */
124 int extern_count
; /* Size of extern_tab. */
125 enum language pst_language
;
128 /* Things we import explicitly from other modules */
130 extern int info_verbose
;
132 /* Various complaints about symbol reading that don't abort the process */
134 static struct complaint bad_file_number_complaint
=
135 {"bad file number %d", 0, 0};
137 static struct complaint index_complaint
=
138 {"bad aux index at symbol %s", 0, 0};
140 static struct complaint aux_index_complaint
=
141 {"bad proc end in aux found from symbol %s", 0, 0};
143 static struct complaint block_index_complaint
=
144 {"bad aux index at block symbol %s", 0, 0};
146 static struct complaint unknown_ext_complaint
=
147 {"unknown external symbol %s", 0, 0};
149 static struct complaint unknown_sym_complaint
=
150 {"unknown local symbol %s", 0, 0};
152 static struct complaint unknown_st_complaint
=
153 {"with type %d", 0, 0};
155 static struct complaint block_overflow_complaint
=
156 {"block containing %s overfilled", 0, 0};
158 static struct complaint basic_type_complaint
=
159 {"cannot map ECOFF basic type 0x%x for %s", 0, 0};
161 static struct complaint unknown_type_qual_complaint
=
162 {"unknown type qualifier 0x%x", 0, 0};
164 static struct complaint array_index_type_complaint
=
165 {"illegal array index type for %s, assuming int", 0, 0};
167 static struct complaint bad_tag_guess_complaint
=
168 {"guessed tag type of %s incorrectly", 0, 0};
170 static struct complaint block_member_complaint
=
171 {"declaration block contains unhandled symbol type %d", 0, 0};
173 static struct complaint stEnd_complaint
=
174 {"stEnd with storage class %d not handled", 0, 0};
176 static struct complaint unknown_mdebug_symtype_complaint
=
177 {"unknown symbol type 0x%x", 0, 0};
179 static struct complaint stab_unknown_complaint
=
180 {"unknown stabs symbol %s", 0, 0};
182 static struct complaint pdr_for_nonsymbol_complaint
=
183 {"PDR for %s, but no symbol", 0, 0};
185 static struct complaint pdr_static_symbol_complaint
=
186 {"can't handle PDR for static proc at 0x%lx", 0, 0};
188 static struct complaint bad_setjmp_pdr_complaint
=
189 {"fixing bad setjmp PDR from libc", 0, 0};
191 static struct complaint bad_fbitfield_complaint
=
192 {"can't handle TIR fBitfield for %s", 0, 0};
194 static struct complaint bad_continued_complaint
=
195 {"illegal TIR continued for %s", 0, 0};
197 static struct complaint bad_rfd_entry_complaint
=
198 {"bad rfd entry for %s: file %d, index %d", 0, 0};
200 static struct complaint unexpected_type_code_complaint
=
201 {"unexpected type code for %s", 0, 0};
203 static struct complaint unable_to_cross_ref_complaint
=
204 {"unable to cross ref btTypedef for %s", 0, 0};
206 static struct complaint illegal_forward_tq0_complaint
=
207 {"illegal tq0 in forward typedef for %s", 0, 0};
209 static struct complaint illegal_forward_bt_complaint
=
210 {"illegal bt %d in forward typedef for %s", 0, 0};
212 static struct complaint bad_linetable_guess_complaint
=
213 {"guessed size of linetable for %s incorrectly", 0, 0};
215 static struct complaint bad_ext_ifd_complaint
=
216 {"bad ifd for external symbol: %d (max %d)", 0, 0};
218 static struct complaint bad_ext_iss_complaint
=
219 {"bad iss for external symbol: %ld (max %ld)", 0, 0};
221 /* Macros and extra defs */
223 /* Puns: hard to find whether -g was used and how */
225 #define MIN_GLEVEL GLEVEL_0
226 #define compare_glevel(a,b) \
227 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
228 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
230 /* Things that really are local to this module */
232 /* Remember what we deduced to be the source language of this psymtab. */
234 static enum language psymtab_language
= language_unknown
;
240 /* How to parse debugging information for CUR_BFD. */
242 static const struct ecoff_debug_swap
*debug_swap
;
244 /* Pointers to debugging information for CUR_BFD. */
246 static struct ecoff_debug_info
*debug_info
;
248 /* Pointer to current file decriptor record, and its index */
253 /* Index of current symbol */
257 /* Note how much "debuggable" this image is. We would like
258 to see at least one FDR with full symbols */
263 /* When examining .o files, report on undefined symbols */
265 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
267 /* Pseudo symbol to use when putting stabs into the symbol table. */
269 static char stabs_symbol
[] = STABS_SYMBOL
;
271 /* Types corresponding to btComplex, btDComplex, etc. These are here
272 rather than in gdbtypes.c or some such, because the meaning of codes
273 like btComplex is specific to the mdebug debug format. FIXME: We should
274 be using our own types thoughout this file, instead of sometimes using
277 static struct type
*mdebug_type_complex
;
278 static struct type
*mdebug_type_double_complex
;
279 static struct type
*mdebug_type_fixed_dec
;
280 static struct type
*mdebug_type_float_dec
;
281 static struct type
*mdebug_type_string
;
283 /* Forward declarations */
286 upgrade_type
PARAMS ((int, struct type
**, int, union aux_ext
*, int, char *));
289 parse_partial_symbols
PARAMS ((struct objfile
*,
290 struct section_offsets
*));
293 *get_rfd
PARAMS ((int, int));
296 cross_ref
PARAMS ((int, union aux_ext
*, struct type
**, enum type_code
,
297 char **, int, char *));
299 static struct symbol
*
300 new_symbol
PARAMS ((char *));
303 new_type
PARAMS ((char *));
305 static struct block
*
306 new_block
PARAMS ((int));
308 static struct symtab
*
309 new_symtab
PARAMS ((char *, int, int, struct objfile
*));
311 static struct linetable
*
312 new_linetable
PARAMS ((int));
314 static struct blockvector
*
315 new_bvect
PARAMS ((int));
318 parse_symbol
PARAMS ((SYMR
*, union aux_ext
*, char *, int));
321 parse_type
PARAMS ((int, union aux_ext
*, unsigned int, int *, int, char *));
323 static struct symbol
*
324 mylookup_symbol
PARAMS ((char *, struct block
*, enum namespace,
325 enum address_class
));
327 static struct block
*
328 shrink_block
PARAMS ((struct block
*, struct symtab
*));
331 xzalloc
PARAMS ((unsigned int));
334 sort_blocks
PARAMS ((struct symtab
*));
337 compare_blocks
PARAMS ((const void *, const void *));
339 static struct partial_symtab
*
340 new_psymtab
PARAMS ((char *, struct objfile
*, struct section_offsets
*));
343 psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*, char *));
346 add_block
PARAMS ((struct block
*, struct symtab
*));
349 add_symbol
PARAMS ((struct symbol
*, struct block
*));
352 add_line
PARAMS ((struct linetable
*, int, CORE_ADDR
, int));
354 static struct linetable
*
355 shrink_linetable
PARAMS ((struct linetable
*));
358 handle_psymbol_enumerators
PARAMS ((struct objfile
*, FDR
*, int));
361 mdebug_next_symbol_text
PARAMS ((void));
363 /* Address bounds for the signal trampoline in inferior, if any */
365 CORE_ADDR sigtramp_address
, sigtramp_end
;
367 /* Allocate zeroed memory */
373 PTR p
= xmalloc (size
);
379 /* Exported procedure: Builds a symtab from the PST partial one.
380 Restores the environment in effect when PST was created, delegates
381 most of the work to an ancillary procedure, and sorts
382 and reorders the symtab list at the end */
385 mdebug_psymtab_to_symtab (pst
)
386 struct partial_symtab
*pst
;
394 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
395 gdb_flush (gdb_stdout
);
398 next_symbol_text_func
= mdebug_next_symbol_text
;
400 psymtab_to_symtab_1 (pst
, pst
->filename
);
402 /* Match with global symbols. This only needs to be done once,
403 after all of the symtabs and dependencies have been read in. */
404 scan_file_globals (pst
->objfile
);
407 printf_filtered ("done.\n");
410 /* File-level interface functions */
412 /* Find a file descriptor given its index RF relative to a file CF */
422 fdrs
= debug_info
->fdr
;
424 /* Object files do not have the RFD table, all refs are absolute */
427 (*debug_swap
->swap_rfd_in
) (cur_bfd
,
428 ((char *) debug_info
->external_rfd
430 * debug_swap
->external_rfd_size
)),
435 /* Return a safer print NAME for a file descriptor */
442 return "<stripped file>";
445 return debug_info
->ss
+ f
->issBase
+ f
->rss
;
449 /* Read in and parse the symtab of the file OBJFILE. Symbols from
450 different sections are relocated via the SECTION_OFFSETS. */
453 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
)
454 struct objfile
*objfile
;
455 const struct ecoff_debug_swap
*swap
;
456 struct ecoff_debug_info
*info
;
457 struct section_offsets
*section_offsets
;
459 cur_bfd
= objfile
->obfd
;
463 /* Make sure all the FDR information is swapped in. */
464 if (info
->fdr
== (FDR
*) NULL
)
470 info
->fdr
= (FDR
*) obstack_alloc (&objfile
->psymbol_obstack
,
471 (info
->symbolic_header
.ifdMax
473 fdr_src
= info
->external_fdr
;
475 + info
->symbolic_header
.ifdMax
* swap
->external_fdr_size
);
477 for (; fdr_src
< fdr_end
; fdr_src
+= swap
->external_fdr_size
, fdr_ptr
++)
478 (*swap
->swap_fdr_in
) (objfile
->obfd
, fdr_src
, fdr_ptr
);
481 parse_partial_symbols (objfile
, section_offsets
);
484 /* Check to make sure file was compiled with -g. If not, warn the
485 user of this limitation. */
486 if (compare_glevel (max_glevel
, GLEVEL_2
) < 0)
488 if (max_gdbinfo
== 0)
489 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
491 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
492 gdb_flush (gdb_stdout
);
497 /* Local utilities */
499 /* Map of FDR indexes to partial symtabs */
503 struct partial_symtab
*pst
; /* the psymtab proper */
504 long n_globals
; /* exported globals (external symbols) */
505 long globals_offset
; /* cumulative */
509 /* Utility stack, used to nest procedures and blocks properly.
510 It is a doubly linked list, to avoid too many alloc/free.
511 Since we might need it quite a few times it is NOT deallocated
514 static struct parse_stack
516 struct parse_stack
*next
, *prev
;
517 struct symtab
*cur_st
; /* Current symtab. */
518 struct block
*cur_block
; /* Block in it. */
520 /* What are we parsing. stFile, or stBlock are for files and
521 blocks. stProc or stStaticProc means we have seen the start of a
522 procedure, but not the start of the block within in. When we see
523 the start of that block, we change it to stNil, without pushing a
524 new block, i.e. stNil means both a procedure and a block. */
528 int maxsyms
; /* Max symbols in this block. */
529 struct type
*cur_type
; /* Type we parse fields for. */
530 int cur_field
; /* Field number in cur_type. */
531 CORE_ADDR procadr
; /* Start addres of this procedure */
532 int numargs
; /* Its argument count */
535 *top_stack
; /* Top stack ptr */
538 /* Enter a new lexical context */
543 struct parse_stack
*new;
545 /* Reuse frames if possible */
546 if (top_stack
&& top_stack
->prev
)
547 new = top_stack
->prev
;
549 new = (struct parse_stack
*) xzalloc (sizeof (struct parse_stack
));
550 /* Initialize new frame with previous content */
553 register struct parse_stack
*prev
= new->prev
;
556 top_stack
->prev
= new;
558 new->next
= top_stack
;
563 /* Exit a lexical context */
571 top_stack
= top_stack
->next
;
575 /* Cross-references might be to things we haven't looked at
576 yet, e.g. type references. To avoid too many type
577 duplications we keep a quick fixup table, an array
578 of lists of references indexed by file descriptor */
580 struct mdebug_pending
582 struct mdebug_pending
*next
; /* link */
583 char *s
; /* the unswapped symbol */
584 struct type
*t
; /* its partial type descriptor */
588 /* The pending information is kept for an entire object file, and used
589 to be in the sym_private field. I took it out when I split
590 mdebugread from mipsread, because this might not be the only type
591 of symbols read from an object file. Instead, we allocate the
592 pending information table when we create the partial symbols, and
593 we store a pointer to the single table in each psymtab. */
595 static struct mdebug_pending
**pending_list
;
597 /* Check whether we already saw symbol SH in file FH */
599 static struct mdebug_pending
*
600 is_pending_symbol (fh
, sh
)
604 int f_idx
= fh
- debug_info
->fdr
;
605 register struct mdebug_pending
*p
;
607 /* Linear search is ok, list is typically no more than 10 deep */
608 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
614 /* Add a new symbol SH of type T */
617 add_pending (fh
, sh
, t
)
622 int f_idx
= fh
- debug_info
->fdr
;
623 struct mdebug_pending
*p
= is_pending_symbol (fh
, sh
);
625 /* Make sure we do not make duplicates */
628 p
= ((struct mdebug_pending
*)
629 obstack_alloc (¤t_objfile
->psymbol_obstack
,
630 sizeof (struct mdebug_pending
)));
633 p
->next
= pending_list
[f_idx
];
634 pending_list
[f_idx
] = p
;
639 /* Parsing Routines proper. */
641 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
642 For blocks, procedures and types we open a new lexical context.
643 This is basically just a big switch on the symbol's type. Argument
644 AX is the base pointer of aux symbols for this file (fh->iauxBase).
645 EXT_SH points to the unswapped symbol, which is needed for struct,
646 union, etc., types; it is NULL for an EXTR. BIGEND says whether
647 aux symbols are big-endian or little-endian. Return count of
648 SYMR's handled (normally one). */
651 parse_symbol (sh
, ax
, ext_sh
, bigend
)
657 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
658 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*)) =
659 debug_swap
->swap_sym_in
;
663 struct mdebug_pending
*pend
;
667 enum address_class
class;
669 long svalue
= sh
->value
;
672 if (ext_sh
== (char *) NULL
)
673 name
= debug_info
->ssext
+ sh
->iss
;
675 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
->iss
;
682 case stGlobal
: /* external symbol, goes into global block */
684 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
686 s
= new_symbol (name
);
687 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
690 case stStatic
: /* static data, goes into current block. */
692 b
= top_stack
->cur_block
;
693 s
= new_symbol (name
);
694 if (sh
->sc
== scCommon
)
696 /* It is a FORTRAN common block. At least for SGI Fortran the
697 address is not in the symbol; we need to fix it later in
698 scan_file_globals. */
699 int bucket
= hashname (SYMBOL_NAME (s
));
700 SYMBOL_VALUE_CHAIN (s
) = global_sym_chain
[bucket
];
701 global_sym_chain
[bucket
] = s
;
704 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
707 case stLocal
: /* local variable, goes into current block */
708 if (sh
->sc
== scRegister
)
710 class = LOC_REGISTER
;
711 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
715 b
= top_stack
->cur_block
;
716 s
= new_symbol (name
);
717 SYMBOL_VALUE (s
) = svalue
;
719 data
: /* Common code for symbols describing data */
720 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
721 SYMBOL_CLASS (s
) = class;
724 /* Type could be missing in a number of cases */
725 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
726 SYMBOL_TYPE (s
) = builtin_type_int
; /* undefined? */
728 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
729 /* Value of a data symbol is its memory address */
732 case stParam
: /* arg to procedure, goes into current block */
734 top_stack
->numargs
++;
736 /* Special GNU C++ name. */
737 if (name
[0] == CPLUS_MARKER
&& name
[1] == 't' && name
[2] == 0)
738 name
= "this"; /* FIXME, not alloc'd in obstack */
739 s
= new_symbol (name
);
741 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
745 /* Pass by value in register. */
746 SYMBOL_CLASS(s
) = LOC_REGPARM
;
747 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
750 /* Pass by reference on stack. */
751 SYMBOL_CLASS(s
) = LOC_REF_ARG
;
754 /* Pass by reference in register. */
755 SYMBOL_CLASS(s
) = LOC_REGPARM_ADDR
;
756 svalue
= ECOFF_REG_TO_REGNUM (svalue
);
759 /* Pass by value on stack. */
760 SYMBOL_CLASS(s
) = LOC_ARG
;
763 SYMBOL_VALUE (s
) = svalue
;
764 SYMBOL_TYPE (s
) = parse_type (cur_fd
, ax
, sh
->index
, 0, bigend
, name
);
765 add_symbol (s
, top_stack
->cur_block
);
767 /* FIXME: This has not been tested. See dbxread.c */
768 /* Add the type of this parameter to the function/procedure
769 type of this block. */
770 add_param_to_type (&top_stack
->cur_block
->function
->type
, s
);
774 case stLabel
: /* label, goes into current block */
775 s
= new_symbol (name
);
776 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
; /* so that it can be used */
777 SYMBOL_CLASS (s
) = LOC_LABEL
; /* but not misused */
778 SYMBOL_VALUE_ADDRESS (s
) = (CORE_ADDR
) sh
->value
;
779 SYMBOL_TYPE (s
) = builtin_type_int
;
780 add_symbol (s
, top_stack
->cur_block
);
783 case stProc
: /* Procedure, usually goes into global block */
784 case stStaticProc
: /* Static procedure, goes into current block */
785 s
= new_symbol (name
);
786 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
787 SYMBOL_CLASS (s
) = LOC_BLOCK
;
788 /* Type of the return value */
789 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
790 t
= builtin_type_int
;
792 t
= parse_type (cur_fd
, ax
, sh
->index
+ 1, 0, bigend
, name
);
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 */
812 /* FIXME: This has not been tested yet! See dbxread.c */
813 /* Generate a template for the type of this function. The
814 types of the arguments will be added as we read the symbol
816 memcpy (lookup_function_type (t
), SYMBOL_TYPE (s
), sizeof (struct type
));
818 SYMBOL_TYPE (s
) = lookup_function_type (t
);
821 /* Create and enter a new lexical context */
822 b
= new_block (top_stack
->maxsyms
);
823 SYMBOL_BLOCK_VALUE (s
) = b
;
824 BLOCK_FUNCTION (b
) = s
;
825 BLOCK_START (b
) = BLOCK_END (b
) = sh
->value
;
826 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
827 add_block (b
, top_stack
->cur_st
);
829 /* Not if we only have partial info */
830 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
834 top_stack
->cur_block
= b
;
835 top_stack
->blocktype
= sh
->st
;
836 top_stack
->cur_type
= SYMBOL_TYPE (s
);
837 top_stack
->cur_field
= -1;
838 top_stack
->procadr
= sh
->value
;
839 top_stack
->numargs
= 0;
842 /* Beginning of code for structure, union, and enum definitions.
843 They all share a common set of local variables, defined here. */
845 enum type_code type_code
;
851 case stStruct
: /* Start a block defining a struct type */
852 type_code
= TYPE_CODE_STRUCT
;
853 goto structured_common
;
855 case stUnion
: /* Start a block defining a union type */
856 type_code
= TYPE_CODE_UNION
;
857 goto structured_common
;
859 case stEnum
: /* Start a block defining an enum type */
860 type_code
= TYPE_CODE_ENUM
;
861 goto structured_common
;
863 case stBlock
: /* Either a lexical block, or some type */
864 if (sh
->sc
!= scInfo
&& sh
->sc
!= scCommon
)
865 goto case_stBlock_code
; /* Lexical block */
867 type_code
= TYPE_CODE_UNDEF
; /* We have a type. */
869 /* Common code for handling struct, union, enum, and/or as-yet-
870 unknown-type blocks of info about structured data. `type_code'
871 has been set to the proper TYPE_CODE, if we know it. */
874 top_stack
->blocktype
= stBlock
;
876 /* First count the number of fields and the highest value. */
879 for (ext_tsym
= ext_sh
+ external_sym_size
;
881 ext_tsym
+= external_sym_size
)
885 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
893 if (nfields
== 0 && type_code
== TYPE_CODE_UNDEF
)
894 /* If the type of the member is Nil (or Void),
895 without qualifiers, assume the tag is an
897 if (tsym
.index
== indexNil
)
898 type_code
= TYPE_CODE_ENUM
;
901 ecoff_swap_tir_in (bigend
,
902 &ax
[tsym
.index
].a_ti
,
904 if ((tir
.bt
== btNil
|| tir
.bt
== btVoid
)
906 type_code
= TYPE_CODE_ENUM
;
909 if (tsym
.value
> max_value
)
910 max_value
= tsym
.value
;
919 /* This is a no-op; is it trying to tell us something
920 we should be checking? */
921 if (tsym
.sc
== scVariant
); /*UNIMPLEMENTED*/
925 /* This is something like a struct within a
926 struct. Skip over the fields of the inner
927 struct. The -1 is because the for loop will
928 increment ext_tsym. */
929 ext_tsym
= ((char *) debug_info
->external_sym
930 + ((cur_fdr
->isymBase
+ tsym
.index
- 1)
931 * external_sym_size
));
937 /* mips cc puts out a typedef for struct x if it is not yet
938 defined when it encounters
939 struct y { struct x *xp; };
944 complain (&block_member_complaint
, tsym
.st
);
949 /* In an stBlock, there is no way to distinguish structs,
950 unions, and enums at this point. This is a bug in the
951 original design (that has been fixed with the recent
952 addition of the stStruct, stUnion, and stEnum symbol
953 types.) The way you can tell is if/when you see a variable
954 or field of that type. In that case the variable's type
955 (in the AUX table) says if the type is struct, union, or
956 enum, and points back to the stBlock here. So you can
957 patch the tag kind up later - but only if there actually is
958 a variable or field of that type.
960 So until we know for sure, we will guess at this point.
962 If the first member has index==indexNil or a void type,
963 assume we have an enumeration.
964 Otherwise, if there is more than one member, and all
965 the members have offset 0, assume we have a union.
966 Otherwise, assume we have a struct.
968 The heuristic could guess wrong in the case of of an
969 enumeration with no members or a union with one (or zero)
970 members, or when all except the last field of a struct have
971 width zero. These are uncommon and/or illegal situations,
972 and in any case guessing wrong probably doesn't matter
975 But if we later do find out we were wrong, we fixup the tag
976 kind. Members of an enumeration must be handled
977 differently from struct/union fields, and that is harder to
978 patch up, but luckily we shouldn't need to. (If there are
979 any enumeration members, we can tell for sure it's an enum
982 if (type_code
== TYPE_CODE_UNDEF
)
983 if (nfields
> 1 && max_value
== 0)
984 type_code
= TYPE_CODE_UNION
;
986 type_code
= TYPE_CODE_STRUCT
;
988 /* Create a new type or use the pending type. */
989 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
990 if (pend
== (struct mdebug_pending
*) NULL
)
993 add_pending (cur_fdr
, ext_sh
, t
);
998 /* Do not set the tag name if it is a compiler generated tag name
999 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1000 Alpha cc puts out an sh->iss of zero for those. */
1001 if (sh
->iss
== 0 || name
[0] == '.' || name
[0] == '\0')
1002 TYPE_TAG_NAME (t
) = NULL
;
1004 TYPE_TAG_NAME (t
) = obconcat (¤t_objfile
->symbol_obstack
,
1007 TYPE_CODE (t
) = type_code
;
1008 TYPE_LENGTH (t
) = sh
->value
;
1009 TYPE_NFIELDS (t
) = nfields
;
1010 TYPE_FIELDS (t
) = f
= ((struct field
*)
1012 nfields
* sizeof (struct field
)));
1014 if (type_code
== TYPE_CODE_ENUM
)
1016 /* This is a non-empty enum. */
1018 /* DEC c89 has the number of enumerators in the sh.value field,
1019 not the type length, so we have to compensate for that
1020 incompatibility quirk.
1021 This might do the wrong thing for an enum with one or two
1022 enumerators and gcc -gcoff -fshort-enums, but these cases
1023 are hopefully rare enough. */
1024 if (TYPE_LENGTH (t
) == TYPE_NFIELDS (t
))
1025 TYPE_LENGTH (t
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
1026 for (ext_tsym
= ext_sh
+ external_sym_size
;
1028 ext_tsym
+= external_sym_size
)
1031 struct symbol
*enum_sym
;
1033 (*swap_sym_in
) (cur_bfd
, ext_tsym
, &tsym
);
1035 if (tsym
.st
!= stMember
)
1038 f
->bitpos
= tsym
.value
;
1040 f
->name
= debug_info
->ss
+ cur_fdr
->issBase
+ tsym
.iss
;
1043 enum_sym
= ((struct symbol
*)
1044 obstack_alloc (¤t_objfile
->symbol_obstack
,
1045 sizeof (struct symbol
)));
1046 memset ((PTR
) enum_sym
, 0, sizeof (struct symbol
));
1047 SYMBOL_NAME (enum_sym
) = f
->name
;
1048 SYMBOL_CLASS (enum_sym
) = LOC_CONST
;
1049 SYMBOL_TYPE (enum_sym
) = t
;
1050 SYMBOL_NAMESPACE (enum_sym
) = VAR_NAMESPACE
;
1051 SYMBOL_VALUE (enum_sym
) = tsym
.value
;
1052 add_symbol (enum_sym
, top_stack
->cur_block
);
1054 /* Skip the stMembers that we've handled. */
1059 /* make this the current type */
1060 top_stack
->cur_type
= t
;
1061 top_stack
->cur_field
= 0;
1063 /* Do not create a symbol for alpha cc unnamed structs. */
1067 /* gcc puts out an empty struct for an opaque struct definitions,
1068 do not create a symbol for it either. */
1069 if (TYPE_NFIELDS (t
) == 0)
1071 TYPE_FLAGS (t
) |= TYPE_FLAG_STUB
;
1075 s
= new_symbol (name
);
1076 SYMBOL_NAMESPACE (s
) = STRUCT_NAMESPACE
;
1077 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1078 SYMBOL_VALUE (s
) = 0;
1079 SYMBOL_TYPE (s
) = t
;
1080 add_symbol (s
, top_stack
->cur_block
);
1083 /* End of local variables shared by struct, union, enum, and
1084 block (as yet unknown struct/union/enum) processing. */
1088 /* beginnning of (code) block. Value of symbol
1089 is the displacement from procedure start */
1090 push_parse_stack ();
1092 /* Do not start a new block if this is the outermost block of a
1093 procedure. This allows the LOC_BLOCK symbol to point to the
1094 block with the local variables, so funcname::var works. */
1095 if (top_stack
->blocktype
== stProc
1096 || top_stack
->blocktype
== stStaticProc
)
1098 top_stack
->blocktype
= stNil
;
1102 top_stack
->blocktype
= stBlock
;
1103 b
= new_block (top_stack
->maxsyms
);
1104 BLOCK_START (b
) = sh
->value
+ top_stack
->procadr
;
1105 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1106 top_stack
->cur_block
= b
;
1107 add_block (b
, top_stack
->cur_st
);
1110 case stEnd
: /* end (of anything) */
1111 if (sh
->sc
== scInfo
|| sh
->sc
== scCommon
)
1113 /* Finished with type */
1114 top_stack
->cur_type
= 0;
1116 else if (sh
->sc
== scText
&&
1117 (top_stack
->blocktype
== stProc
||
1118 top_stack
->blocktype
== stStaticProc
))
1120 /* Finished with procedure */
1121 struct blockvector
*bv
= BLOCKVECTOR (top_stack
->cur_st
);
1122 struct mips_extra_func_info
*e
;
1126 BLOCK_END (top_stack
->cur_block
) += sh
->value
; /* size */
1128 /* Make up special symbol to contain procedure specific info */
1129 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
1130 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
1131 SYMBOL_CLASS (s
) = LOC_CONST
;
1132 SYMBOL_TYPE (s
) = builtin_type_void
;
1133 e
= ((struct mips_extra_func_info
*)
1134 obstack_alloc (¤t_objfile
->symbol_obstack
,
1135 sizeof (struct mips_extra_func_info
)));
1136 SYMBOL_VALUE (s
) = (long) e
;
1137 e
->numargs
= top_stack
->numargs
;
1138 add_symbol (s
, top_stack
->cur_block
);
1140 /* Reallocate symbols, saving memory */
1141 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1143 /* f77 emits proc-level with address bounds==[0,0],
1144 So look for such child blocks, and patch them. */
1145 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
1147 struct block
*b_bad
= BLOCKVECTOR_BLOCK (bv
, i
);
1148 if (BLOCK_SUPERBLOCK (b_bad
) == b
1149 && BLOCK_START (b_bad
) == top_stack
->procadr
1150 && BLOCK_END (b_bad
) == top_stack
->procadr
)
1152 BLOCK_START (b_bad
) = BLOCK_START (b
);
1153 BLOCK_END (b_bad
) = BLOCK_END (b
);
1157 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
)
1159 /* End of (code) block. The value of the symbol is the
1160 displacement from the procedure`s start address of the
1161 end of this block. */
1162 BLOCK_END (top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
1163 shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
1165 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stNil
)
1167 /* End of outermost block. Pop parse stack and ignore. The
1168 following stEnd of stProc will take care of the block. */
1171 else if (sh
->sc
== scText
&& top_stack
->blocktype
== stFile
)
1173 /* End of file. Pop parse stack and ignore. Higher
1174 level code deals with this. */
1178 complain (&stEnd_complaint
, sh
->sc
);
1180 pop_parse_stack (); /* restore previous lexical context */
1183 case stMember
: /* member of struct or union */
1184 f
= &TYPE_FIELDS (top_stack
->cur_type
)[top_stack
->cur_field
++];
1186 f
->bitpos
= sh
->value
;
1188 f
->type
= parse_type (cur_fd
, ax
, sh
->index
, &bitsize
, bigend
, name
);
1189 f
->bitsize
= bitsize
;
1192 case stTypedef
: /* type definition */
1193 /* Typedefs for forward declarations and opaque structs from alpha cc
1194 are handled by cross_ref, skip them. */
1198 /* Parse the type or use the pending type. */
1199 pend
= is_pending_symbol (cur_fdr
, ext_sh
);
1200 if (pend
== (struct mdebug_pending
*) NULL
)
1202 t
= parse_type (cur_fd
, ax
, sh
->index
, (int *)NULL
, bigend
, name
);
1203 add_pending (cur_fdr
, ext_sh
, t
);
1208 /* mips cc puts out a typedef with the name of the struct for forward
1209 declarations. These should not go into the symbol table and
1210 TYPE_NAME should not be set for them.
1211 They can't be distinguished from an intentional typedef to
1212 the same name however:
1214 struct x { int ix; int jx; };
1218 struct xx {int ixx; int jxx; };
1219 generates a cross referencing stTypedef for x and xx.
1220 The user visible effect of this is that the type of a pointer
1221 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1222 The problem is fixed with alpha cc. */
1224 s
= new_symbol (name
);
1225 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1226 SYMBOL_CLASS (s
) = LOC_TYPEDEF
;
1227 SYMBOL_BLOCK_VALUE (s
) = top_stack
->cur_block
;
1228 SYMBOL_TYPE (s
) = t
;
1229 add_symbol (s
, top_stack
->cur_block
);
1231 /* Incomplete definitions of structs should not get a name. */
1232 if (TYPE_NAME (SYMBOL_TYPE (s
)) == NULL
1233 && (TYPE_NFIELDS (SYMBOL_TYPE (s
)) != 0
1234 || (TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_STRUCT
1235 && TYPE_CODE (SYMBOL_TYPE (s
)) != TYPE_CODE_UNION
)))
1237 if (TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_PTR
1238 || TYPE_CODE (SYMBOL_TYPE (s
)) == TYPE_CODE_FUNC
)
1240 /* If we are giving a name to a type such as "pointer to
1241 foo" or "function returning foo", we better not set
1242 the TYPE_NAME. If the program contains "typedef char
1243 *caddr_t;", we don't want all variables of type char
1244 * to print as caddr_t. This is not just a
1245 consequence of GDB's type management; CC and GCC (at
1246 least through version 2.4) both output variables of
1247 either type char * or caddr_t with the type
1248 refering to the stTypedef symbol for caddr_t. If a future
1249 compiler cleans this up it GDB is not ready for it
1250 yet, but if it becomes ready we somehow need to
1251 disable this check (without breaking the PCC/GCC2.4
1256 Fortunately, this check seems not to be necessary
1257 for anything except pointers or functions. */
1260 TYPE_NAME (SYMBOL_TYPE (s
)) = SYMBOL_NAME (s
);
1264 case stFile
: /* file name */
1265 push_parse_stack ();
1266 top_stack
->blocktype
= sh
->st
;
1269 /* I`ve never seen these for C */
1271 break; /* register relocation */
1273 break; /* forwarding address */
1275 break; /* constant */
1277 complain (&unknown_mdebug_symtype_complaint
, sh
->st
);
1284 /* Parse the type information provided in the raw AX entries for
1285 the symbol SH. Return the bitfield size in BS, in case.
1286 We must byte-swap the AX entries before we use them; BIGEND says whether
1287 they are big-endian or little-endian (from fh->fBigendian). */
1289 static struct type
*
1290 parse_type (fd
, ax
, aux_index
, bs
, bigend
, sym_name
)
1293 unsigned int aux_index
;
1298 /* Null entries in this map are treated specially */
1299 static struct type
**map_bt
[] =
1301 &builtin_type_void
, /* btNil */
1303 &builtin_type_char
, /* btChar */
1304 &builtin_type_unsigned_char
,/* btUChar */
1305 &builtin_type_short
, /* btShort */
1306 &builtin_type_unsigned_short
, /* btUShort */
1307 &builtin_type_int
, /* btInt */
1308 &builtin_type_unsigned_int
, /* btUInt */
1309 &builtin_type_long
, /* btLong */
1310 &builtin_type_unsigned_long
,/* btULong */
1311 &builtin_type_float
, /* btFloat */
1312 &builtin_type_double
, /* btDouble */
1319 &mdebug_type_complex
, /* btComplex */
1320 &mdebug_type_double_complex
, /* btDComplex */
1322 &mdebug_type_fixed_dec
, /* btFixedDec */
1323 &mdebug_type_float_dec
, /* btFloatDec */
1324 &mdebug_type_string
, /* btString */
1327 &builtin_type_void
, /* btVoid */
1328 0, /* DEC C++: Pointer to member */
1329 0, /* DEC C++: Virtual function table */
1330 0, /* DEC C++: Class (Record) */
1331 &builtin_type_long
, /* btLong64 */
1332 &builtin_type_unsigned_long
, /* btULong64 */
1333 &builtin_type_long_long
, /* btLongLong64 */
1334 &builtin_type_unsigned_long_long
, /* btULongLong64 */
1335 &builtin_type_unsigned_long
, /* btAdr64 */
1336 &builtin_type_long
, /* btInt64 */
1337 &builtin_type_unsigned_long
, /* btUInt64 */
1341 struct type
*tp
= 0;
1342 enum type_code type_code
= TYPE_CODE_UNDEF
;
1344 /* Handle undefined types, they have indexNil. */
1345 if (aux_index
== indexNil
)
1346 return builtin_type_int
;
1348 /* Handle corrupt aux indices. */
1349 if (aux_index
>= (debug_info
->fdr
+ fd
)->caux
)
1351 complain (&index_complaint
, sym_name
);
1352 return builtin_type_int
;
1356 /* Use aux as a type information record, map its basic type. */
1357 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1358 if (t
->bt
>= (sizeof (map_bt
) / sizeof (*map_bt
)))
1360 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1361 return builtin_type_int
;
1365 tp
= *map_bt
[t
->bt
];
1370 /* Cannot use builtin types -- build our own */
1374 tp
= lookup_pointer_type (builtin_type_void
);
1377 type_code
= TYPE_CODE_STRUCT
;
1380 type_code
= TYPE_CODE_UNION
;
1383 type_code
= TYPE_CODE_ENUM
;
1386 type_code
= TYPE_CODE_RANGE
;
1389 type_code
= TYPE_CODE_SET
;
1392 /* alpha cc uses this for typedefs. The true type will be
1393 obtained by crossreferencing below. */
1394 type_code
= TYPE_CODE_ERROR
;
1397 complain (&basic_type_complaint
, t
->bt
, sym_name
);
1398 return builtin_type_int
;
1402 /* Move on to next aux */
1407 /* Inhibit core dumps with some cfront generated objects that
1409 if (bs
== (int *)NULL
)
1411 complain (&bad_fbitfield_complaint
, sym_name
);
1412 return builtin_type_int
;
1414 *bs
= AUX_GET_WIDTH (bigend
, ax
);
1418 /* All these types really point to some (common) MIPS type
1419 definition, and only the type-qualifiers fully identify
1420 them. We'll make the same effort at sharing. */
1421 if (t
->bt
== btStruct
||
1425 /* btSet (I think) implies that the name is a tag name, not a typedef
1426 name. This apparently is a MIPS extension for C sets. */
1431 /* Try to cross reference this type, build new type on failure. */
1432 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1433 if (tp
== (struct type
*) NULL
)
1434 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1436 /* DEC c89 produces cross references to qualified aggregate types,
1437 dereference them. */
1438 while (TYPE_CODE (tp
) == TYPE_CODE_PTR
1439 || TYPE_CODE (tp
) == TYPE_CODE_ARRAY
)
1440 tp
= tp
->target_type
;
1442 /* Make sure that TYPE_CODE(tp) has an expected type code.
1443 Any type may be returned from cross_ref if file indirect entries
1445 if (TYPE_CODE (tp
) != TYPE_CODE_STRUCT
1446 && TYPE_CODE (tp
) != TYPE_CODE_UNION
1447 && TYPE_CODE (tp
) != TYPE_CODE_ENUM
)
1449 complain (&unexpected_type_code_complaint
, sym_name
);
1454 /* Usually, TYPE_CODE(tp) is already type_code. The main
1455 exception is if we guessed wrong re struct/union/enum.
1456 But for struct vs. union a wrong guess is harmless, so
1457 don't complain(). */
1458 if ((TYPE_CODE (tp
) == TYPE_CODE_ENUM
1459 && type_code
!= TYPE_CODE_ENUM
)
1460 || (TYPE_CODE (tp
) != TYPE_CODE_ENUM
1461 && type_code
== TYPE_CODE_ENUM
))
1463 complain (&bad_tag_guess_complaint
, sym_name
);
1466 if (TYPE_CODE (tp
) != type_code
)
1468 TYPE_CODE (tp
) = type_code
;
1471 /* Do not set the tag name if it is a compiler generated tag name
1472 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1473 if (name
[0] == '.' || name
[0] == '\0')
1474 TYPE_TAG_NAME (tp
) = NULL
;
1475 else if (TYPE_TAG_NAME (tp
) == NULL
1476 || !STREQ (TYPE_TAG_NAME (tp
), name
))
1477 TYPE_TAG_NAME (tp
) = obsavestring (name
, strlen (name
),
1478 ¤t_objfile
->type_obstack
);
1482 /* All these types really point to some (common) MIPS type
1483 definition, and only the type-qualifiers fully identify
1484 them. We'll make the same effort at sharing.
1485 FIXME: btIndirect cannot happen here as it is handled by the
1486 switch t->bt above. And we are not doing any guessing on range types. */
1487 if (t
->bt
== btIndirect
||
1492 /* Try to cross reference this type, build new type on failure. */
1493 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1494 if (tp
== (struct type
*) NULL
)
1495 tp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
1497 /* Make sure that TYPE_CODE(tp) has an expected type code.
1498 Any type may be returned from cross_ref if file indirect entries
1500 if (TYPE_CODE (tp
) != TYPE_CODE_RANGE
)
1502 complain (&unexpected_type_code_complaint
, sym_name
);
1506 /* Usually, TYPE_CODE(tp) is already type_code. The main
1507 exception is if we guessed wrong re struct/union/enum. */
1508 if (TYPE_CODE (tp
) != type_code
)
1510 complain (&bad_tag_guess_complaint
, sym_name
);
1511 TYPE_CODE (tp
) = type_code
;
1513 if (TYPE_NAME (tp
) == NULL
|| !STREQ (TYPE_NAME (tp
), name
))
1514 TYPE_NAME (tp
) = obsavestring (name
, strlen (name
),
1515 ¤t_objfile
->type_obstack
);
1518 if (t
->bt
== btTypedef
)
1522 /* Try to cross reference this type, it should succeed. */
1523 ax
+= cross_ref (fd
, ax
, &tp
, type_code
, &name
, bigend
, sym_name
);
1524 if (tp
== (struct type
*) NULL
)
1526 complain (&unable_to_cross_ref_complaint
, sym_name
);
1527 tp
= builtin_type_int
;
1531 /* Deal with range types */
1532 if (t
->bt
== btRange
)
1534 TYPE_NFIELDS (tp
) = 2;
1535 TYPE_FIELDS (tp
) = ((struct field
*)
1536 TYPE_ALLOC (tp
, 2 * sizeof (struct field
)));
1537 TYPE_FIELD_NAME (tp
, 0) = obsavestring ("Low", strlen ("Low"),
1538 ¤t_objfile
->type_obstack
);
1539 TYPE_FIELD_BITPOS (tp
, 0) = AUX_GET_DNLOW (bigend
, ax
);
1541 TYPE_FIELD_NAME (tp
, 1) = obsavestring ("High", strlen ("High"),
1542 ¤t_objfile
->type_obstack
);
1543 TYPE_FIELD_BITPOS (tp
, 1) = AUX_GET_DNHIGH (bigend
, ax
);
1547 /* Parse all the type qualifiers now. If there are more
1548 than 6 the game will continue in the next aux */
1552 #define PARSE_TQ(tq) \
1553 if (t->tq != tqNil) \
1554 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1566 /* mips cc 2.x and gcc never put out continued aux entries. */
1570 ecoff_swap_tir_in (bigend
, &ax
->a_ti
, t
);
1574 /* Complain for illegal continuations due to corrupt aux entries. */
1576 complain (&bad_continued_complaint
, sym_name
);
1581 /* Make up a complex type from a basic one. Type is passed by
1582 reference in TPP and side-effected as necessary. The type
1583 qualifier TQ says how to handle the aux symbols at AX for
1584 the symbol SX we are currently analyzing. BIGEND says whether
1585 aux symbols are big-endian or little-endian.
1586 Returns the number of aux symbols we parsed. */
1589 upgrade_type (fd
, tpp
, tq
, ax
, bigend
, sym_name
)
1600 /* Used in array processing */
1611 t
= lookup_pointer_type (*tpp
);
1616 t
= lookup_function_type (*tpp
);
1623 /* Determine and record the domain type (type of index) */
1624 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, &rndx
);
1630 rf
= AUX_GET_ISYM (bigend
, ax
);
1633 fh
= get_rfd (fd
, rf
);
1635 indx
= parse_type (fd
, debug_info
->external_aux
+ fh
->iauxBase
,
1636 id
, (int *) NULL
, bigend
, sym_name
);
1638 /* The bounds type should be an integer type, but might be anything
1639 else due to corrupt aux entries. */
1640 if (TYPE_CODE (indx
) != TYPE_CODE_INT
)
1642 complain (&array_index_type_complaint
, sym_name
);
1643 indx
= builtin_type_int
;
1646 /* Get the bounds, and create the array type. */
1648 lower
= AUX_GET_DNLOW (bigend
, ax
);
1650 upper
= AUX_GET_DNHIGH (bigend
, ax
);
1652 rf
= AUX_GET_WIDTH (bigend
, ax
); /* bit size of array element */
1654 range
= create_range_type ((struct type
*) NULL
, indx
,
1657 t
= create_array_type ((struct type
*) NULL
, *tpp
, range
);
1659 /* We used to fill in the supplied array element bitsize
1660 here if the TYPE_LENGTH of the target type was zero.
1661 This happens for a `pointer to an array of anonymous structs',
1662 but in this case the array element bitsize is also zero,
1663 so nothing is gained.
1664 And we used to check the TYPE_LENGTH of the target type against
1665 the supplied array element bitsize.
1666 gcc causes a mismatch for `pointer to array of object',
1667 since the sdb directives it uses do not have a way of
1668 specifying the bitsize, but it does no harm (the
1669 TYPE_LENGTH should be correct) and we should be able to
1670 ignore the erroneous bitsize from the auxiliary entry safely.
1671 dbx seems to ignore it too. */
1677 /* Volatile -- currently ignored */
1681 /* Const -- currently ignored */
1685 complain (&unknown_type_qual_complaint
, tq
);
1691 /* Parse a procedure descriptor record PR. Note that the procedure is
1692 parsed _after_ the local symbols, now we just insert the extra
1693 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1694 already been placed in the procedure's main block. Note also that
1695 images that have been partially stripped (ld -x) have been deprived
1696 of local symbols, and we have to cope with them here. FIRST_OFF is
1697 the offset of the first procedure for this FDR; we adjust the
1698 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1699 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1700 in question, or NULL to use top_stack->cur_block. */
1702 static void parse_procedure
PARAMS ((PDR
*, struct symtab
*, unsigned long));
1705 parse_procedure (pr
, search_symtab
, first_off
)
1707 struct symtab
*search_symtab
;
1708 unsigned long first_off
;
1710 struct symbol
*s
, *i
;
1712 struct mips_extra_func_info
*e
;
1715 /* Simple rule to find files linked "-x" */
1716 if (cur_fdr
->rss
== -1)
1720 /* Static procedure at address pr->adr. Sigh. */
1721 /* FIXME-32x64. assuming pr->adr fits in long. */
1722 complain (&pdr_static_symbol_complaint
, (unsigned long) pr
->adr
);
1730 (*debug_swap
->swap_ext_in
) (cur_bfd
,
1731 ((char *) debug_info
->external_ext
1733 * debug_swap
->external_ext_size
)),
1735 sh_name
= debug_info
->ssext
+ she
.asym
.iss
;
1743 (*debug_swap
->swap_sym_in
) (cur_bfd
,
1744 ((char *) debug_info
->external_sym
1745 + ((cur_fdr
->isymBase
+ pr
->isym
)
1746 * debug_swap
->external_sym_size
)),
1748 sh_name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
1751 if (search_symtab
!= NULL
)
1754 /* This loses both in the case mentioned (want a static, find a global),
1755 but also if we are looking up a non-mangled name which happens to
1756 match the name of a mangled function. */
1757 /* We have to save the cur_fdr across the call to lookup_symbol.
1758 If the pdr is for a static function and if a global function with
1759 the same name exists, lookup_symbol will eventually read in the symtab
1760 for the global function and clobber cur_fdr. */
1761 FDR
*save_cur_fdr
= cur_fdr
;
1762 s
= lookup_symbol (sh_name
, NULL
, VAR_NAMESPACE
, 0, NULL
);
1763 cur_fdr
= save_cur_fdr
;
1767 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab
), STATIC_BLOCK
),
1773 s
= mylookup_symbol (sh_name
, top_stack
->cur_block
,
1774 VAR_NAMESPACE
, LOC_BLOCK
);
1778 b
= SYMBOL_BLOCK_VALUE (s
);
1782 complain (&pdr_for_nonsymbol_complaint
, sh_name
);
1786 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1787 s
= new_symbol (sh_name
);
1788 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
1789 SYMBOL_CLASS (s
) = LOC_BLOCK
;
1790 /* Donno its type, hope int is ok */
1791 SYMBOL_TYPE (s
) = lookup_function_type (builtin_type_int
);
1792 add_symbol (s
, top_stack
->cur_block
);
1793 /* Wont have symbols for this one */
1795 SYMBOL_BLOCK_VALUE (s
) = b
;
1796 BLOCK_FUNCTION (b
) = s
;
1797 BLOCK_START (b
) = pr
->adr
;
1798 /* BOUND used to be the end of procedure's text, but the
1799 argument is no longer passed in. */
1800 BLOCK_END (b
) = bound
;
1801 BLOCK_SUPERBLOCK (b
) = top_stack
->cur_block
;
1802 add_block (b
, top_stack
->cur_st
);
1806 i
= mylookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, LOC_CONST
);
1810 e
= (struct mips_extra_func_info
*) SYMBOL_VALUE (i
);
1812 e
->pdr
.isym
= (long) s
;
1813 e
->pdr
.adr
+= cur_fdr
->adr
- first_off
;
1815 /* Correct incorrect setjmp procedure descriptor from the library
1816 to make backtrace through setjmp work. */
1817 if (e
->pdr
.pcreg
== 0 && STREQ (sh_name
, "setjmp"))
1819 complain (&bad_setjmp_pdr_complaint
, 0);
1820 e
->pdr
.pcreg
= RA_REGNUM
;
1821 e
->pdr
.regmask
= 0x80000000;
1822 e
->pdr
.regoffset
= -4;
1827 /* Parse the external symbol ES. Just call parse_symbol() after
1828 making sure we know where the aux are for it. For procedures,
1829 parsing of the PDRs has already provided all the needed
1830 information, we only parse them if SKIP_PROCEDURES is false,
1831 and only if this causes no symbol duplication.
1832 BIGEND says whether aux entries are big-endian or little-endian.
1834 This routine clobbers top_stack->cur_block and ->cur_st. */
1837 parse_external (es
, skip_procedures
, bigend
)
1839 int skip_procedures
;
1844 if (es
->ifd
!= ifdNil
)
1847 cur_fdr
= debug_info
->fdr
+ cur_fd
;
1848 ax
= debug_info
->external_aux
+ cur_fdr
->iauxBase
;
1852 cur_fdr
= debug_info
->fdr
;
1856 /* Reading .o files */
1857 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
)
1860 switch (es
->asym
.st
)
1863 /* These are generated for static symbols in .o files,
1884 /* FIXME: Turn this into a complaint? */
1886 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
1887 what
, debug_info
->ssext
+ es
->asym
.iss
,
1888 fdr_name (cur_fdr
));
1892 switch (es
->asym
.st
)
1895 /* If we have full symbols we do not need more */
1896 if (skip_procedures
)
1898 if (mylookup_symbol (debug_info
->ssext
+ es
->asym
.iss
,
1899 top_stack
->cur_block
,
1900 VAR_NAMESPACE
, LOC_BLOCK
))
1905 /* Note that the case of a symbol with indexNil must be handled
1906 anyways by parse_symbol(). */
1907 parse_symbol (&es
->asym
, ax
, (char *) NULL
, bigend
);
1914 /* Parse the line number info for file descriptor FH into
1915 GDB's linetable LT. MIPS' encoding requires a little bit
1916 of magic to get things out. Note also that MIPS' line
1917 numbers can go back and forth, apparently we can live
1918 with that and do not need to reorder our linetables */
1921 parse_lines (fh
, pr
, lt
, maxlines
)
1924 struct linetable
*lt
;
1927 unsigned char *base
;
1929 int delta
, count
, lineno
= 0;
1930 unsigned long first_off
= pr
->adr
;
1932 if (fh
->cbLine
== 0)
1935 base
= debug_info
->line
+ fh
->cbLineOffset
;
1937 /* Scan by procedure descriptors */
1939 for (j
= 0; j
< fh
->cpd
; j
++, pr
++)
1943 unsigned char *halt
;
1945 /* No code for this one */
1946 if (pr
->iline
== ilineNil
||
1947 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1950 /* Determine start and end address of compressed line bytes for
1952 base
= debug_info
->line
+ fh
->cbLineOffset
;
1953 if (j
!= (fh
->cpd
- 1))
1954 halt
= base
+ pr
[1].cbLineOffset
;
1956 halt
= base
+ fh
->cbLine
;
1957 base
+= pr
->cbLineOffset
;
1959 adr
= fh
->adr
+ pr
->adr
- first_off
;
1960 l
= adr
>> 2; /* in words */
1961 for (lineno
= pr
->lnLow
; base
< halt
; )
1963 count
= *base
& 0x0f;
1964 delta
= *base
++ >> 4;
1969 delta
= (base
[0] << 8) | base
[1];
1970 if (delta
>= 0x8000)
1974 lineno
+= delta
; /* first delta is 0 */
1976 /* Complain if the line table overflows. Could happen
1977 with corrupt binaries. */
1978 if (lt
->nitems
>= maxlines
)
1980 complain (&bad_linetable_guess_complaint
, fdr_name (fh
));
1983 k
= add_line (lt
, lineno
, l
, k
);
1989 /* Master parsing procedure for first-pass reading of file symbols
1990 into a partial_symtab. */
1993 parse_partial_symbols (objfile
, section_offsets
)
1994 struct objfile
*objfile
;
1995 struct section_offsets
*section_offsets
;
1997 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
1998 const bfd_size_type external_rfd_size
= debug_swap
->external_rfd_size
;
1999 const bfd_size_type external_ext_size
= debug_swap
->external_ext_size
;
2000 void (* const swap_ext_in
) PARAMS ((bfd
*, PTR
, EXTR
*))
2001 = debug_swap
->swap_ext_in
;
2002 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2003 = debug_swap
->swap_sym_in
;
2004 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
2005 = debug_swap
->swap_rfd_in
;
2007 HDRR
*hdr
= &debug_info
->symbolic_header
;
2008 /* Running pointers */
2013 register EXTR
*ext_in
;
2016 struct partial_symtab
*pst
;
2018 int past_first_source_file
= 0;
2020 /* List of current psymtab's include files */
2021 char **psymtab_include_list
;
2022 int includes_allocated
;
2025 struct pst_map
*fdr_to_pst
;
2026 /* Index within current psymtab dependency list */
2027 struct partial_symtab
**dependency_list
;
2028 int dependencies_used
, dependencies_allocated
;
2029 struct cleanup
*old_chain
;
2031 enum language prev_language
;
2033 extern_tab
= (EXTR
*) obstack_alloc (&objfile
->psymbol_obstack
,
2034 sizeof (EXTR
) * hdr
->iextMax
);
2036 includes_allocated
= 30;
2038 psymtab_include_list
= (char **) alloca (includes_allocated
*
2040 next_symbol_text_func
= mdebug_next_symbol_text
;
2042 dependencies_allocated
= 30;
2043 dependencies_used
= 0;
2045 (struct partial_symtab
**) alloca (dependencies_allocated
*
2046 sizeof (struct partial_symtab
*));
2048 last_source_file
= NULL
;
2053 * Only parse the Local and External symbols, and the Relative FDR.
2054 * Fixup enough of the loader symtab to be able to use it.
2055 * Allocate space only for the file's portions we need to
2060 max_glevel
= MIN_GLEVEL
;
2062 /* Allocate the map FDR -> PST.
2063 Minor hack: -O3 images might claim some global data belongs
2064 to FDR -1. We`ll go along with that */
2065 fdr_to_pst
= (struct pst_map
*) xzalloc ((hdr
->ifdMax
+ 1) * sizeof *fdr_to_pst
);
2066 old_chain
= make_cleanup (free
, fdr_to_pst
);
2069 struct partial_symtab
*pst
= new_psymtab ("", objfile
, section_offsets
);
2070 fdr_to_pst
[-1].pst
= pst
;
2074 /* Allocate the global pending list. */
2076 ((struct mdebug_pending
**)
2077 obstack_alloc (&objfile
->psymbol_obstack
,
2078 hdr
->ifdMax
* sizeof (struct mdebug_pending
*)));
2079 memset ((PTR
) pending_list
, 0,
2080 hdr
->ifdMax
* sizeof (struct mdebug_pending
*));
2082 /* Pass 0 over external syms: swap them in. */
2083 ext_block
= (EXTR
*) xmalloc (hdr
->iextMax
* sizeof (EXTR
));
2084 make_cleanup (free
, ext_block
);
2086 ext_out
= (char *) debug_info
->external_ext
;
2087 ext_out_end
= ext_out
+ hdr
->iextMax
* external_ext_size
;
2089 for (; ext_out
< ext_out_end
; ext_out
+= external_ext_size
, ext_in
++)
2090 (*swap_ext_in
) (cur_bfd
, ext_out
, ext_in
);
2092 /* Pass 1 over external syms: Presize and partition the list */
2094 ext_in_end
= ext_in
+ hdr
->iextMax
;
2095 for (; ext_in
< ext_in_end
; ext_in
++)
2097 /* See calls to complain below. */
2098 if (ext_in
->ifd
>= -1
2099 && ext_in
->ifd
< hdr
->ifdMax
2100 && ext_in
->asym
.iss
>= 0
2101 && ext_in
->asym
.iss
< hdr
->issExtMax
)
2102 fdr_to_pst
[ext_in
->ifd
].n_globals
++;
2105 /* Pass 1.5 over files: partition out global symbol space */
2107 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++)
2109 fdr_to_pst
[f_idx
].globals_offset
= s_idx
;
2110 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
2111 fdr_to_pst
[f_idx
].n_globals
= 0;
2114 /* Pass 2 over external syms: fill in external symbols */
2116 ext_in_end
= ext_in
+ hdr
->iextMax
;
2117 for (; ext_in
< ext_in_end
; ext_in
++)
2119 enum minimal_symbol_type ms_type
= mst_text
;
2121 /* The Irix 5 native tools seem to sometimes generate bogus
2122 external symbols. */
2123 if (ext_in
->ifd
< -1 || ext_in
->ifd
>= hdr
->ifdMax
)
2125 complain (&bad_ext_ifd_complaint
, ext_in
->ifd
, hdr
->ifdMax
);
2128 if (ext_in
->asym
.iss
< 0 || ext_in
->asym
.iss
>= hdr
->issExtMax
)
2130 complain (&bad_ext_iss_complaint
, ext_in
->asym
.iss
,
2135 extern_tab
[fdr_to_pst
[ext_in
->ifd
].globals_offset
2136 + fdr_to_pst
[ext_in
->ifd
].n_globals
++] = *ext_in
;
2138 if (ext_in
->asym
.sc
== scUndefined
|| ext_in
->asym
.sc
== scNil
)
2141 name
= debug_info
->ssext
+ ext_in
->asym
.iss
;
2142 switch (ext_in
->asym
.st
)
2147 ms_type
= mst_file_text
;
2150 if (ext_in
->asym
.sc
== scCommon
)
2152 /* The value of a common symbol is its size, not its address.
2156 else if (ext_in
->asym
.sc
== scData
2157 || ext_in
->asym
.sc
== scSData
2158 || ext_in
->asym
.sc
== scRData
2159 || ext_in
->asym
.sc
== scPData
2160 || ext_in
->asym
.sc
== scXData
)
2166 if (ext_in
->asym
.sc
== scAbs
)
2168 else if (ext_in
->asym
.sc
== scText
2169 || ext_in
->asym
.sc
== scInit
2170 || ext_in
->asym
.sc
== scFini
)
2171 ms_type
= mst_file_text
;
2172 else if (ext_in
->asym
.sc
== scData
2173 || ext_in
->asym
.sc
== scSData
2174 || ext_in
->asym
.sc
== scRData
2175 || ext_in
->asym
.sc
== scPData
2176 || ext_in
->asym
.sc
== scXData
)
2177 ms_type
= mst_file_data
;
2179 ms_type
= mst_file_bss
;
2182 /* The alpha has the section start addresses in stLocal symbols
2183 whose name starts with a `.'. Skip those but complain for all
2184 other stLocal symbols. */
2189 ms_type
= mst_unknown
;
2190 complain (&unknown_ext_complaint
, name
);
2192 prim_record_minimal_symbol (name
, ext_in
->asym
.value
, ms_type
, objfile
);
2195 /* Pass 3 over files, over local syms: fill in static symbols */
2196 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2198 struct partial_symtab
*save_pst
;
2201 cur_fdr
= fh
= debug_info
->fdr
+ f_idx
;
2205 fdr_to_pst
[f_idx
].pst
= NULL
;
2208 pst
= start_psymtab_common (objfile
, section_offsets
,
2210 fh
->cpd
? fh
->adr
: 0,
2211 objfile
->global_psymbols
.next
,
2212 objfile
->static_psymbols
.next
);
2213 pst
->read_symtab_private
= ((char *)
2214 obstack_alloc (&objfile
->psymbol_obstack
,
2215 sizeof (struct symloc
)));
2216 memset ((PTR
) pst
->read_symtab_private
, 0, sizeof (struct symloc
));
2219 FDR_IDX (pst
) = f_idx
;
2220 CUR_BFD (pst
) = cur_bfd
;
2221 DEBUG_SWAP (pst
) = debug_swap
;
2222 DEBUG_INFO (pst
) = debug_info
;
2223 PENDING_LIST (pst
) = pending_list
;
2225 /* The way to turn this into a symtab is to call... */
2226 pst
->read_symtab
= mdebug_psymtab_to_symtab
;
2228 /* Set up language for the pst.
2229 The language from the FDR is used if it is unambigious (e.g. cfront
2230 with native cc and g++ will set the language to C).
2231 Otherwise we have to deduce the language from the filename.
2232 Native ecoff has every header file in a separate FDR, so
2233 deduce_language_from_filename will return language_unknown for
2234 a header file, which is not what we want.
2235 But the FDRs for the header files are after the FDR for the source
2236 file, so we can assign the language of the source file to the
2237 following header files. Then we save the language in the private
2238 pst data so that we can reuse it when building symtabs. */
2239 prev_language
= psymtab_language
;
2243 case langCplusplusV2
:
2244 psymtab_language
= language_cplus
;
2247 psymtab_language
= deduce_language_from_filename (fdr_name (fh
));
2250 if (psymtab_language
== language_unknown
)
2251 psymtab_language
= prev_language
;
2252 PST_PRIVATE (pst
)->pst_language
= psymtab_language
;
2254 pst
->texthigh
= pst
->textlow
;
2256 /* For stabs-in-ecoff files, the second symbol must be @stab.
2257 This symbol is emitted by mips-tfile to signal that the
2258 current object file uses encapsulated stabs instead of mips
2259 ecoff for local symbols. (It is the second symbol because
2260 the first symbol is the stFile used to signal the start of a
2262 processing_gcc_compilation
= 0;
2265 (*swap_sym_in
) (cur_bfd
,
2266 ((char *) debug_info
->external_sym
2267 + (fh
->isymBase
+ 1) * external_sym_size
),
2269 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
, stabs_symbol
))
2270 processing_gcc_compilation
= 2;
2273 if (processing_gcc_compilation
!= 0)
2275 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2280 (*swap_sym_in
) (cur_bfd
,
2281 (((char *) debug_info
->external_sym
)
2282 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2284 type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2285 if (!ECOFF_IS_STAB (&sh
))
2287 if (sh
.st
== stProc
|| sh
.st
== stStaticProc
)
2289 long procaddr
= sh
.value
;
2293 isym
= AUX_GET_ISYM (fh
->fBigendian
,
2294 (debug_info
->external_aux
2297 (*swap_sym_in
) (cur_bfd
,
2298 ((char *) debug_info
->external_sym
2299 + ((fh
->isymBase
+ isym
- 1)
2300 * external_sym_size
)),
2304 long high
= procaddr
+ sh
.value
;
2305 if (high
> pst
->texthigh
)
2306 pst
->texthigh
= high
;
2311 #define SET_NAMESTRING() \
2312 namestring = debug_info->ss + fh->issBase + sh.iss
2313 #define CUR_SYMBOL_TYPE type_code
2314 #define CUR_SYMBOL_VALUE sh.value
2315 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2317 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2318 #define HANDLE_RBRAC(val) \
2319 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2320 #include "partial-stab.h"
2325 for (cur_sdx
= 0; cur_sdx
< fh
->csym
;)
2328 enum address_class
class;
2330 (*swap_sym_in
) (cur_bfd
,
2331 ((char *) debug_info
->external_sym
2332 + ((fh
->isymBase
+ cur_sdx
)
2333 * external_sym_size
)),
2336 if (ECOFF_IS_STAB (&sh
))
2342 /* Non absolute static symbols go into the minimal table. */
2343 if (sh
.sc
== scUndefined
|| sh
.sc
== scNil
2344 || (sh
.index
== indexNil
2345 && (sh
.st
!= stStatic
|| sh
.sc
== scAbs
)))
2347 /* FIXME, premature? */
2352 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2361 prim_record_minimal_symbol (name
, sh
.value
, mst_file_text
,
2367 /* Usually there is a local and a global stProc symbol
2368 for a function. This means that the function name
2369 has already been entered into the mimimal symbol table
2370 while processing the global symbols in pass 2 above.
2371 One notable exception is the PROGRAM name from
2372 f77 compiled executables, it is only put out as
2373 local stProc symbol, and a global MAIN__ stProc symbol
2374 points to it. It doesn't matter though, as gdb is
2375 still able to find the PROGRAM name via the partial
2376 symbol table, and the MAIN__ symbol via the minimal
2378 if (sh
.st
== stProc
)
2379 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2380 VAR_NAMESPACE
, LOC_BLOCK
,
2381 objfile
->global_psymbols
,
2382 sh
.value
, psymtab_language
, objfile
);
2384 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2385 VAR_NAMESPACE
, LOC_BLOCK
,
2386 objfile
->static_psymbols
,
2387 sh
.value
, psymtab_language
, objfile
);
2389 /* Skip over procedure to next one. */
2390 if (sh
.index
>= hdr
->iauxMax
)
2392 /* Should not happen, but does when cross-compiling
2393 with the MIPS compiler. FIXME -- pull later. */
2394 complain (&index_complaint
, name
);
2395 new_sdx
= cur_sdx
+ 1; /* Don't skip at all */
2398 new_sdx
= AUX_GET_ISYM (fh
->fBigendian
,
2399 (debug_info
->external_aux
2402 procaddr
= sh
.value
;
2404 if (new_sdx
<= cur_sdx
)
2406 /* This should not happen either... FIXME. */
2407 complain (&aux_index_complaint
, name
);
2408 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2412 (*swap_sym_in
) (cur_bfd
,
2413 ((char *) debug_info
->external_sym
2414 + ((fh
->isymBase
+ cur_sdx
- 1)
2415 * external_sym_size
)),
2419 high
= procaddr
+ sh
.value
;
2420 if (high
> pst
->texthigh
)
2421 pst
->texthigh
= high
;
2424 case stStatic
: /* Variable */
2429 || sh
.sc
== scXData
)
2430 prim_record_minimal_symbol (name
, sh
.value
, mst_file_data
,
2433 prim_record_minimal_symbol (name
, sh
.value
, mst_file_bss
,
2438 case stTypedef
:/* Typedef */
2439 /* Skip typedefs for forward declarations and opaque
2440 structs from alpha cc. */
2443 class = LOC_TYPEDEF
;
2446 case stConstant
: /* Constant decl */
2453 case stBlock
: /* { }, str, un, enum*/
2454 /* Do not create a partial symbol for cc unnamed aggregates
2455 and gcc empty aggregates. */
2456 if ((sh
.sc
== scInfo
|| sh
.sc
== scCommon
)
2458 && sh
.index
!= cur_sdx
+ 2)
2460 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2461 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2462 objfile
->static_psymbols
,
2464 psymtab_language
, objfile
);
2466 handle_psymbol_enumerators (objfile
, fh
, sh
.st
);
2468 /* Skip over the block */
2470 if (new_sdx
<= cur_sdx
)
2472 /* This happens with the Ultrix kernel. */
2473 complain (&block_index_complaint
, name
);
2474 new_sdx
= cur_sdx
+ 1; /* Don't skip backward */
2479 case stFile
: /* File headers */
2480 case stLabel
: /* Labels */
2481 case stEnd
: /* Ends of files */
2484 case stLocal
: /* Local variables */
2485 /* Normally these are skipped because we skip over
2486 all blocks we see. However, these can occur
2487 as visible symbols in a .h file that contains code. */
2491 /* Both complaints are valid: one gives symbol name,
2492 the other the offending symbol type. */
2493 complain (&unknown_sym_complaint
, name
);
2494 complain (&unknown_st_complaint
, sh
.st
);
2498 /* Use this gdb symbol */
2499 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2500 VAR_NAMESPACE
, class,
2501 objfile
->static_psymbols
, sh
.value
,
2502 psymtab_language
, objfile
);
2504 cur_sdx
++; /* Go to next file symbol */
2507 /* Now do enter the external symbols. */
2508 ext_ptr
= &extern_tab
[fdr_to_pst
[f_idx
].globals_offset
];
2509 cur_sdx
= fdr_to_pst
[f_idx
].n_globals
;
2510 PST_PRIVATE (save_pst
)->extern_count
= cur_sdx
;
2511 PST_PRIVATE (save_pst
)->extern_tab
= ext_ptr
;
2512 for (; --cur_sdx
>= 0; ext_ptr
++)
2514 enum address_class
class;
2518 if (ext_ptr
->ifd
!= f_idx
)
2520 psh
= &ext_ptr
->asym
;
2522 /* Do not add undefined symbols to the partial symbol table. */
2523 if (psh
->sc
== scUndefined
|| psh
->sc
== scNil
)
2529 /* These are generated for static symbols in .o files,
2534 /* If the index of the global symbol is not indexNil,
2535 it points to the local stProc symbol with the same
2536 name, which has already been entered into the
2537 partial symbol table above. */
2538 if (psh
->index
!= indexNil
)
2546 complain (&unknown_ext_complaint
,
2547 debug_info
->ssext
+ psh
->iss
);
2548 /* Fall through, pretend it's global. */
2553 name
= debug_info
->ssext
+ psh
->iss
;
2554 ADD_PSYMBOL_ADDR_TO_LIST (name
, strlen (name
),
2555 VAR_NAMESPACE
, class,
2556 objfile
->global_psymbols
,
2557 (CORE_ADDR
) psh
->value
,
2558 psymtab_language
, objfile
);
2562 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2563 empty and put on the free list. */
2564 fdr_to_pst
[f_idx
].pst
= end_psymtab (save_pst
,
2565 psymtab_include_list
, includes_used
,
2566 -1, save_pst
->texthigh
,
2567 dependency_list
, dependencies_used
);
2568 if (objfile
->ei
.entry_point
>= save_pst
->textlow
&&
2569 objfile
->ei
.entry_point
< save_pst
->texthigh
)
2571 objfile
->ei
.entry_file_lowpc
= save_pst
->textlow
;
2572 objfile
->ei
.entry_file_highpc
= save_pst
->texthigh
;
2576 /* Now scan the FDRs for dependencies */
2577 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
2579 fh
= f_idx
+ debug_info
->fdr
;
2580 pst
= fdr_to_pst
[f_idx
].pst
;
2582 if (pst
== (struct partial_symtab
*)NULL
)
2585 /* This should catch stabs-in-ecoff. */
2589 /* Skip the first file indirect entry as it is a self dependency
2590 for source files or a reverse .h -> .c dependency for header files. */
2591 pst
->number_of_dependencies
= 0;
2593 ((struct partial_symtab
**)
2594 obstack_alloc (&objfile
->psymbol_obstack
,
2596 * sizeof (struct partial_symtab
*))));
2597 for (s_idx
= 1; s_idx
< fh
->crfd
; s_idx
++)
2601 (*swap_rfd_in
) (cur_bfd
,
2602 ((char *) debug_info
->external_rfd
2603 + (fh
->rfdBase
+ s_idx
) * external_rfd_size
),
2605 if (rh
< 0 || rh
>= hdr
->ifdMax
)
2607 complain (&bad_file_number_complaint
, rh
);
2611 /* Skip self dependencies of header files. */
2615 /* Do not add to dependeny list if psymtab was empty. */
2616 if (fdr_to_pst
[rh
].pst
== (struct partial_symtab
*)NULL
)
2618 pst
->dependencies
[pst
->number_of_dependencies
++] = fdr_to_pst
[rh
].pst
;
2622 /* Remove the dummy psymtab created for -O3 images above, if it is
2623 still empty, to enable the detection of stripped executables. */
2624 if (objfile
->psymtabs
->next
== NULL
2625 && objfile
->psymtabs
->number_of_dependencies
== 0
2626 && objfile
->psymtabs
->n_global_syms
== 0
2627 && objfile
->psymtabs
->n_static_syms
== 0)
2628 objfile
->psymtabs
= NULL
;
2629 do_cleanups (old_chain
);
2632 /* If the current psymbol has an enumerated type, we need to add
2633 all the the enum constants to the partial symbol table. */
2636 handle_psymbol_enumerators (objfile
, fh
, stype
)
2637 struct objfile
*objfile
;
2641 const bfd_size_type external_sym_size
= debug_swap
->external_sym_size
;
2642 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
2643 = debug_swap
->swap_sym_in
;
2644 char *ext_sym
= ((char *) debug_info
->external_sym
2645 + ((fh
->isymBase
+ cur_sdx
+ 1) * external_sym_size
));
2655 /* It is an enumerated type if the next symbol entry is a stMember
2656 and its auxiliary index is indexNil or its auxiliary entry
2657 is a plain btNil or btVoid. */
2658 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2659 if (sh
.st
!= stMember
)
2662 if (sh
.index
== indexNil
)
2664 ecoff_swap_tir_in (fh
->fBigendian
,
2665 &(debug_info
->external_aux
2666 + fh
->iauxBase
+ sh
.index
)->a_ti
,
2668 if ((tir
.bt
!= btNil
&& tir
.bt
!= btVoid
) || tir
.tq0
!= tqNil
)
2680 (*swap_sym_in
) (cur_bfd
, ext_sym
, &sh
);
2681 if (sh
.st
!= stMember
)
2683 name
= debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2685 /* Note that the value doesn't matter for enum constants
2686 in psymtabs, just in symtabs. */
2687 ADD_PSYMBOL_TO_LIST (name
, strlen (name
),
2688 VAR_NAMESPACE
, LOC_CONST
,
2689 objfile
->static_psymbols
, 0,
2690 psymtab_language
, objfile
);
2691 ext_sym
+= external_sym_size
;
2696 mdebug_next_symbol_text ()
2701 (*debug_swap
->swap_sym_in
) (cur_bfd
,
2702 ((char *) debug_info
->external_sym
2703 + ((cur_fdr
->isymBase
+ cur_sdx
)
2704 * debug_swap
->external_sym_size
)),
2706 return debug_info
->ss
+ cur_fdr
->issBase
+ sh
.iss
;
2709 /* Ancillary function to psymtab_to_symtab(). Does all the work
2710 for turning the partial symtab PST into a symtab, recurring
2711 first on all dependent psymtabs. The argument FILENAME is
2712 only passed so we can see in debug stack traces what file
2715 This function has a split personality, based on whether the
2716 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
2717 The flow of control and even the memory allocation differs. FIXME. */
2720 psymtab_to_symtab_1 (pst
, filename
)
2721 struct partial_symtab
*pst
;
2724 bfd_size_type external_sym_size
;
2725 bfd_size_type external_pdr_size
;
2726 void (*swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*));
2727 void (*swap_pdr_in
) PARAMS ((bfd
*, PTR
, PDR
*));
2731 struct linetable
*lines
;
2737 /* Read in all partial symbtabs on which this one is dependent.
2738 NOTE that we do have circular dependencies, sigh. We solved
2739 that by setting pst->readin before this point. */
2741 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2742 if (!pst
->dependencies
[i
]->readin
)
2744 /* Inform about additional files to be read in. */
2747 fputs_filtered (" ", gdb_stdout
);
2749 fputs_filtered ("and ", gdb_stdout
);
2751 printf_filtered ("%s...",
2752 pst
->dependencies
[i
]->filename
);
2753 wrap_here (""); /* Flush output */
2754 gdb_flush (gdb_stdout
);
2756 /* We only pass the filename for debug purposes */
2757 psymtab_to_symtab_1 (pst
->dependencies
[i
],
2758 pst
->dependencies
[i
]->filename
);
2761 /* Do nothing if this is a dummy psymtab. */
2763 if (pst
->n_global_syms
== 0 && pst
->n_static_syms
== 0
2764 && pst
->textlow
== 0 && pst
->texthigh
== 0)
2767 /* Now read the symbols for this symtab */
2769 cur_bfd
= CUR_BFD (pst
);
2770 debug_swap
= DEBUG_SWAP (pst
);
2771 debug_info
= DEBUG_INFO (pst
);
2772 pending_list
= PENDING_LIST (pst
);
2773 external_sym_size
= debug_swap
->external_sym_size
;
2774 external_pdr_size
= debug_swap
->external_pdr_size
;
2775 swap_sym_in
= debug_swap
->swap_sym_in
;
2776 swap_pdr_in
= debug_swap
->swap_pdr_in
;
2777 current_objfile
= pst
->objfile
;
2778 cur_fd
= FDR_IDX (pst
);
2779 fh
= ((cur_fd
== -1)
2781 : debug_info
->fdr
+ cur_fd
);
2784 /* See comment in parse_partial_symbols about the @stabs sentinel. */
2785 processing_gcc_compilation
= 0;
2786 if (fh
!= (FDR
*) NULL
&& fh
->csym
>= 2)
2790 (*swap_sym_in
) (cur_bfd
,
2791 ((char *) debug_info
->external_sym
2792 + (fh
->isymBase
+ 1) * external_sym_size
),
2794 if (STREQ (debug_info
->ss
+ fh
->issBase
+ sh
.iss
,
2797 /* We indicate that this is a GCC compilation so that certain
2798 features will be enabled in stabsread/dbxread. */
2799 processing_gcc_compilation
= 2;
2803 if (processing_gcc_compilation
!= 0)
2808 unsigned long first_off
= 0;
2810 /* This symbol table contains stabs-in-ecoff entries. */
2812 /* Parse local symbols first */
2814 if (fh
->csym
<= 2) /* FIXME, this blows psymtab->symtab ptr */
2816 current_objfile
= NULL
;
2819 for (cur_sdx
= 2; cur_sdx
< fh
->csym
; cur_sdx
++)
2825 (*swap_sym_in
) (cur_bfd
,
2826 (((char *) debug_info
->external_sym
)
2827 + (fh
->isymBase
+ cur_sdx
) * external_sym_size
),
2829 name
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
2831 if (ECOFF_IS_STAB (&sh
))
2833 int type_code
= ECOFF_UNMARK_STAB (sh
.index
);
2835 /* We should never get non N_STAB symbols here, but they
2836 should be harmless, so keep process_one_symbol from
2837 complaining about them. */
2838 if (type_code
& N_STAB
)
2840 process_one_symbol (type_code
, 0, valu
, name
,
2841 pst
->section_offsets
, pst
->objfile
);
2843 if (type_code
== N_FUN
)
2845 /* Make up special symbol to contain
2846 procedure specific info */
2847 struct mips_extra_func_info
*e
=
2848 ((struct mips_extra_func_info
*)
2849 obstack_alloc (¤t_objfile
->symbol_obstack
,
2850 sizeof (struct mips_extra_func_info
)));
2851 struct symbol
*s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
2852 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
2853 SYMBOL_CLASS (s
) = LOC_CONST
;
2854 SYMBOL_TYPE (s
) = builtin_type_void
;
2855 SYMBOL_VALUE (s
) = (long) e
;
2856 add_symbol_to_list (s
, &local_symbols
);
2859 else if (sh
.st
== stLabel
)
2861 if (sh
.index
== indexNil
)
2863 /* This is what the gcc2_compiled and __gnu_compiled_*
2864 show up as. So don't complain. */
2868 /* Handle encoded stab line number. */
2869 record_line (current_subfile
, sh
.index
, valu
);
2871 else if (sh
.st
== stProc
|| sh
.st
== stStaticProc
|| sh
.st
== stEnd
)
2872 /* These are generated by gcc-2.x, do not complain */
2875 complain (&stab_unknown_complaint
, name
);
2877 st
= end_symtab (pst
->texthigh
, 0, 0, pst
->objfile
, SECT_OFF_TEXT
);
2880 /* Sort the symbol table now, we are done adding symbols to it.
2881 We must do this before parse_procedure calls lookup_symbol. */
2882 sort_symtab_syms (st
);
2884 /* This may not be necessary for stabs symtabs. FIXME. */
2887 /* Fill in procedure info next. */
2889 pdr_ptr
= ((char *) debug_info
->external_pdr
2890 + fh
->ipdFirst
* external_pdr_size
);
2891 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2892 for (; pdr_ptr
< pdr_end
; pdr_ptr
+= external_pdr_size
)
2896 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, &pr
);
2902 parse_procedure (&pr
, st
, first_off
);
2907 /* This symbol table contains ordinary ecoff entries. */
2909 /* FIXME: doesn't use pst->section_offsets. */
2915 /* How many symbols will we need */
2916 /* FIXME, this does not count enum values. */
2917 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
2921 st
= new_symtab ("unknown", f_max
, 0, pst
->objfile
);
2925 f_max
+= fh
->csym
+ fh
->cpd
;
2926 maxlines
= 2 * fh
->cline
;
2927 st
= new_symtab (pst
->filename
, 2 * f_max
, maxlines
, pst
->objfile
);
2929 /* The proper language was already determined when building
2930 the psymtab, use it. */
2931 st
->language
= PST_PRIVATE (pst
)->pst_language
;
2934 psymtab_language
= st
->language
;
2936 lines
= LINETABLE (st
);
2938 /* Get a new lexical context */
2940 push_parse_stack ();
2941 top_stack
->cur_st
= st
;
2942 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (st
),
2944 BLOCK_START (top_stack
->cur_block
) = fh
? fh
->adr
: 0;
2945 BLOCK_END (top_stack
->cur_block
) = 0;
2946 top_stack
->blocktype
= stFile
;
2947 top_stack
->maxsyms
= 2 * f_max
;
2948 top_stack
->cur_type
= 0;
2949 top_stack
->procadr
= 0;
2950 top_stack
->numargs
= 0;
2957 /* Parse local symbols first */
2958 sym_ptr
= ((char *) debug_info
->external_sym
2959 + fh
->isymBase
* external_sym_size
);
2960 sym_end
= sym_ptr
+ fh
->csym
* external_sym_size
;
2961 while (sym_ptr
< sym_end
)
2966 (*swap_sym_in
) (cur_bfd
, sym_ptr
, &sh
);
2967 c
= parse_symbol (&sh
,
2968 debug_info
->external_aux
+ fh
->iauxBase
,
2969 sym_ptr
, fh
->fBigendian
);
2970 sym_ptr
+= c
* external_sym_size
;
2973 /* Linenumbers. At the end, check if we can save memory.
2974 parse_lines has to look ahead an arbitrary number of PDR
2975 structures, so we swap them all first. */
2979 struct cleanup
*old_chain
;
2985 pr_block
= (PDR
*) xmalloc (fh
->cpd
* sizeof (PDR
));
2987 old_chain
= make_cleanup (free
, pr_block
);
2989 pdr_ptr
= ((char *) debug_info
->external_pdr
2990 + fh
->ipdFirst
* external_pdr_size
);
2991 pdr_end
= pdr_ptr
+ fh
->cpd
* external_pdr_size
;
2995 pdr_ptr
+= external_pdr_size
, pdr_in
++)
2996 (*swap_pdr_in
) (cur_bfd
, pdr_ptr
, pdr_in
);
2998 parse_lines (fh
, pr_block
, lines
, maxlines
);
2999 if (lines
->nitems
< fh
->cline
)
3000 lines
= shrink_linetable (lines
);
3002 /* Fill in procedure info next. */
3004 pdr_in_end
= pdr_in
+ fh
->cpd
;
3005 for (; pdr_in
< pdr_in_end
; pdr_in
++)
3006 parse_procedure (pdr_in
, 0, pr_block
->adr
);
3008 do_cleanups (old_chain
);
3012 LINETABLE (st
) = lines
;
3014 /* .. and our share of externals.
3015 XXX use the global list to speed up things here. how?
3016 FIXME, Maybe quit once we have found the right number of ext's? */
3017 top_stack
->cur_st
= st
;
3018 top_stack
->cur_block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack
->cur_st
),
3020 top_stack
->blocktype
= stFile
;
3022 = (debug_info
->symbolic_header
.isymMax
3023 + debug_info
->symbolic_header
.ipdMax
3024 + debug_info
->symbolic_header
.iextMax
);
3026 ext_ptr
= PST_PRIVATE (pst
)->extern_tab
;
3027 for (i
= PST_PRIVATE (pst
)->extern_count
; --i
>= 0; ext_ptr
++)
3028 parse_external (ext_ptr
, 1, fh
->fBigendian
);
3030 /* If there are undefined symbols, tell the user.
3031 The alpha has an undefined symbol for every symbol that is
3032 from a shared library, so tell the user only if verbose is on. */
3033 if (info_verbose
&& n_undef_symbols
)
3035 printf_filtered ("File %s contains %d unresolved references:",
3036 st
->filename
, n_undef_symbols
);
3037 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
3038 n_undef_vars
, n_undef_procs
, n_undef_labels
);
3039 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
3044 /* Sort the symbol table now, we are done adding symbols to it.*/
3045 sort_symtab_syms (st
);
3050 /* Now link the psymtab and the symtab. */
3053 current_objfile
= NULL
;
3056 /* Ancillary parsing procedures. */
3058 /* Lookup the type at relative index RN. Return it in TPP
3059 if found and in any event come up with its name PNAME.
3060 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
3061 Return value says how many aux symbols we ate. */
3064 cross_ref (fd
, ax
, tpp
, type_code
, pname
, bigend
, sym_name
)
3068 enum type_code type_code
; /* Use to alloc new type if none is found. */
3080 struct mdebug_pending
*pend
;
3082 *tpp
= (struct type
*)NULL
;
3084 ecoff_swap_rndx_in (bigend
, &ax
->a_rndx
, rn
);
3086 /* Escape index means 'the next one' */
3087 if (rn
->rfd
== 0xfff)
3090 rf
= AUX_GET_ISYM (bigend
, ax
+ 1);
3097 /* mips cc uses a rf of -1 for opaque struct definitions.
3098 Set TYPE_FLAG_STUB for these types so that check_stub_type will
3099 resolve them if the struct gets defined in another compilation unit. */
3102 *pname
= "<undefined>";
3103 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3104 TYPE_FLAGS (*tpp
) |= TYPE_FLAG_STUB
;
3108 /* mips cc uses an escaped rn->index of 0 for struct return types
3109 of procedures that were compiled without -g. These will always remain
3111 if (rn
->rfd
== 0xfff && rn
->index
== 0)
3113 *pname
= "<undefined>";
3117 /* Find the relative file descriptor and the symbol in it. */
3118 fh
= get_rfd (fd
, rf
);
3119 xref_fd
= fh
- debug_info
->fdr
;
3121 if (rn
->index
>= fh
->csym
)
3123 /* File indirect entry is corrupt. */
3124 *pname
= "<illegal>";
3125 complain (&bad_rfd_entry_complaint
,
3126 sym_name
, xref_fd
, rn
->index
);
3130 /* If we have processed this symbol then we left a forwarding
3131 pointer to the type in the pending list. If not, we`ll put
3132 it in a list of pending types, to be processed later when
3133 the file will be. In any event, we collect the name for the
3136 esh
= ((char *) debug_info
->external_sym
3137 + ((fh
->isymBase
+ rn
->index
)
3138 * debug_swap
->external_sym_size
));
3139 (*debug_swap
->swap_sym_in
) (cur_bfd
, esh
, &sh
);
3141 /* Make sure that this type of cross reference can be handled. */
3142 if ((sh
.sc
!= scInfo
3143 || (sh
.st
!= stBlock
&& sh
.st
!= stTypedef
3144 && sh
.st
!= stStruct
&& sh
.st
!= stUnion
3145 && sh
.st
!= stEnum
))
3146 && (sh
.sc
!= scCommon
|| sh
.st
!= stBlock
))
3148 /* File indirect entry is corrupt. */
3149 *pname
= "<illegal>";
3150 complain (&bad_rfd_entry_complaint
,
3151 sym_name
, xref_fd
, rn
->index
);
3155 *pname
= debug_info
->ss
+ fh
->issBase
+ sh
.iss
;
3157 pend
= is_pending_symbol (fh
, esh
);
3162 /* We have not yet seen this type. */
3164 if (sh
.iss
== 0 && sh
.st
== stTypedef
)
3168 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3170 a) forward declarations of structs/unions/enums which are not
3171 defined in this compilation unit.
3172 For these the type will be void. This is a bad design decision
3173 as cross referencing across compilation units is impossible
3174 due to the missing name.
3175 b) forward declarations of structs/unions/enums which are defined
3176 later in this file or in another file in the same compilation
3177 unit. Simply cross reference those again to get the
3179 The forward references are not entered in the pending list and
3180 in the symbol table. */
3182 ecoff_swap_tir_in (bigend
,
3183 &(debug_info
->external_aux
3184 + fh
->iauxBase
+ sh
.index
)->a_ti
,
3186 if (tir
.tq0
!= tqNil
)
3187 complain (&illegal_forward_tq0_complaint
, sym_name
);
3191 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3193 *pname
= "<undefined>";
3200 (debug_info
->external_aux
3201 + fh
->iauxBase
+ sh
.index
+ 1),
3202 tpp
, type_code
, pname
,
3203 fh
->fBigendian
, sym_name
);
3207 complain (&illegal_forward_bt_complaint
, tir
.bt
, sym_name
);
3208 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
,
3214 else if (sh
.st
== stTypedef
)
3216 /* Parse the type for a normal typedef. This might recursively call
3217 cross_ref till we get a non typedef'ed type.
3218 FIXME: This is not correct behaviour, but gdb currently
3219 cannot handle typedefs without type copying. But type copying is
3220 impossible as we might have mutual forward references between
3221 two files and the copied type would not get filled in when
3222 we later parse its definition. */
3223 *tpp
= parse_type (xref_fd
,
3224 debug_info
->external_aux
+ fh
->iauxBase
,
3228 debug_info
->ss
+ fh
->issBase
+ sh
.iss
);
3232 /* Cross reference to a struct/union/enum which is defined
3233 in another file in the same compilation unit but that file
3234 has not been parsed yet.
3235 Initialize the type only, it will be filled in when
3236 it's definition is parsed. */
3237 *tpp
= init_type (type_code
, 0, 0, (char *) NULL
, current_objfile
);
3239 add_pending (fh
, esh
, *tpp
);
3242 /* We used one auxent normally, two if we got a "next one" rf. */
3247 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3248 keeping the symtab sorted */
3250 static struct symbol
*
3251 mylookup_symbol (name
, block
, namespace, class)
3253 register struct block
*block
;
3254 enum namespace namespace;
3255 enum address_class
class;
3257 register int bot
, top
, inc
;
3258 register struct symbol
*sym
;
3261 top
= BLOCK_NSYMS (block
);
3265 sym
= BLOCK_SYM (block
, bot
);
3266 if (SYMBOL_NAME (sym
)[0] == inc
3267 && SYMBOL_NAMESPACE (sym
) == namespace
3268 && SYMBOL_CLASS (sym
) == class
3269 && strcmp (SYMBOL_NAME (sym
), name
) == 0)
3273 block
= BLOCK_SUPERBLOCK (block
);
3275 return mylookup_symbol (name
, block
, namespace, class);
3280 /* Add a new symbol S to a block B.
3281 Infrequently, we will need to reallocate the block to make it bigger.
3282 We only detect this case when adding to top_stack->cur_block, since
3283 that's the only time we know how big the block is. FIXME. */
3290 int nsyms
= BLOCK_NSYMS (b
)++;
3291 struct block
*origb
;
3292 struct parse_stack
*stackp
;
3294 if (b
== top_stack
->cur_block
&&
3295 nsyms
>= top_stack
->maxsyms
)
3297 complain (&block_overflow_complaint
, SYMBOL_NAME (s
));
3298 /* In this case shrink_block is actually grow_block, since
3299 BLOCK_NSYMS(b) is larger than its current size. */
3301 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
3303 /* Now run through the stack replacing pointers to the
3304 original block. shrink_block has already done this
3305 for the blockvector and BLOCK_FUNCTION. */
3306 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
)
3308 if (stackp
->cur_block
== origb
)
3310 stackp
->cur_block
= b
;
3311 stackp
->maxsyms
= BLOCK_NSYMS (b
);
3315 BLOCK_SYM (b
, nsyms
) = s
;
3318 /* Add a new block B to a symtab S */
3325 struct blockvector
*bv
= BLOCKVECTOR (s
);
3327 bv
= (struct blockvector
*) xrealloc ((PTR
) bv
,
3328 (sizeof (struct blockvector
)
3329 + BLOCKVECTOR_NBLOCKS (bv
)
3330 * sizeof (bv
->block
)));
3331 if (bv
!= BLOCKVECTOR (s
))
3332 BLOCKVECTOR (s
) = bv
;
3334 BLOCKVECTOR_BLOCK (bv
, BLOCKVECTOR_NBLOCKS (bv
)++) = b
;
3337 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3338 MIPS' linenumber encoding might need more than one byte
3339 to describe it, LAST is used to detect these continuation lines.
3341 Combining lines with the same line number seems like a bad idea.
3342 E.g: There could be a line number entry with the same line number after the
3343 prologue and GDB should not ignore it (this is a better way to find
3344 a prologue than mips_skip_prologue).
3345 But due to the compressed line table format there are line number entries
3346 for the same line which are needed to bridge the gap to the next
3347 line number entry. These entries have a bogus address info with them
3348 and we are unable to tell them from intended duplicate line number
3350 This is another reason why -ggdb debugging format is preferable. */
3353 add_line (lt
, lineno
, adr
, last
)
3354 struct linetable
*lt
;
3359 /* DEC c89 sometimes produces zero linenos which confuse gdb.
3360 Change them to something sensible. */
3364 last
= -2; /* make sure we record first line */
3366 if (last
== lineno
) /* skip continuation lines */
3369 lt
->item
[lt
->nitems
].line
= lineno
;
3370 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
3374 /* Sorting and reordering procedures */
3376 /* Blocks with a smaller low bound should come first */
3379 compare_blocks (arg1
, arg2
)
3383 register int addr_diff
;
3384 struct block
**b1
= (struct block
**) arg1
;
3385 struct block
**b2
= (struct block
**) arg2
;
3387 addr_diff
= (BLOCK_START ((*b1
))) - (BLOCK_START ((*b2
)));
3389 return (BLOCK_END ((*b2
))) - (BLOCK_END ((*b1
)));
3393 /* Sort the blocks of a symtab S.
3394 Reorder the blocks in the blockvector by code-address,
3395 as required by some MI search routines */
3401 struct blockvector
*bv
= BLOCKVECTOR (s
);
3403 if (BLOCKVECTOR_NBLOCKS (bv
) <= 2)
3406 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) == 0)
3407 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = 0;
3408 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) == 0)
3409 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) = 0;
3413 * This is very unfortunate: normally all functions are compiled in
3414 * the order they are found, but if the file is compiled -O3 things
3415 * are very different. It would be nice to find a reliable test
3416 * to detect -O3 images in advance.
3418 if (BLOCKVECTOR_NBLOCKS (bv
) > 3)
3419 qsort (&BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
),
3420 BLOCKVECTOR_NBLOCKS (bv
) - FIRST_LOCAL_BLOCK
,
3421 sizeof (struct block
*),
3425 register CORE_ADDR high
= 0;
3426 register int i
, j
= BLOCKVECTOR_NBLOCKS (bv
);
3428 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
3429 if (high
< BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
)))
3430 high
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, i
));
3431 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) = high
;
3434 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
)) =
3435 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, FIRST_LOCAL_BLOCK
));
3437 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3438 BLOCK_START (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3439 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)) =
3440 BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3444 /* Constructor/restructor/destructor procedures */
3446 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3447 MAXSYMS and linenumbers MAXLINES we'll put in it */
3449 static struct symtab
*
3450 new_symtab (name
, maxsyms
, maxlines
, objfile
)
3454 struct objfile
*objfile
;
3456 struct symtab
*s
= allocate_symtab (name
, objfile
);
3458 LINETABLE (s
) = new_linetable (maxlines
);
3460 /* All symtabs must have at least two blocks */
3461 BLOCKVECTOR (s
) = new_bvect (2);
3462 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
) = new_block (maxsyms
);
3463 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
) = new_block (maxsyms
);
3464 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)) =
3465 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3467 s
->free_code
= free_linetable
;
3472 /* Allocate a new partial_symtab NAME */
3474 static struct partial_symtab
*
3475 new_psymtab (name
, objfile
, section_offsets
)
3477 struct objfile
*objfile
;
3478 struct section_offsets
*section_offsets
;
3480 struct partial_symtab
*psymtab
;
3482 psymtab
= allocate_psymtab (name
, objfile
);
3483 psymtab
->section_offsets
= section_offsets
;
3485 /* Keep a backpointer to the file's symbols */
3487 psymtab
->read_symtab_private
= ((char *)
3488 obstack_alloc (&objfile
->psymbol_obstack
,
3489 sizeof (struct symloc
)));
3490 memset ((PTR
) psymtab
->read_symtab_private
, 0, sizeof (struct symloc
));
3491 CUR_BFD (psymtab
) = cur_bfd
;
3492 DEBUG_SWAP (psymtab
) = debug_swap
;
3493 DEBUG_INFO (psymtab
) = debug_info
;
3494 PENDING_LIST (psymtab
) = pending_list
;
3496 /* The way to turn this into a symtab is to call... */
3497 psymtab
->read_symtab
= mdebug_psymtab_to_symtab
;
3502 /* Allocate a linetable array of the given SIZE. Since the struct
3503 already includes one item, we subtract one when calculating the
3504 proper size to allocate. */
3506 static struct linetable
*
3507 new_linetable (size
)
3510 struct linetable
*l
;
3512 size
= (size
- 1) * sizeof (l
->item
) + sizeof (struct linetable
);
3513 l
= (struct linetable
*) xmalloc (size
);
3518 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3519 I am not so sure about the 3.4 ones.
3521 Since the struct linetable already includes one item, we subtract one when
3522 calculating the proper size to allocate. */
3524 static struct linetable
*
3525 shrink_linetable (lt
)
3526 struct linetable
*lt
;
3529 return (struct linetable
*) xrealloc ((PTR
) lt
,
3530 (sizeof (struct linetable
)
3532 * sizeof (lt
->item
))));
3535 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3537 static struct blockvector
*
3541 struct blockvector
*bv
;
3544 size
= sizeof (struct blockvector
) + nblocks
* sizeof (struct block
*);
3545 bv
= (struct blockvector
*) xzalloc (size
);
3547 BLOCKVECTOR_NBLOCKS (bv
) = nblocks
;
3552 /* Allocate and zero a new block of MAXSYMS symbols */
3554 static struct block
*
3558 int size
= sizeof (struct block
) + (maxsyms
- 1) * sizeof (struct symbol
*);
3560 return (struct block
*) xzalloc (size
);
3563 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3564 Shrink_block can also be used by add_symbol to grow a block. */
3566 static struct block
*
3572 struct blockvector
*bv
= BLOCKVECTOR (s
);
3575 /* Just reallocate it and fix references to the old one */
3577 new = (struct block
*) xrealloc ((PTR
) b
,
3578 (sizeof (struct block
)
3579 + ((BLOCK_NSYMS (b
) - 1)
3580 * sizeof (struct symbol
*))));
3582 /* Should chase pointers to old one. Fortunately, that`s just
3583 the block`s function and inferior blocks */
3584 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b
)
3585 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3586 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); i
++)
3587 if (BLOCKVECTOR_BLOCK (bv
, i
) == b
)
3588 BLOCKVECTOR_BLOCK (bv
, i
) = new;
3589 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) == b
)
3590 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv
, i
)) = new;
3594 /* Create a new symbol with printname NAME */
3596 static struct symbol
*
3600 struct symbol
*s
= ((struct symbol
*)
3601 obstack_alloc (¤t_objfile
->symbol_obstack
,
3602 sizeof (struct symbol
)));
3604 memset ((PTR
) s
, 0, sizeof (*s
));
3605 SYMBOL_NAME (s
) = name
;
3606 SYMBOL_LANGUAGE (s
) = psymtab_language
;
3607 SYMBOL_INIT_DEMANGLED_NAME (s
, ¤t_objfile
->symbol_obstack
);
3611 /* Create a new type with printname NAME */
3613 static struct type
*
3619 t
= alloc_type (current_objfile
);
3620 TYPE_NAME (t
) = name
;
3621 TYPE_CPLUS_SPECIFIC (t
) = (struct cplus_struct_type
*) &cplus_struct_default
;
3625 /* Read ECOFF debugging information from a BFD section. This is
3626 called from elfread.c. It parses the section into a
3627 ecoff_debug_info struct, and then lets the rest of the file handle
3631 elfmdebug_build_psymtabs (objfile
, swap
, sec
, section_offsets
)
3632 struct objfile
*objfile
;
3633 const struct ecoff_debug_swap
*swap
;
3635 struct section_offsets
*section_offsets
;
3637 bfd
*abfd
= objfile
->obfd
;
3639 struct ecoff_debug_info
*info
;
3641 buf
= alloca (swap
->external_hdr_size
);
3642 if (bfd_get_section_contents (abfd
, sec
, buf
, (file_ptr
) 0,
3643 swap
->external_hdr_size
) == false)
3644 perror_with_name (bfd_get_filename (abfd
));
3646 info
= ((struct ecoff_debug_info
*)
3647 obstack_alloc (&objfile
->psymbol_obstack
,
3648 sizeof (struct ecoff_debug_info
)));
3650 (*swap
->swap_hdr_in
) (abfd
, buf
, &info
->symbolic_header
);
3652 /* The offsets in symbolic_header are file offsets, not section
3653 offsets. Strangely, on Irix 5 the information is not entirely
3654 within the .mdebug section. There are parts of an executable
3655 file which are not within any ELF section at all. This means
3656 that we must read the information using bfd_read. */
3658 #define READ(ptr, count, off, size, type) \
3661 if (info->symbolic_header.count == 0) \
3662 info->ptr = (type) NULL; \
3665 info->ptr = ((type) \
3666 obstack_alloc (&objfile->psymbol_obstack, \
3667 (info->symbolic_header.count \
3669 if (bfd_seek (abfd, info->symbolic_header.off, SEEK_SET) < 0 \
3670 || (bfd_read ((PTR) info->ptr, size, \
3671 info->symbolic_header.count, abfd) \
3672 != info->symbolic_header.count * size)) \
3673 perror_with_name (bfd_get_filename (abfd)); \
3678 READ (line
, cbLine
, cbLineOffset
, sizeof (unsigned char), unsigned char *);
3679 READ (external_dnr
, idnMax
, cbDnOffset
, swap
->external_dnr_size
, PTR
);
3680 READ (external_pdr
, ipdMax
, cbPdOffset
, swap
->external_pdr_size
, PTR
);
3681 READ (external_sym
, isymMax
, cbSymOffset
, swap
->external_sym_size
, PTR
);
3682 READ (external_opt
, ioptMax
, cbOptOffset
, swap
->external_opt_size
, PTR
);
3683 READ (external_aux
, iauxMax
, cbAuxOffset
, sizeof (union aux_ext
),
3685 READ (ss
, issMax
, cbSsOffset
, sizeof (char), char *);
3686 READ (ssext
, issExtMax
, cbSsExtOffset
, sizeof (char), char *);
3687 READ (external_fdr
, ifdMax
, cbFdOffset
, swap
->external_fdr_size
, PTR
);
3688 READ (external_rfd
, crfd
, cbRfdOffset
, swap
->external_rfd_size
, PTR
);
3689 READ (external_ext
, iextMax
, cbExtOffset
, swap
->external_ext_size
, PTR
);
3695 mdebug_build_psymtabs (objfile
, swap
, info
, section_offsets
);
3699 /* Things used for calling functions in the inferior.
3700 These functions are exported to our companion
3701 mips-tdep.c file and are here because they play
3702 with the symbol-table explicitly. */
3704 /* Sigtramp: make sure we have all the necessary information
3705 about the signal trampoline code. Since the official code
3706 from MIPS does not do so, we make up that information ourselves.
3707 If they fix the library (unlikely) this code will neutralize itself. */
3709 /* FIXME: This function is called only by mips-tdep.c. It needs to be
3710 here because it calls functions defined in this file, but perhaps
3711 this could be handled in a better way. */
3718 struct block
*b
, *b0
= NULL
;
3720 sigtramp_address
= -1;
3722 /* We have to handle the following cases here:
3723 a) The Mips library has a sigtramp label within sigvec.
3724 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
3725 s
= lookup_symbol ("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
3728 b0
= SYMBOL_BLOCK_VALUE (s
);
3729 s
= lookup_symbol ("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
3733 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
3734 s
= lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE
, 0, NULL
);
3737 /* But maybe this program uses its own version of sigvec */
3741 /* Did we or MIPSco fix the library ? */
3742 if (SYMBOL_CLASS (s
) == LOC_BLOCK
)
3744 sigtramp_address
= BLOCK_START (SYMBOL_BLOCK_VALUE (s
));
3745 sigtramp_end
= BLOCK_END (SYMBOL_BLOCK_VALUE (s
));
3749 sigtramp_address
= SYMBOL_VALUE (s
);
3750 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
3752 /* But what symtab does it live in ? */
3753 st
= find_pc_symtab (SYMBOL_VALUE (s
));
3756 * Ok, there goes the fix: turn it into a procedure, with all the
3757 * needed info. Note we make it a nested procedure of sigvec,
3758 * which is the way the (assembly) code is actually written.
3760 SYMBOL_NAMESPACE (s
) = VAR_NAMESPACE
;
3761 SYMBOL_CLASS (s
) = LOC_BLOCK
;
3762 SYMBOL_TYPE (s
) = init_type (TYPE_CODE_FUNC
, 4, 0, (char *) NULL
,
3764 TYPE_TARGET_TYPE (SYMBOL_TYPE (s
)) = builtin_type_void
;
3766 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
3768 SYMBOL_BLOCK_VALUE (s
) = b
;
3769 BLOCK_START (b
) = sigtramp_address
;
3770 BLOCK_END (b
) = sigtramp_end
;
3771 BLOCK_FUNCTION (b
) = s
;
3772 BLOCK_SUPERBLOCK (b
) = BLOCK_SUPERBLOCK (b0
);
3776 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
3778 struct mips_extra_func_info
*e
=
3779 ((struct mips_extra_func_info
*)
3780 xzalloc (sizeof (struct mips_extra_func_info
)));
3782 e
->numargs
= 0; /* the kernel thinks otherwise */
3783 e
->pdr
.frameoffset
= 32;
3784 e
->pdr
.framereg
= SP_REGNUM
;
3785 /* Note that setting pcreg is no longer strictly necessary as
3786 mips_frame_saved_pc is now aware of signal handler frames. */
3787 e
->pdr
.pcreg
= PC_REGNUM
;
3788 e
->pdr
.regmask
= -2;
3789 /* Offset to saved r31, in the sigtramp case the saved registers
3790 are above the frame in the sigcontext.
3791 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
3792 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
3793 and 32 * 4 bytes for the floating point registers. */
3794 e
->pdr
.regoffset
= 4 + 12 + 31 * 4;
3795 e
->pdr
.fregmask
= -1;
3796 /* Offset to saved f30 (first saved *double* register). */
3797 e
->pdr
.fregoffset
= 4 + 12 + 32 * 4 + 12 + 30 * 4;
3798 e
->pdr
.isym
= (long) s
;
3799 e
->pdr
.adr
= sigtramp_address
;
3801 current_objfile
= st
->objfile
; /* Keep new_symbol happy */
3802 s
= new_symbol (MIPS_EFI_SYMBOL_NAME
);
3803 SYMBOL_VALUE (s
) = (long) e
;
3804 SYMBOL_NAMESPACE (s
) = LABEL_NAMESPACE
;
3805 SYMBOL_CLASS (s
) = LOC_CONST
;
3806 SYMBOL_TYPE (s
) = builtin_type_void
;
3807 current_objfile
= NULL
;
3810 BLOCK_SYM (b
, BLOCK_NSYMS (b
)++) = s
;
3814 _initialize_mdebugread ()
3816 /* Missing basic types */
3818 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
3820 mdebug_type_string
=
3821 init_type (TYPE_CODE_STRING
,
3822 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
3824 (struct objfile
*) NULL
);
3826 mdebug_type_complex
=
3827 init_type (TYPE_CODE_ERROR
,
3828 TARGET_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3830 (struct objfile
*) NULL
);
3831 mdebug_type_double_complex
=
3832 init_type (TYPE_CODE_ERROR
,
3833 TARGET_DOUBLE_COMPLEX_BIT
/ TARGET_CHAR_BIT
,
3834 0, "double complex",
3835 (struct objfile
*) NULL
);
3837 /* We use TYPE_CODE_INT to print these as integers. Does this do any
3838 good? Would we be better off with TYPE_CODE_ERROR? Should
3839 TYPE_CODE_ERROR print things in hex if it knows the size? */
3840 mdebug_type_fixed_dec
=
3841 init_type (TYPE_CODE_INT
,
3842 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3844 (struct objfile
*) NULL
);
3846 mdebug_type_float_dec
=
3847 init_type (TYPE_CODE_ERROR
,
3848 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
3849 0, "floating decimal",
3850 (struct objfile
*) NULL
);