1 /* Read a symbol table in MIPS' format (Third-Eye).
2 Copyright (C) 1986, 1987, 1989-1991 Free Software Foundation, Inc.
3 Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This module provides three functions: mipscoff_symfile_init,
22 which initializes to read a symbol file; mipscoff_new_init, which
23 discards existing cached information when all symbols are being
24 discarded; and mipscoff_symfile_read, which reads a symbol table
27 mipscoff_symfile_read only does the minimum work necessary for letting the
28 user "name" things symbolically; it does not read the entire symtab.
29 Instead, it reads the external and static symbols and puts them in partial
30 symbol tables. When more extensive information is requested of a
31 file, the corresponding partial symbol table is mutated into a full
32 fledged symbol table by going back and reading the symbols
33 for real. mipscoff_psymtab_to_symtab() is called indirectly through
34 a pointer in the psymtab to do this. */
39 #include <sys/param.h>
47 #include <mips/syms.h>
51 #endif /* not CMUCS */
56 struct external_filehdr f
;
57 struct external_aouthdr a
;
60 /* Things we import explicitly from other modules */
62 extern int info_verbose
;
63 extern struct block
*block_for_pc();
64 extern void sort_symtab_syms();
66 /* Various complaints about symbol reading that don't abort the process */
68 struct complaint unknown_ext_complaint
=
69 {"unknown external symbol %s", 0, 0};
71 struct complaint unknown_sym_complaint
=
72 {"unknown local symbol %s", 0, 0};
74 struct complaint unknown_st_complaint
=
75 {"with type %d", 0, 0};
77 struct complaint block_overflow_complaint
=
78 {"block containing %s overfilled", 0, 0};
80 struct complaint basic_type_complaint
=
81 {"cannot map MIPS basic type 0x%x", 0, 0};
83 struct complaint unknown_type_qual_complaint
=
84 {"unknown type qualifier 0x%x", 0, 0};
86 struct complaint array_bitsize_complaint
=
87 {"size of array target type not known, assuming %d bits", 0, 0};
89 struct complaint array_parse_complaint
=
90 {"array type with strange relative symbol", 0, 0};
92 /* Macros and extra defs */
94 /* Already-parsed symbols are marked specially */
96 #define stParsed stType
98 /* Puns: hard to find whether -g was used and how */
100 #define MIN_GLEVEL GLEVEL_0
101 #define compare_glevel(a,b) \
102 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
103 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
105 /* When looking at .o files, avoid tripping over bad addresses */
107 #define SAFE_TEXT_ADDR 0x400000
108 #define SAFE_DATA_ADDR 0x10000000
110 #define UNSAFE_DATA_ADDR(p) ((unsigned)p < SAFE_DATA_ADDR || (unsigned)p > 2*SAFE_DATA_ADDR)
112 /* Things that really are local to this module */
114 /* GDB symtable for the current compilation unit */
116 static struct symtab
*cur_stab
;
118 /* MIPS symtab header for the current file */
120 static HDRR
*cur_hdr
;
122 /* Pointer to current file decriptor record, and its index */
127 /* Index of current symbol */
131 /* Note how much "debuggable" this image is. We would like
132 to see at least one FDR with full symbols */
137 /* When examining .o files, report on undefined symbols */
139 static int n_undef_symbols
, n_undef_labels
, n_undef_vars
, n_undef_procs
;
141 /* Extra builtin types */
143 struct type
*builtin_type_complex
;
144 struct type
*builtin_type_double_complex
;
145 struct type
*builtin_type_fixed_dec
;
146 struct type
*builtin_type_float_dec
;
147 struct type
*builtin_type_string
;
151 static struct type
*builtin_type_ptr
;
152 static struct type
*builtin_type_struct
;
153 static struct type
*builtin_type_union
;
154 static struct type
*builtin_type_enum
;
155 static struct type
*builtin_type_range
;
156 static struct type
*builtin_type_set
;
158 /* Forward declarations */
160 static struct symbol
*new_symbol();
161 static struct type
*new_type();
162 static struct field
*new_field();
163 static struct block
*new_block();
164 static struct symtab
*new_symtab();
165 static struct linetable
*new_linetable();
166 static struct blockvector
*new_bvect();
168 static struct type
*parse_type();
169 static struct type
*make_type();
170 static struct symbol
*mylookup_symbol();
171 static struct block
*shrink_block();
173 static int compare_symtabs();
174 static int compare_psymtabs();
175 static int compare_blocks();
177 static struct partial_symtab
*new_psymtab();
178 static struct partial_symtab
*parse_fdr();
179 static int compare_psymbols();
181 static void psymtab_to_symtab_1();
182 static void add_block();
183 static void add_symbol();
184 static int add_line();
185 static void reorder_symtabs();
186 static void reorder_psymtabs();
187 static void shrink_linetable();
189 /* Things we export to other modules */
191 /* Address bounds for the signal trampoline in inferior, if any */
192 /* FIXME: Nothing really seems to use this. Why is it here? */
194 CORE_ADDR sigtramp_address
, sigtramp_end
;
196 /* The entry point (starting address) of the file, if it is an executable. */
198 static CORE_ADDR entry_point
;
200 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
201 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
206 /* If we have a file symbol header lying around, blow it away. */
208 free ((char *)cur_hdr
);
213 mipscoff_symfile_init (sf
)
216 bfd
*abfd
= sf
->sym_bfd
;
217 sf
->sym_private
= NULL
;
219 /* Save startup file's range of PC addresses to help blockframe.c
220 decide where the bottom of the stack is. */
221 if (bfd_get_file_flags (abfd
) & EXEC_P
)
223 /* Executable file -- record its entry point so we'll recognize
224 the startup file because it contains the entry point. */
225 entry_point
= bfd_get_start_address (abfd
);
229 /* Examination of non-executable.o files. Short-circuit this stuff. */
230 /* ~0 will not be in any file, we hope. */
232 /* set the startup file to be an empty range. */
233 startup_file_start
= 0;
234 startup_file_end
= 0;
239 mipscoff_symfile_read(sf
, addr
, mainline
)
244 struct coff_symfile_info
*info
= (struct coff_symfile_info
*)sf
->sym_private
;
245 bfd
*abfd
= sf
->sym_bfd
;
246 char *name
= bfd_get_filename (abfd
);
250 int stringtab_offset
;
252 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
253 desc
= fileno ((FILE *)(abfd
->iostream
)); /* Raw file descriptor */
256 /* Position to read the symbol table. */
257 val
= lseek (desc
, (long)symtab_offset
, 0);
259 perror_with_name (name
);
261 init_misc_bunches ();
262 make_cleanup (discard_misc_bunches
, 0);
264 /* Now that the executable file is positioned at symbol table,
265 process it and define symbols accordingly. */
267 read_mips_symtab(abfd
, desc
);
269 /* Go over the misc symbol bunches and install them in vector. */
271 condense_misc_bunches (!mainline
);
274 /* Exported procedure: Allocate zeroed memory */
279 char *p
= xmalloc(size
);
285 /* Exported procedure: Builds a symtab from the PST partial one.
286 Restores the environment in effect when PST was created, delegates
287 most of the work to an ancillary procedure, and sorts
288 and reorders the symtab list at the end */
291 mipscoff_psymtab_to_symtab(pst
)
292 struct partial_symtab
*pst
;
301 printf_filtered("Reading in symbols for %s...", pst
->filename
);
304 /* Restore the header and list of pending typedefs */
305 /* FIXME, we should use private data that is a proper pointer. */
306 cur_hdr
= (HDRR
*) pst
->ldsymlen
;
308 psymtab_to_symtab_1(pst
, pst
->filename
);
313 printf_filtered("done.\n");
316 /* Exported procedure: Is PC in the signal trampoline code */
319 in_sigtramp(pc
, name
)
323 if (sigtramp_address
== 0)
325 return (pc
>= sigtramp_address
&& pc
< sigtramp_end
);
328 /* File-level interface functions */
330 /* Read the symtab information from file FSYM into memory. Also,
331 return address just past end of our text segment in *END_OF_TEXT_SEGP. */
334 read_the_mips_symtab(abfd
, fsym
, end_of_text_segp
)
337 CORE_ADDR
*end_of_text_segp
;
339 int stsize
, st_hdrsize
;
342 /* Header for executable/object file we read symbols from */
343 struct coff_exec filhdr
;
345 /* We get here with DESC pointing to the symtab header. But we need
346 * other info from the initial headers */
348 myread(fsym
, &filhdr
, sizeof filhdr
);
350 if (end_of_text_segp
)
352 bfd_h_get_32 (abfd
, filhdr
.a
.text_start
) +
353 bfd_h_get_32 (abfd
, filhdr
.a
.tsize
);
355 /* Find and read the symbol table header */
356 st_hdrsize
= bfd_h_get_32 (abfd
, filhdr
.f
.f_nsyms
);
357 st_filptr
= bfd_h_get_32 (abfd
, filhdr
.f
.f_symptr
);
361 lseek(fsym
, st_filptr
, L_SET
);
362 if (st_hdrsize
> sizeof (st_hdr
)) /* Profanity check */
364 if (read(fsym
, &st_hdr
, st_hdrsize
) != st_hdrsize
)
367 /* Find out how large the symbol table is */
368 stsize
= (st_hdr
.cbExtOffset
- (st_filptr
+ st_hdrsize
))
369 + st_hdr
.iextMax
* cbEXTR
;
371 /* Allocate space for the symbol table. Read it in. */
372 cur_hdr
= (HDRR
*) xmalloc(stsize
+ st_hdrsize
);
374 bcopy(&st_hdr
, cur_hdr
, st_hdrsize
);
375 if (read(fsym
, (char *) cur_hdr
+ st_hdrsize
, stsize
) != stsize
)
378 /* Fixup file_pointers in it */
379 fixup_symtab(cur_hdr
, (char *) cur_hdr
+ st_hdrsize
,
380 st_filptr
+ st_hdrsize
);
384 error("Short read on %s", symfile
);
388 /* Turn all file-relative pointers in the symtab described by HDR
389 into memory pointers, given that the symtab itself is located
390 at DATA in memory and F_PTR in the file. */
393 fixup_symtab( hdr
, data
, f_ptr
)
405 * These fields are useless (and empty) by now:
406 * hdr->cbDnOffset, hdr->cbOptOffset
407 * We use them for other internal purposes.
410 hdr
->cbOptOffset
= 0;
413 if (hdr->off) hdr->off = (unsigned int)data + (hdr->off - f_ptr);
429 * Fix all string pointers inside the symtab, and
430 * the FDR records. Also fix other miscellany.
432 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
433 register unsigned code_offset
;
435 /* Header itself, and strings */
436 fh
= (FDR
*) (hdr
->cbFdOffset
) + f_idx
;
437 fh
->issBase
+= hdr
->cbSsOffset
;
439 fh
->rss
= (long)fh
->rss
+ fh
->issBase
;
440 for (s_idx
= 0; s_idx
< fh
->csym
; s_idx
++) {
441 sh
= (SYMR
*)(hdr
->cbSymOffset
) + fh
->isymBase
+ s_idx
;
442 sh
->iss
= (long) sh
->iss
+ fh
->issBase
;
449 fh
->isymBase
= (int)((SYMR
*)(hdr
->cbSymOffset
)+fh
->isymBase
);
451 /* cannot fix fh->ipdFirst because it is a short */
452 #define IPDFIRST(h,fh) \
453 ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR))
455 /* Optional symbols (actually used for partial_symtabs) */
461 fh
->iauxBase
= hdr
->cbAuxOffset
+ fh
->iauxBase
* sizeof(AUXU
);
462 /* Relative file descriptor table */
463 fh
->rfdBase
= hdr
->cbRfdOffset
+ fh
->rfdBase
* sizeof(RFDT
);
467 fh
->cbLineOffset
+= hdr
->cbLineOffset
;
469 /* Procedure symbols. (XXX This should be done later) */
470 code_offset
= fh
->adr
;
471 for (s_idx
= 0; s_idx
< fh
->cpd
; s_idx
++) {
472 unsigned name
, only_ext
;
474 pr
= (PDR
*)(IPDFIRST(hdr
,fh
)) + s_idx
;
476 /* Simple rule to find files linked "-x" */
477 only_ext
= fh
->rss
== -1;
479 if (pr
->isym
== -1) {
480 /* static function */
484 name
= hdr
->cbExtOffset
+ pr
->isym
* sizeof(EXTR
);
485 sh
= &((EXTR
*)name
)->asym
;
489 sh
= (SYMR
*)fh
->isymBase
+ pr
->isym
;
490 /* Included code ? */
491 if (s_idx
== 0 && pr
->adr
!= 0)
492 code_offset
-= pr
->adr
;
495 /* Turn index into a pointer */
498 /* Fix line numbers */
499 pr
->cbLineOffset
+= fh
->cbLineOffset
;
501 /* Relocate address */
503 pr
->adr
+= code_offset
;
507 /* External symbols: fix string */
508 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
509 esh
= (EXTR
*)(hdr
->cbExtOffset
) + s_idx
;
510 esh
->asym
.iss
= esh
->asym
.iss
+ hdr
->cbSsExtOffset
;
515 /* Find a file descriptor given its index RF relative to a file CF */
523 f
= (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
524 /* Object files do not have the RFD table, all refs are absolute */
526 return (FDR
*) (cur_hdr
->cbFdOffset
) + rf
;
527 cf
= *((pRFDT
) f
->rfdBase
+ rf
);
528 return (FDR
*) (cur_hdr
->cbFdOffset
) + cf
;
531 /* Return a safer print NAME for a file descriptor */
537 if (name
== (char *) -1)
538 return "<stripped file>";
539 if (UNSAFE_DATA_ADDR(name
))
545 /* Read in and parse the symtab of the file DESC. INCREMENTAL says
546 whether we are adding to the general symtab or not.
547 FIXME: INCREMENTAL is currently always zero, though it should not be. */
550 read_mips_symtab (abfd
, desc
)
554 CORE_ADDR end_of_text_seg
;
556 read_the_mips_symtab(abfd
, desc
, &end_of_text_seg
);
558 parse_partial_symbols(end_of_text_seg
);
561 * Check to make sure file was compiled with -g.
562 * If not, warn the user of this limitation.
564 if (compare_glevel(max_glevel
, GLEVEL_2
) < 0) {
565 if (max_gdbinfo
== 0)
566 printf("\n%s not compiled with -g, debugging support is limited.", symfile
);
567 printf("\nYou should compile with -g2 or -g3 for best debugging support.\n");
572 /* Local utilities */
574 /* Map of FDR indexes to partial symtabs */
576 static struct pst_map
{
577 struct partial_symtab
*pst
; /* the psymtab proper */
578 int n_globals
; /* globals it exports */
579 int n_statics
; /* statics (locals) it contains */
583 /* Utility stack, used to nest procedures and blocks properly.
584 It is a doubly linked list, to avoid too many alloc/free.
585 Since we might need it quite a few times it is NOT deallocated
588 static struct parse_stack
{
589 struct parse_stack
*next
, *prev
;
590 struct symtab
*cur_st
; /* Current symtab */
591 struct block
*cur_block
; /* Block in it */
592 int blocktype
; /* What are we parsing */
593 int maxsyms
; /* Max symbols in this block */
594 struct type
*cur_type
; /* Type we parse fields for */
595 int procadr
; /* Start addres of this procedure */
596 int numargs
; /* Its argument count */
597 } *top_stack
; /* Top stack ptr */
600 /* Enter a new lexical context */
602 static push_parse_stack()
604 struct parse_stack
*new;
606 /* Reuse frames if possible */
607 if (top_stack
&& top_stack
->prev
)
608 new = top_stack
->prev
;
610 new = (struct parse_stack
*) xzalloc(sizeof(struct parse_stack
));
611 /* Initialize new frame with previous content */
613 register struct parse_stack
*prev
= new->prev
;
616 top_stack
->prev
= new;
618 new->next
= top_stack
;
623 /* Exit a lexical context */
625 static pop_parse_stack()
630 top_stack
= top_stack
->next
;
634 /* Cross-references might be to things we haven't looked at
635 yet, e.g. type references. To avoid too many type
636 duplications we keep a quick fixup table, an array
637 of lists of references indexed by file descriptor */
639 static struct pending
{
640 struct pending
*next
; /* link */
641 SYMR
*s
; /* the symbol */
642 struct type
*t
; /* its partial type descriptor */
646 /* Check whether we already saw symbol SH in file FH as undefined */
649 struct pending
*is_pending_symbol(fh
, sh
)
653 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
654 register struct pending
*p
;
656 /* Linear search is ok, list is typically no more than 10 deep */
657 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
663 /* Check whether we already saw type T in file FH as undefined */
666 struct pending
*is_pending_type(fh
, t
)
670 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
671 register struct pending
*p
;
673 for (p
= pending_list
[f_idx
]; p
; p
= p
->next
)
679 /* Add a new undef symbol SH of type T */
682 add_pending(fh
, sh
, t
)
687 int f_idx
= fh
- (FDR
*) cur_hdr
->cbFdOffset
;
688 struct pending
*p
= is_pending_symbol(fh
, sh
);
690 /* Make sure we do not make duplicates */
692 p
= (struct pending
*) xmalloc(sizeof(*p
));
695 p
->next
= pending_list
[f_idx
];
696 pending_list
[f_idx
] = p
;
698 sh
->reserved
= 1; /* for quick check */
701 /* Throw away undef entries when done with file index F_IDX */
706 register struct pending
*p
, *q
;
708 for (p
= pending_list
[f_idx
]; p
; p
= q
) {
712 pending_list
[f_idx
] = 0;
715 /* The number of args to a procedure is not explicit in the symtab,
716 this is the list of all those we know of.
717 This makes parsing more reasonable and avoids extra passes */
719 static struct numarg
{
720 struct numarg
*next
; /* link */
721 unsigned adr
; /* procedure's start address */
722 unsigned num
; /* arg count */
725 /* Record that the procedure at ADR takes NUM arguments. */
730 struct numarg
*n
= (struct numarg
*) xmalloc(sizeof(struct numarg
));
734 n
->next
= numargs_list
;
738 /* See if we know how many arguments the procedure at ADR takes */
743 struct numarg
*n
= numargs_list
;
745 while (n
&& n
->adr
!= adr
)
747 return (n
) ? n
->num
: -1;
750 /* Release storage when done with this file */
755 struct numarg
*n
= numargs_list
, *m
;
766 /* Parsing Routines proper. */
768 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
769 For blocks, procedures and types we open a new lexical context.
770 This is basically just a big switch on the symbol's type */
781 /* When a symbol is cross-referenced from other files/symbols
782 we mark it explicitly */
783 int pend
= (sh
->reserved
== 1);
784 enum address_class
class;
791 case stGlobal
: /* external symbol, goes into global block */
793 b
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
795 s
= new_symbol(sh
->iss
);
796 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
799 case stStatic
: /* static data, goes into current block. */
801 b
= top_stack
->cur_block
;
802 s
= new_symbol(sh
->iss
);
803 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
806 case stLocal
: /* local variable, goes into current block */
807 if (sh
->sc
== scRegister
) {
808 class = LOC_REGISTER
;
813 b
= top_stack
->cur_block
;
814 s
= new_symbol(sh
->iss
);
815 SYMBOL_VALUE(s
) = sh
->value
;
817 data
: /* Common code for symbols describing data */
818 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
819 SYMBOL_CLASS(s
) = class;
822 /* Type could be missing in a number of cases */
823 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
||
824 sh
->index
== 0xfffff)
825 SYMBOL_TYPE(s
) = builtin_type_int
; /* undefined? */
827 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, sh
, 0);
828 /* Value of a data symbol is its memory address */
831 case stParam
: /* arg to procedure, goes into current block */
833 top_stack
->numargs
++;
834 s
= new_symbol(sh
->iss
);
835 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
836 if (sh
->sc
== scRegister
) {
837 SYMBOL_CLASS(s
) = LOC_REGPARM
;
841 SYMBOL_CLASS(s
) = LOC_ARG
;
842 SYMBOL_VALUE(s
) = sh
->value
;
843 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, sh
, 0);
844 add_symbol(s
, top_stack
->cur_block
);
846 /* FIXME: This has not been tested. See dbxread.c */
847 /* Add the type of this parameter to the function/procedure
848 type of this block. */
849 add_param_to_type(&top_stack
->cur_block
->function
->type
,s
);
853 case stLabel
: /* label, goes into current block */
854 s
= new_symbol(sh
->iss
);
855 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
; /* so that it can be used */
856 SYMBOL_CLASS(s
) = LOC_LABEL
; /* but not misused */
857 SYMBOL_VALUE_ADDRESS(s
) = (CORE_ADDR
)sh
->value
;
858 SYMBOL_TYPE(s
) = builtin_type_int
;
859 add_symbol(s
, top_stack
->cur_block
);
862 case stProc
: /* Procedure, usually goes into global block */
863 case stStaticProc
: /* Static procedure, goes into current block */
864 s
= new_symbol(sh
->iss
);
865 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
866 SYMBOL_CLASS(s
) = LOC_BLOCK
;
867 /* Type of the return value */
868 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
869 t
= builtin_type_int
;
871 t
= parse_type(ax
+ sh
->index
, sh
, 0);
872 b
= top_stack
->cur_block
;
873 if (sh
->st
== stProc
) {
874 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
875 /* The next test should normally be true,
876 but provides a hook for nested functions
877 (which we don't want to make global). */
878 if (b
== BLOCKVECTOR_BLOCK(bv
, STATIC_BLOCK
))
879 b
= BLOCKVECTOR_BLOCK(bv
, GLOBAL_BLOCK
);
883 /* Make a type for the procedure itself */
885 /* FIXME: This has not been tested yet! See dbxread.c */
886 /* Generate a template for the type of this function. The
887 types of the arguments will be added as we read the symbol
889 bcopy(SYMBOL_TYPE(s
),lookup_function_type(t
),sizeof(struct type
));
891 SYMBOL_TYPE(s
) = lookup_function_type (t
);
894 /* Create and enter a new lexical context */
895 b
= new_block(top_stack
->maxsyms
);
896 SYMBOL_BLOCK_VALUE(s
) = b
;
897 BLOCK_FUNCTION(b
) = s
;
898 BLOCK_START(b
) = BLOCK_END(b
) = sh
->value
;
899 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
900 add_block(b
, top_stack
->cur_st
);
902 /* Not if we only have partial info */
903 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
)
907 top_stack
->cur_block
= b
;
908 top_stack
->blocktype
= sh
->st
;
909 top_stack
->cur_type
= SYMBOL_TYPE(s
);
910 top_stack
->procadr
= sh
->value
;
911 top_stack
->numargs
= 0;
913 sh
->value
= (long) SYMBOL_TYPE(s
);
916 case stBlock
: /* Either a lexical block, or some type */
918 top_stack
->blocktype
= stBlock
;
919 if (sh
->sc
== scInfo
) { /* structure/union/enum def */
920 s
= new_symbol(sh
->iss
);
921 SYMBOL_NAMESPACE(s
) = STRUCT_NAMESPACE
;
922 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
924 add_symbol(s
, top_stack
->cur_block
);
925 /* If this type was expected, use its partial definition */
927 t
= is_pending_symbol(cur_fdr
, sh
)->t
;
929 /* Uhmm, can`t decide yet. Smash later */
930 t
= new_type(sh
->iss
);
931 TYPE_CODE(t
) = TYPE_CODE_UNDEF
;
932 add_pending(cur_fdr
, sh
, t
);
935 /* make this the current type */
936 top_stack
->cur_type
= t
;
937 TYPE_LENGTH(t
) = sh
->value
;
938 /* Mark that symbol has a type, and say which one */
939 sh
->value
= (long) t
;
941 /* beginnning of (code) block. Value of symbol
942 is the displacement from procedure start */
943 b
= new_block(top_stack
->maxsyms
);
944 BLOCK_START(b
) = sh
->value
+ top_stack
->procadr
;
945 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
946 top_stack
->cur_block
= b
;
947 add_block(b
, top_stack
->cur_st
);
951 case stEnd
: /* end (of anything) */
952 if (sh
->sc
== scInfo
) {
953 /* Finished with type */
954 top_stack
->cur_type
= 0;
955 } else if (sh
->sc
== scText
&&
956 (top_stack
->blocktype
== stProc
||
957 top_stack
->blocktype
== stStaticProc
)) {
958 /* Finished with procedure */
959 struct blockvector
*bv
= BLOCKVECTOR(top_stack
->cur_st
);
963 BLOCK_END(top_stack
->cur_block
) += sh
->value
; /* size */
964 got_numargs(top_stack
->procadr
, top_stack
->numargs
);
965 /* Reallocate symbols, saving memory */
966 b
= shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
968 /* f77 emits proc-level with address bounds==[0,0],
969 So look for such child blocks, and patch them. */
970 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++) {
971 struct block
*b_bad
= BLOCKVECTOR_BLOCK(bv
,i
);
972 if (BLOCK_SUPERBLOCK(b_bad
) == b
973 && BLOCK_START(b_bad
) == top_stack
->procadr
974 && BLOCK_END(b_bad
) == top_stack
->procadr
) {
975 BLOCK_START(b_bad
) = BLOCK_START(b
);
976 BLOCK_END(b_bad
) = BLOCK_END(b
);
979 if (entry_point
< BLOCK_END(b
)
980 && entry_point
>= BLOCK_START(b
)) {
981 startup_file_start
= BLOCK_START(b
);
982 startup_file_end
= BLOCK_END(b
);
984 } else if (sh
->sc
== scText
&& top_stack
->blocktype
== stBlock
) {
985 /* End of (code) block. The value of the symbol
986 is the displacement from the procedure`s start
987 address of the end of this block. */
988 BLOCK_END(top_stack
->cur_block
) = sh
->value
+ top_stack
->procadr
;
989 (void) shrink_block(top_stack
->cur_block
, top_stack
->cur_st
);
991 pop_parse_stack(); /* restore previous lexical context */
994 case stMember
: /* member of struct/union/enum.. */
995 f
= new_field(top_stack
->cur_type
, sh
->iss
);
996 f
->bitpos
= sh
->value
;
997 f
->type
= parse_type(ax
+ sh
->index
, sh
, &f
->bitsize
);
1000 case stTypedef
: /* type definition */
1001 s
= new_symbol(sh
->iss
);
1002 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1003 SYMBOL_CLASS(s
) = LOC_TYPEDEF
;
1004 SYMBOL_BLOCK_VALUE(s
) = top_stack
->cur_block
;
1005 add_symbol(s
, top_stack
->cur_block
);
1006 SYMBOL_TYPE(s
) = parse_type(ax
+ sh
->index
, sh
, 0);
1007 sh
->value
= (long) SYMBOL_TYPE(s
);
1010 case stFile
: /* file name */
1012 top_stack
->blocktype
= sh
->st
;
1015 /* I`ve never seen these for C */
1017 break; /* register relocation */
1019 break; /* forwarding address */
1021 break; /* constant */
1023 error("Unknown symbol type %x.", sh
->st
);
1028 /* Parse the type information provided in the AX entries for
1029 the symbol SH. Return the bitfield size in BS, in case. */
1031 static struct type
*parse_type(ax
, sh
, bs
)
1036 /* Null entries in this map are treated specially */
1037 static struct type
**map_bt
[] =
1039 &builtin_type_void
, /* btNil */
1041 &builtin_type_char
, /* btChar */
1042 &builtin_type_unsigned_char
, /* btUChar */
1043 &builtin_type_short
, /* btShort */
1044 &builtin_type_unsigned_short
, /* btUShort */
1045 &builtin_type_int
, /* btInt */
1046 &builtin_type_unsigned_int
, /* btUInt */
1047 &builtin_type_long
, /* btLong */
1048 &builtin_type_unsigned_long
, /* btULong */
1049 &builtin_type_float
, /* btFloat */
1050 &builtin_type_double
, /* btDouble */
1057 &builtin_type_complex
, /* btComplex */
1058 &builtin_type_double_complex
, /* btDComplex */
1060 &builtin_type_fixed_dec
, /* btFixedDec */
1061 &builtin_type_float_dec
, /* btFloatDec */
1062 &builtin_type_string
, /* btString */
1065 &builtin_type_void
, /* btVoid */
1069 struct type
*tp
= 0, *tp1
;
1072 /* Procedures start off by one */
1073 if (sh
->st
== stProc
|| sh
->st
== stStaticProc
)
1076 /* Undefined ? Should not happen */
1077 if (ax
->rndx
.rfd
== 0xfff) {
1078 return builtin_type_void
;
1081 /* Use aux as a type information record, map its basic type */
1083 if (t
->bt
> 26 || t
->bt
== btPicture
) {
1084 complain (&basic_type_complaint
, t
->bt
);
1085 return builtin_type_int
;
1088 tp
= *map_bt
[t
->bt
];
1090 /* Cannot use builtin types, use templates */
1091 tp
= make_type(TYPE_CODE_VOID
, 0, 0, 0);
1094 *tp
= *builtin_type_ptr
;
1097 *tp
= *builtin_type_struct
;
1101 *tp
= *builtin_type_union
;
1105 *tp
= *builtin_type_enum
;
1109 *tp
= *builtin_type_range
;
1112 *tp
= *builtin_type_set
;
1118 /* Move on to next aux */
1121 /* This is the way it would work if the compiler worked */
1122 register TIR
*t1
= t
;
1123 while (t1
->continued
)
1127 /* For bitfields all we need is the width */
1133 /* All these types really point to some (common) MIPS type
1134 definition, and only the type-qualifiers fully identify
1135 them. We`ll make the same effort at sharing */
1136 if (t
->bt
== btIndirect
||
1137 t
->bt
== btStruct
||
1140 t
->bt
== btTypedef
||
1143 char name
[256], *pn
;
1145 /* Try to cross reference this type */
1147 ax
+= cross_ref(ax
, &tp1
, &pn
);
1148 /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */
1149 sprintf(name
, fmt
, pn
);
1151 /* reading .o file ? */
1152 if (UNSAFE_DATA_ADDR(tp1
))
1154 if (TYPE_CODE(tp1
) == TYPE_CODE_UNDEF
) {
1156 * Type was incompletely defined, now we know.
1158 TYPE_CODE(tp1
) = TYPE_CODE(tp
);
1159 TYPE_NAME(tp1
) = obsavestring(name
, strlen(name
));
1160 if (TYPE_CODE(tp1
) == TYPE_CODE_ENUM
) {
1163 for (i
= 0; i
< TYPE_NFIELDS(tp1
); i
++)
1164 make_enum_constant(&TYPE_FIELD(tp1
,i
), tp1
);
1168 /* found as cross ref, rid of our template */
1169 if ((TYPE_FLAGS(tp
) & TYPE_FLAG_PERM
) == 0)
1172 /* stupid idea of prepending "struct" to type names */
1173 if (t
->bt
== btStruct
&& !index(TYPE_NAME(tp
), ' ')) {
1174 sprintf(name
, fmt
, TYPE_NAME(tp
));
1175 TYPE_NAME(tp
) = obsavestring(name
, strlen(name
));
1178 TYPE_NAME(tp
) = savestring(name
, strlen(name
));
1181 /* Deal with range types */
1182 if (t
->bt
== btRange
) {
1185 f
= new_field(tp
, "Low");
1186 f
->bitpos
= ax
->dnLow
;
1188 f
= new_field(tp
, "High");
1189 f
->bitpos
= ax
->dnHigh
;
1193 /* Parse all the type qualifiers now. If there are more
1194 than 6 the game will continue in the next aux */
1196 #define PARSE_TQ(tq) \
1197 if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, sh);
1199 again
: PARSE_TQ(tq0
);
1214 /* Make up a complex type from a basic one. Type is passed by
1215 reference in TPP and side-effected as necessary. The type
1216 qualifier TQ says how to handle the aux symbols at AX for
1217 the symbol SX we are currently analyzing.
1218 Returns the number of aux symbols we parsed. */
1221 upgrade_type(tpp
, tq
, ax
, sh
)
1229 /* Used in array processing */
1238 t
= lookup_pointer_type (*tpp
);
1243 t
= lookup_function_type (*tpp
);
1249 t
= make_type(TYPE_CODE_ARRAY
, 0, 0, 0);
1250 TYPE_TARGET_TYPE(t
) = *tpp
;
1252 /* Determine and record the domain type (type of index) */
1253 id
= ax
->rndx
.index
;
1259 fh
= get_rfd(cur_fd
, rf
);
1260 f
= new_field(t
, (char *)0);
1261 bzero(&ss
, sizeof ss
);
1262 /* XXX */ f
->type
= parse_type(fh
->iauxBase
+ id
* sizeof(AUXU
),
1267 * This seems to be a pointer to the end of the Block defining
1268 * the type. Why it is here is magic for me, and I have no
1269 * good use for it anyways.
1271 /* This used to occur because cross_ref returned
1272 the wrong result (ax pointed wrong). FIXME,
1273 delete this code in a while. -- gnu@cygnus jul91 */
1274 complain (&array_parse_complaint
, 0);
1276 id
= (++ax
)->rndx
.index
;
1277 if ((rf
= ax
->rndx
.rfd
) == 0xfff)
1278 rf
= (++ax
)->isym
, off
++;
1280 lower
= (++ax
)->dnLow
;
1281 upper
= (++ax
)->dnHigh
;
1282 rf
= (++ax
)->width
; /* bit size of array element */
1284 /* Check whether supplied array element bit size matches
1285 the known size of the element type. If this complaint
1286 ends up not happening, we can remove this code. It's
1287 here because we aren't sure we understand this *&%&$
1289 id
= TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) << 3; /* bitsize */
1291 /* Most likely an undefined type */
1293 TYPE_LENGTH(TYPE_TARGET_TYPE(t
)) = id
>> 3;
1296 complain (&array_bitsize_complaint
, rf
);
1298 TYPE_LENGTH(t
) = (upper
< 0) ? 0 :
1299 (upper
- lower
+ 1) * (rf
>> 3);
1304 /* Volatile -- currently ignored */
1308 complain (&unknown_type_qual_complaint
, tq
);
1314 /* Parse a procedure descriptor record PR. Note that the procedure
1315 is parsed _after_ the local symbols, now we just make up the
1316 extra information we need into a special symbol that we insert
1317 in the procedure's main block. Note also that images that
1318 have been partially stripped (ld -x) have been deprived
1319 of local symbols, and we have to cope with them here.
1320 The procedure's code ends at BOUND */
1323 parse_procedure(pr
, bound
)
1326 struct symbol
*s
, *i
;
1327 SYMR
*sh
= (SYMR
*)pr
->isym
;
1329 struct mips_extra_func_info
*e
;
1333 /* Reuse the MIPS record */
1334 e
= (struct mips_extra_func_info
*) pr
;
1335 e
->numargs
= lookup_numargs(pr
->adr
);
1337 /* Make up our special symbol */
1338 i
= new_symbol(".gdbinfo.");
1339 SYMBOL_VALUE(i
) = (int)e
;
1340 SYMBOL_NAMESPACE(i
) = LABEL_NAMESPACE
;
1341 SYMBOL_CLASS(i
) = LOC_CONST
;
1342 SYMBOL_TYPE(i
) = builtin_type_void
;
1344 /* Make up a name for static procedures. Sigh. */
1345 if (sh
== (SYMR
*)-1) {
1346 sprintf(name
,".static_procedure@%x",pr
->adr
);
1347 sh_name
= savestring(name
, strlen(name
));
1351 sh_name
= (char*)sh
->iss
;
1352 s
= mylookup_symbol(sh_name
, top_stack
->cur_block
,
1353 VAR_NAMESPACE
, LOC_BLOCK
);
1356 b
= SYMBOL_BLOCK_VALUE(s
);
1358 s
= new_symbol(sh_name
);
1359 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
1360 SYMBOL_CLASS(s
) = LOC_BLOCK
;
1361 /* Donno its type, hope int is ok */
1362 SYMBOL_TYPE(s
) = lookup_function_type (builtin_type_int
);
1363 add_symbol(s
, top_stack
->cur_block
);
1364 /* Wont have symbols for this one */
1366 SYMBOL_BLOCK_VALUE(s
) = b
;
1367 BLOCK_FUNCTION(b
) = s
;
1368 BLOCK_START(b
) = pr
->adr
;
1369 BLOCK_END(b
) = bound
;
1370 BLOCK_SUPERBLOCK(b
) = top_stack
->cur_block
;
1371 add_block(b
, top_stack
->cur_st
);
1377 /* Parse the external symbol ES. Just call parse_symbol() after
1378 making sure we know where the aux are for it. For procedures,
1379 parsing of the PDRs has already provided all the needed
1380 information, we only parse them if SKIP_PROCEDURES is false,
1381 and only if this causes no symbol duplication.
1383 This routine clobbers top_stack->cur_block and ->cur_st. */
1386 parse_external(es
, skip_procedures
)
1391 if (es
->ifd
!= ifdNil
) {
1393 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
) + cur_fd
;
1394 ax
= (AUXU
*)cur_fdr
->iauxBase
;
1396 cur_fdr
= (FDR
*)(cur_hdr
->cbFdOffset
);
1399 top_stack
->cur_st
= cur_stab
;
1400 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(top_stack
->cur_st
),
1403 /* Reading .o files */
1404 if (es
->asym
.sc
== scUndefined
|| es
->asym
.sc
== scNil
) {
1406 switch (es
->asym
.st
) {
1408 case stProc
: what
= "procedure"; n_undef_procs
++; break;
1409 case stGlobal
: what
= "variable"; n_undef_vars
++; break;
1410 case stLabel
: what
= "label"; n_undef_labels
++; break;
1411 default : what
= "symbol"; break;
1415 printf_filtered("Warning: %s `%s' is undefined (in %s)\n", what
,
1416 es
->asym
.iss
, fdr_name(cur_fdr
->rss
));
1420 switch (es
->asym
.st
) {
1422 /* If we have full symbols we do not need more */
1423 if (skip_procedures
)
1425 if (mylookup_symbol (es
->asym
.iss
, top_stack
->cur_block
,
1426 VAR_NAMESPACE
, LOC_BLOCK
))
1432 * Note that the case of a symbol with indexNil
1433 * must be handled anyways by parse_symbol().
1435 parse_symbol(&es
->asym
, ax
);
1442 /* Parse the line number info for file descriptor FH into
1443 GDB's linetable LT. MIPS' encoding requires a little bit
1444 of magic to get things out. Note also that MIPS' line
1445 numbers can go back and forth, apparently we can live
1446 with that and do not need to reorder our linetables */
1451 struct linetable
*lt
;
1453 unsigned char *base
= (unsigned char*)fh
->cbLineOffset
;
1455 int delta
, count
, lineno
= 0;
1461 /* Scan by procedure descriptors */
1462 i
= 0; j
= 0, k
= 0;
1463 for (pr
= (PDR
*)IPDFIRST(cur_hdr
,fh
); j
< fh
->cpd
; j
++, pr
++) {
1466 /* No code for this one */
1467 if (pr
->iline
== ilineNil
||
1468 pr
->lnLow
== -1 || pr
->lnHigh
== -1)
1471 * Aurgh! To know where to stop expanding we
1474 for (l
= 1; l
< (fh
->cpd
- j
); l
++)
1475 if (pr
[l
].iline
!= -1)
1477 if (l
== (fh
->cpd
- j
))
1482 * When procedures are moved around the linenumbers
1483 * are attributed to the next procedure up
1485 if (pr
->iline
>= halt
) continue;
1487 base
= (unsigned char*)pr
->cbLineOffset
;
1488 l
= pr
->adr
>> 2; /* in words */
1489 halt
+= (pr
->adr
>> 2) - pr
->iline
;
1490 for (lineno
= pr
->lnLow
; l
< halt
;) {
1491 count
= *base
& 0x0f;
1492 delta
= *base
++ >> 4;
1496 delta
= (base
[0] << 8) | base
[1];
1499 lineno
+= delta
;/* first delta is 0 */
1500 k
= add_line(lt
, lineno
, l
, k
);
1507 /* Parse the symbols of the file described by FH, whose index is F_IDX.
1508 BOUND is the highest core address of this file's procedures */
1511 parse_one_file(fh
, f_idx
, bound
)
1518 /* Parse local symbols first */
1520 for (s_idx
= 0; s_idx
< fh
->csym
; s_idx
++) {
1521 sh
= (SYMR
*) (fh
->isymBase
) + s_idx
;
1523 parse_symbol(sh
, fh
->iauxBase
);
1526 /* Procedures next, note we need to look-ahead to
1527 find out where the procedure's code ends */
1529 for (s_idx
= 0; s_idx
< fh
->cpd
-1; s_idx
++) {
1530 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + s_idx
;
1531 parse_procedure(pr
, pr
[1].adr
); /* next proc up */
1534 pr
= (PDR
*) (IPDFIRST(cur_hdr
, fh
)) + s_idx
;
1535 parse_procedure(pr
, bound
); /* next file up */
1538 /* Linenumbers. At the end, check if we can save memory */
1539 parse_lines(fh
, LINETABLE(cur_stab
));
1540 if (LINETABLE(cur_stab
)->nitems
< fh
->cline
)
1541 shrink_linetable(cur_stab
);
1544 /* Master parsing procedure for first-pass reading of file symbols
1545 into a partial_symtab.
1547 Parses the symtab described by the global symbolic header CUR_HDR.
1548 END_OF_TEXT_SEG gives the address just after the text segment for
1549 the symtab we are reading. */
1552 parse_partial_symbols(end_of_text_seg
)
1553 int end_of_text_seg
;
1555 int f_idx
, s_idx
, h_max
, stat_idx
;
1556 CORE_ADDR dummy
, *prevhigh
;
1558 /* Running pointers */
1563 struct partial_symtab
*pst
;
1568 * Only parse the Local and External symbols, and the Relative FDR.
1569 * Fixup enough of the loader symtab to be able to use it.
1570 * Allocate space only for the file's portions we need to
1576 max_glevel
= MIN_GLEVEL
;
1578 /* Allocate the map FDR -> PST.
1579 Minor hack: -O3 images might claim some global data belongs
1580 to FDR -1. We`ll go along with that */
1581 fdr_to_pst
= (struct pst_map
*)xzalloc((hdr
->ifdMax
+1) * sizeof *fdr_to_pst
);
1584 struct partial_symtab
* pst
= new_psymtab("");
1585 fdr_to_pst
[-1].pst
= pst
;
1589 /* Now scan the FDRs, mostly for dependencies */
1590 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++)
1591 (void) parse_fdr(f_idx
, 1);
1593 /* Take a good guess at how many symbols we might ever need */
1594 h_max
= hdr
->iextMax
;
1596 /* Parse externals: two passes because they can be ordered
1597 in any way, but gdb likes to have them segregated by their
1600 /* Pass 1 over external syms: Presize and partition the list */
1601 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1602 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1603 fdr_to_pst
[esh
->ifd
].n_globals
++;
1606 if (global_psymbols
.list
) {
1607 int origsize
= global_psymbols
.next
- global_psymbols
.list
;
1609 global_psymbols
.list
= (struct partial_symbol
*)
1610 xrealloc (global_psymbols
.list
,
1611 (h_max
+ origsize
) * sizeof(struct partial_symbol
));
1612 global_psymbols
.next
= global_psymbols
.list
+ origsize
;
1613 global_psymbols
.size
= h_max
+ origsize
;
1615 global_psymbols
.list
= (struct partial_symbol
*)
1616 xmalloc (h_max
* sizeof(struct partial_symbol
));
1617 global_psymbols
.next
= global_psymbols
.list
;
1618 global_psymbols
.size
= h_max
;
1621 /* Pass 1.5 over files: partition out global symbol space */
1622 s_idx
= global_psymbols
.next
- global_psymbols
.list
;
1623 for (f_idx
= -1; f_idx
< hdr
->ifdMax
; f_idx
++) {
1624 fdr_to_pst
[f_idx
].pst
->globals_offset
= s_idx
;
1625 s_idx
+= fdr_to_pst
[f_idx
].n_globals
;
1628 /* Pass 1.6 over files: partition out static symbol space.
1629 Note that this loop starts at 0, not at -1. */
1630 stat_idx
= static_psymbols
.next
- static_psymbols
.list
;
1631 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
1632 fdr_to_pst
[f_idx
].pst
->statics_offset
= stat_idx
;
1633 fh
= f_idx
+ (FDR
*)(hdr
->cbFdOffset
);
1634 stat_idx
+= fh
->csym
;
1637 /* Now that we know its max size, allocate static symbol list */
1638 if (static_psymbols
.list
) {
1639 int origsize
= static_psymbols
.next
- static_psymbols
.list
;
1641 static_psymbols
.list
= (struct partial_symbol
*)
1642 xrealloc (static_psymbols
.list
,
1643 stat_idx
* sizeof(struct partial_symbol
));
1644 static_psymbols
.next
= static_psymbols
.list
+ origsize
;
1645 static_psymbols
.size
= stat_idx
;
1647 static_psymbols
.list
= (struct partial_symbol
*)
1648 xmalloc (stat_idx
* sizeof(struct partial_symbol
));
1649 static_psymbols
.next
= static_psymbols
.list
;
1650 static_psymbols
.size
= stat_idx
;
1653 /* Pass 2 over external syms: fill in external symbols */
1654 for (s_idx
= 0; s_idx
< hdr
->iextMax
; s_idx
++) {
1655 register struct partial_symbol
*p
;
1656 enum misc_function_type misc_type
= mf_text
;
1657 esh
= (EXTR
*) (hdr
->cbExtOffset
) + s_idx
;
1659 if (esh
->asym
.sc
== scUndefined
|| esh
->asym
.sc
== scNil
)
1662 /* Locate the psymtab and the preallocated psymbol. */
1663 pst
= fdr_to_pst
[esh
->ifd
].pst
;
1664 p
= global_psymbols
.list
+ pst
->globals_offset
+
1665 pst
->n_global_syms
++;
1666 SYMBOL_NAME(p
) = (char *)(esh
->asym
.iss
);
1667 SYMBOL_NAMESPACE(p
) = VAR_NAMESPACE
;
1669 switch (esh
->asym
.st
) {
1671 SYMBOL_CLASS(p
) = LOC_BLOCK
;
1672 SYMBOL_VALUE(p
) = esh
->asym
.value
;
1675 SYMBOL_CLASS(p
) = LOC_STATIC
;
1676 SYMBOL_VALUE_ADDRESS(p
) = (CORE_ADDR
)esh
->asym
.value
;
1677 misc_type
= mf_data
;
1680 SYMBOL_CLASS(p
) = LOC_LABEL
;
1681 SYMBOL_VALUE_ADDRESS(p
) = (CORE_ADDR
)esh
->asym
.value
;
1684 misc_type
= mf_unknown
;
1685 complain (&unknown_ext_complaint
, SYMBOL_NAME(p
));
1687 prim_record_misc_function (SYMBOL_NAME(p
),
1692 /* Pass 3 over files, over local syms: fill in static symbols */
1693 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
1694 fh
= f_idx
+ (FDR
*)(cur_hdr
->cbFdOffset
);
1695 pst
= fdr_to_pst
[f_idx
].pst
;
1697 for (s_idx
= 0; s_idx
< fh
->csym
; ) {
1698 register struct partial_symbol
*p
;
1700 sh
= s_idx
+ (SYMR
*) fh
->isymBase
;
1702 if (sh
->sc
== scUndefined
|| sh
->sc
== scNil
) {
1703 /* FIXME, premature? */
1708 /* Locate the preallocated psymbol. */
1709 p
= static_psymbols
.list
+ pst
->statics_offset
+
1711 SYMBOL_NAME(p
) = (char *)(sh
->iss
);
1712 SYMBOL_VALUE(p
) = sh
->value
;
1713 SYMBOL_NAMESPACE(p
) = VAR_NAMESPACE
;
1716 case stProc
: /* Asm labels apparently */
1717 case stStaticProc
: /* Function */
1718 SYMBOL_CLASS(p
) = LOC_BLOCK
;
1719 pst
->n_static_syms
++; /* Use gdb symbol */
1720 /* Skip over procedure to next one. */
1721 s_idx
= (sh
->index
+ (AUXU
*)fh
->iauxBase
)
1724 case stStatic
: /* Variable */
1725 SYMBOL_CLASS(p
) = LOC_STATIC
;
1726 SYMBOL_VALUE_ADDRESS(p
) = (CORE_ADDR
)sh
->value
;
1728 case stTypedef
: /* Typedef */
1729 SYMBOL_CLASS(p
) = LOC_TYPEDEF
;
1731 case stConstant
: /* Constant decl */
1732 SYMBOL_CLASS(p
) = LOC_CONST
;
1734 case stBlock
: /* { }, str, un, enum */
1735 /* Eventually we want struct names and enum
1736 values out of here. FIXME */
1737 /* Skip over the block */
1740 case stFile
: /* File headers */
1741 case stLabel
: /* Labels */
1742 case stEnd
: /* Ends of files */
1745 complain (&unknown_sym_complaint
, SYMBOL_NAME(p
));
1746 complain (&unknown_st_complaint
, sh
->st
);
1750 pst
->n_static_syms
++; /* Use this gdb symbol */
1752 s_idx
++; /* Go to next file symbol */
1754 /* We don't usually record static syms, but some we seem to. chk dbxread. */
1755 /*FIXME*/ prim_record_misc_function (SYMBOL_NAME(p
),
1762 /* The array (of lists) of globals must be sorted.
1763 Take care, since we are at it, of pst->texthigh.
1765 NOTE: The way we handle textlow/high is incorrect, but good
1766 enough for a first approximation. The case we fail is on a
1767 file "foo.c" that looks like
1769 #include "bar.c" -- this contains proc2()
1771 where proc3() is attributed to bar.c. But since this is a
1772 dependent file it will cause loading of foo.c as well, so
1773 everything will be fine at the end. */
1775 /* First, sort the psymtabs by their textlow addresses. */
1778 /* Now, rip through and fill in "texthigh" from the textlow
1779 of the following psymtab. Slimy but it might work.
1780 Sort the global psymbols while we're at it. */
1782 for (f_idx
= 0; f_idx
< hdr
->ifdMax
; f_idx
++) {
1783 struct partial_symtab
*pst
= fdr_to_pst
[f_idx
].pst
;
1784 if (pst
->n_global_syms
> 1)
1785 qsort (global_psymbols
.list
+ pst
->globals_offset
,
1786 pst
->n_global_syms
, sizeof (struct partial_symbol
),
1789 *prevhigh
= pst
->textlow
;
1790 prevhigh
= &pst
->texthigh
;
1794 /* Mark the last code address, and remember it for later */
1795 *prevhigh
= end_of_text_seg
;
1796 hdr
->cbDnOffset
= end_of_text_seg
;
1798 free(&fdr_to_pst
[-1]);
1803 /* Do the initial analisys of the F_IDX-th file descriptor.
1804 Allocates a partial symtab for it, and builds the list
1805 of dependent files by recursion. LEV says at which level
1806 of recursion we are called (to pretty up debug traces) */
1808 static struct partial_symtab
*
1809 parse_fdr(f_idx
, lev
)
1813 register struct partial_symtab
*pst
;
1816 fh
= (FDR
*) (cur_hdr
->cbFdOffset
) + f_idx
;
1818 /* Use this to indicate into which symtab this file was parsed */
1820 return (struct partial_symtab
*) fh
->ioptBase
;
1822 /* Debuggability level */
1823 if (compare_glevel(max_glevel
, fh
->glevel
) < 0)
1824 max_glevel
= fh
->glevel
;
1826 /* Make a new partial_symtab */
1827 pst
= new_psymtab(fh
->rss
);
1832 pst
->textlow
= fh
->adr
;
1833 pst
->texthigh
= fh
->cpd
; /* To be fixed later */
1836 /* Make everything point to everything. */
1837 pst
->ldsymoff
= f_idx
;
1838 fdr_to_pst
[f_idx
].pst
= pst
;
1839 fh
->ioptBase
= (int)pst
;
1841 /* Analyze its dependencies */
1846 if (fh
->cpd
== 0) { /* If there are no functions defined here ... */
1847 /* ...then presumably a .h file: drop reverse depends .h->.c */
1848 for (; s_id0
< fh
->crfd
; s_id0
++) {
1849 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_id0
;
1851 s_id0
++; /* Skip self-dependency */
1856 pst
->number_of_dependencies
= fh
->crfd
- s_id0
;
1857 pst
->dependencies
= (struct partial_symtab
**)
1858 obstack_alloc (psymbol_obstack
,
1859 pst
->number_of_dependencies
*
1860 sizeof (struct partial_symtab
*));
1861 for (s_idx
= s_id0
; s_idx
< fh
->crfd
; s_idx
++) {
1862 RFDT
*rh
= (RFDT
*) (fh
->rfdBase
) + s_idx
;
1864 pst
->dependencies
[s_idx
-s_id0
] = parse_fdr(*rh
, lev
+1);
1871 /* Ancillary function to psymtab_to_symtab(). Does all the work
1872 for turning the partial symtab PST into a symtab, recurring
1873 first on all dependent psymtabs. The argument FILENAME is
1874 only passed so we can see in debug stack traces what file
1878 psymtab_to_symtab_1(pst
, filename
)
1879 struct partial_symtab
*pst
;
1890 pending_list
= (struct pending
**) cur_hdr
->cbOptOffset
;
1891 if (pending_list
== 0) {
1892 pending_list
= (struct pending
**)
1893 xzalloc(cur_hdr
->ifdMax
* sizeof(struct pending
*));
1894 cur_hdr
->cbOptOffset
= (int)pending_list
;
1897 /* How many symbols will we need */
1898 /* FIXME, this does not count enum values. */
1899 f_max
= pst
->n_global_syms
+ pst
->n_static_syms
;
1900 if (pst
->ldsymoff
== -1) {
1902 st
= new_symtab( "unknown", f_max
, 0);
1904 fh
= (FDR
*) (cur_hdr
->cbFdOffset
) + pst
->ldsymoff
;
1905 f_max
+= fh
->csym
+ fh
->cpd
;
1906 st
= new_symtab(pst
->filename
, 2 * f_max
, 2 * fh
->cline
);
1909 /* Read in all partial symbtabs on which this one is dependent.
1910 NOTE that we do have circular dependencies, sigh. We solved
1911 that by setting pst->readin before this point. */
1913 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1914 if (!pst
->dependencies
[i
]->readin
) {
1915 /* Inform about additional files to be read in. */
1918 fputs_filtered (" ", stdout
);
1920 fputs_filtered ("and ", stdout
);
1922 printf_filtered ("%s...",
1923 pst
->dependencies
[i
]->filename
);
1924 wrap_here (""); /* Flush output */
1927 /* We only pass the filename for debug purposes */
1928 psymtab_to_symtab_1(pst
->dependencies
[i
],
1929 pst
->dependencies
[i
]->filename
);
1932 /* Now read the symbols for this symtab */
1934 cur_fd
= pst
->ldsymoff
;
1938 /* Get a new lexical context */
1941 top_stack
->cur_st
= cur_stab
;
1942 top_stack
->cur_block
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(cur_stab
),
1944 BLOCK_START(top_stack
->cur_block
) = fh
? fh
->adr
: 0;
1945 BLOCK_END(top_stack
->cur_block
) = 0;
1946 top_stack
->blocktype
= stFile
;
1947 top_stack
->maxsyms
= 2*f_max
;
1948 top_stack
->cur_type
= 0;
1949 top_stack
->procadr
= 0;
1950 top_stack
->numargs
= 0;
1952 /* Parse locals and procedures */
1954 parse_one_file(fh
, cur_fd
, (cur_fd
== (cur_hdr
->ifdMax
- 1)) ?
1955 cur_hdr
->cbDnOffset
: fh
[1].adr
);
1957 /* .. and our share of externals.
1958 XXX use the global list to speed up things here. how ?
1959 FIXME, Maybe quit once we have found the right number of ext's? */
1960 /* parse_external clobbers top_stack->cur_block and ->cur_st here. */
1961 top_stack
->blocktype
= stFile
;
1962 top_stack
->maxsyms
= cur_hdr
->isymMax
+ cur_hdr
->ipdMax
+ cur_hdr
->iextMax
;
1963 for (i
= 0; i
< cur_hdr
->iextMax
; i
++) {
1964 register EXTR
*esh
= (EXTR
*) (cur_hdr
->cbExtOffset
) + i
;
1965 if (esh
->ifd
== cur_fd
)
1966 parse_external(esh
, 1);
1969 /* If there are undefined, tell the user */
1970 if (n_undef_symbols
) {
1971 printf_filtered("File %s contains %d unresolved references:",
1972 st
->filename
, n_undef_symbols
);
1973 printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
1974 n_undef_vars
, n_undef_procs
, n_undef_labels
);
1975 n_undef_symbols
= n_undef_labels
= n_undef_vars
= n_undef_procs
= 0;
1981 * Sort the symbol table now, we are done adding symbols to it.
1983 sort_symtab_syms(st
);
1985 /* Now link the psymtab and the symtab. */
1989 /* Ancillary parsing procedures. */
1991 /* Lookup the type at relative index RN. Return it in TPP
1992 if found and in any event come up with its name PNAME.
1993 Return value says how many aux symbols we ate */
1996 cross_ref(rn
, tpp
, pname
)
2003 /* Escape index means 'the next one' */
2004 if (rn
->rfd
== 0xfff)
2005 rf
= *(unsigned *) (rn
+ 1);
2011 *pname
= "<undefined>";
2014 * Find the relative file descriptor and the symbol in it
2016 FDR
*fh
= get_rfd(cur_fd
, rf
);
2021 * If we have processed this symbol then we left a forwarding
2022 * pointer to the corresponding GDB symbol. If not, we`ll put
2023 * it in a list of pending symbols, to be processed later when
2024 * the file f will be. In any event, we collect the name for
2025 * the type here. Which is why we made a first pass at
2028 sh
= (SYMR
*) (fh
->isymBase
) + rn
->index
;
2030 /* Careful, we might be looking at .o files */
2031 *pname
= (UNSAFE_DATA_ADDR(sh
->iss
)) ? "<undefined>" :
2034 /* Have we parsed it ? */
2035 if ((!UNSAFE_DATA_ADDR(sh
->value
)) && (sh
->st
== stParsed
)) {
2036 t
= (struct type
*) sh
->value
;
2041 /* Avoid duplicates */
2042 p
= is_pending_symbol(fh
, sh
);
2047 add_pending(fh
, sh
, *tpp
);
2051 /* We used one auxent normally, two if we got a "next one" rf. */
2052 return (rn
->rfd
== 0xfff? 2: 1);
2056 /* Quick&dirty lookup procedure, to avoid the MI ones that require
2057 keeping the symtab sorted */
2059 static struct symbol
*
2060 mylookup_symbol (name
, block
, namespace, class)
2062 register struct block
*block
;
2063 enum namespace namespace;
2064 enum address_class
class;
2066 register int bot
, top
, inc
;
2067 register struct symbol
*sym
;
2070 top
= BLOCK_NSYMS(block
);
2073 sym
= BLOCK_SYM(block
, bot
);
2074 if (SYMBOL_NAME(sym
)[0] == inc
2075 && SYMBOL_NAMESPACE(sym
) == namespace
2076 && SYMBOL_CLASS(sym
) == class
2077 && !strcmp(SYMBOL_NAME(sym
), name
))
2081 if (block
= BLOCK_SUPERBLOCK (block
))
2082 return mylookup_symbol (name
, block
, namespace, class);
2087 /* Add a new symbol S to a block B.
2088 Infrequently, we will need to reallocate the block to make it bigger.
2089 We only detect this case when adding to top_stack->cur_block, since
2090 that's the only time we know how big the block is. FIXME. */
2097 int nsyms
= BLOCK_NSYMS(b
)++;
2098 struct block
*origb
;
2099 struct parse_stack
*stackp
;
2101 if (b
== top_stack
->cur_block
&&
2102 nsyms
>= top_stack
->maxsyms
) {
2103 complain (&block_overflow_complaint
, s
->name
);
2104 /* In this case shrink_block is actually grow_block, since
2105 BLOCK_NSYMS(b) is larger than its current size. */
2107 b
= shrink_block (top_stack
->cur_block
, top_stack
->cur_st
);
2109 /* Now run through the stack replacing pointers to the
2110 original block. shrink_block has already done this
2111 for the blockvector and BLOCK_FUNCTION. */
2112 for (stackp
= top_stack
; stackp
; stackp
= stackp
->next
) {
2113 if (stackp
->cur_block
== origb
) {
2114 stackp
->cur_block
= b
;
2115 stackp
->maxsyms
= BLOCK_NSYMS (b
);
2119 BLOCK_SYM(b
,nsyms
) = s
;
2122 /* Add a new block B to a symtab S */
2129 struct blockvector
*bv
= BLOCKVECTOR(s
);
2131 bv
= (struct blockvector
*)xrealloc(bv
, sizeof(struct blockvector
) +
2132 BLOCKVECTOR_NBLOCKS(bv
) * sizeof(bv
->block
));
2133 if (bv
!= BLOCKVECTOR(s
))
2134 BLOCKVECTOR(s
) = bv
;
2136 BLOCKVECTOR_BLOCK(bv
, BLOCKVECTOR_NBLOCKS(bv
)++) = b
;
2139 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
2140 MIPS' linenumber encoding might need more than one byte
2141 to describe it, LAST is used to detect these continuation lines */
2144 add_line(lt
, lineno
, adr
, last
)
2145 struct linetable
*lt
;
2151 last
= -2; /* make sure we record first line */
2153 if (last
== lineno
) /* skip continuation lines */
2156 lt
->item
[lt
->nitems
].line
= lineno
;
2157 lt
->item
[lt
->nitems
++].pc
= adr
<< 2;
2163 /* Comparison functions, used when sorting things */
2165 /* Symtabs must be ordered viz the code segments they cover */
2168 compare_symtabs( s1
, s2
)
2169 struct symtab
**s1
, **s2
;
2171 /* "most specific" first */
2173 register struct block
*b1
, *b2
;
2174 b1
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(*s1
),GLOBAL_BLOCK
);
2175 b2
= BLOCKVECTOR_BLOCK(BLOCKVECTOR(*s2
),GLOBAL_BLOCK
);
2176 if (BLOCK_END(b1
) == BLOCK_END(b2
))
2177 return BLOCK_START(b1
) - BLOCK_START(b2
);
2178 return BLOCK_END(b1
) - BLOCK_END(b2
);
2182 /* Partial Symtabs, same */
2185 compare_psymtabs( s1
, s2
)
2186 struct partial_symtab
**s1
, **s2
;
2188 /* Perf twist: put the ones with no code at the end */
2190 register int a
= (*s1
)->textlow
;
2191 register int b
= (*s2
)->textlow
;
2200 /* Partial symbols are compared lexicog by their print names */
2203 compare_psymbols (s1
, s2
)
2204 register struct partial_symbol
*s1
, *s2
;
2207 *st1
= SYMBOL_NAME(s1
),
2208 *st2
= SYMBOL_NAME(s2
);
2210 return (st1
[0] - st2
[0] ? st1
[0] - st2
[0] :
2211 strcmp(st1
+ 1, st2
+ 1));
2214 /* Blocks with a smaller low bound should come first */
2216 static int compare_blocks(b1
,b2
)
2217 struct block
**b1
, **b2
;
2219 register int addr_diff
;
2221 addr_diff
= (BLOCK_START((*b1
))) - (BLOCK_START((*b2
)));
2223 return (BLOCK_END((*b1
))) - (BLOCK_END((*b2
)));
2228 /* Sorting and reordering procedures */
2230 /* Sort the blocks of a symtab S.
2231 Reorder the blocks in the blockvector by code-address,
2232 as required by some MI search routines */
2238 struct blockvector
*bv
= BLOCKVECTOR(s
);
2240 if (BLOCKVECTOR_NBLOCKS(bv
) <= 2) {
2242 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) == 0)
2243 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = 0;
2244 if (BLOCK_END(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) == 0)
2245 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) = 0;
2249 * This is very unfortunate: normally all functions are compiled in
2250 * the order they are found, but if the file is compiled -O3 things
2251 * are very different. It would be nice to find a reliable test
2252 * to detect -O3 images in advance.
2254 if (BLOCKVECTOR_NBLOCKS(bv
) > 3)
2255 qsort(&BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
),
2256 BLOCKVECTOR_NBLOCKS(bv
) - FIRST_LOCAL_BLOCK
,
2257 sizeof(struct block
*),
2261 register CORE_ADDR high
= 0;
2262 register int i
, j
= BLOCKVECTOR_NBLOCKS(bv
);
2264 for (i
= FIRST_LOCAL_BLOCK
; i
< j
; i
++)
2265 if (high
< BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
)))
2266 high
= BLOCK_END(BLOCKVECTOR_BLOCK(bv
,i
));
2267 BLOCK_END(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) = high
;
2270 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
)) =
2271 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,FIRST_LOCAL_BLOCK
));
2273 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2274 BLOCK_START(BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2275 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,STATIC_BLOCK
)) =
2276 BLOCK_END (BLOCKVECTOR_BLOCK(bv
,GLOBAL_BLOCK
));
2279 /* Sort the symtab list, as required by some search procedures.
2280 We want files ordered to make them look right to users, and for
2281 searching (see block_for_pc). */
2287 struct symtab
*stab
;
2288 register struct symtab
**all_symtabs
;
2289 register int symtab_count
;
2294 /* Create an array of pointers to all the symtabs. */
2295 for (symtab_count
= 0, stab
= symtab_list
;
2297 symtab_count
++, stab
= stab
->next
) {
2298 obstack_grow (psymbol_obstack
, &stab
, sizeof (stab
));
2299 /* FIXME: Only sort blocks for new symtabs ??? */
2303 all_symtabs
= (struct symtab
**)
2304 obstack_base (psymbol_obstack
);
2305 qsort((char *)all_symtabs
, symtab_count
,
2306 sizeof(struct symtab
*), compare_symtabs
);
2308 /* Re-construct the symtab list, but now it is sorted. */
2309 for (i
= 0; i
< symtab_count
-1; i
++)
2310 all_symtabs
[i
]->next
= all_symtabs
[i
+1];
2311 all_symtabs
[i
]->next
= 0;
2312 symtab_list
= all_symtabs
[0];
2314 obstack_free (psymbol_obstack
, all_symtabs
);
2317 /* Sort the partial symtab list, as required by some search procedures.
2318 PC lookups stop at the first psymtab such that textlow <= PC < texthigh */
2324 register int all_psymtabs_count
;
2325 struct partial_symtab
*pstab
;
2326 struct partial_symtab
**all_psymtabs
;
2328 if (!partial_symtab_list
)
2331 /* Create an array of pointers to all the partial_symtabs. */
2333 for (all_psymtabs_count
= 0, pstab
= partial_symtab_list
;
2335 all_psymtabs_count
++, pstab
= pstab
->next
)
2336 obstack_grow (psymbol_obstack
, &pstab
, sizeof (pstab
));
2338 all_psymtabs
= (struct partial_symtab
**)
2339 obstack_base (psymbol_obstack
);
2341 qsort((char *)all_psymtabs
, all_psymtabs_count
,
2342 sizeof(struct partial_symtab
*), compare_psymtabs
);
2344 /* Re-construct the partial_symtab_list, but now it is sorted. */
2346 for (i
= 0; i
< all_psymtabs_count
-1; i
++)
2347 all_psymtabs
[i
]->next
= all_psymtabs
[i
+1];
2348 all_psymtabs
[i
]->next
= 0;
2349 partial_symtab_list
= all_psymtabs
[0];
2351 obstack_free (psymbol_obstack
, all_psymtabs
);
2354 /* Constructor/restructor/destructor procedures */
2356 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
2357 MAXSYMS and linenumbers MAXLINES we'll put in it */
2361 new_symtab(name
, maxsyms
, maxlines
)
2364 struct symtab
*s
= allocate_symtab (name
);
2366 LINETABLE(s
) = new_linetable(maxlines
);
2368 /* All symtabs must have at least two blocks */
2369 BLOCKVECTOR(s
) = new_bvect(2);
2370 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
) = new_block(maxsyms
);
2371 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), STATIC_BLOCK
) = new_block(maxsyms
);
2372 BLOCK_SUPERBLOCK( BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
),STATIC_BLOCK
)) =
2373 BLOCKVECTOR_BLOCK(BLOCKVECTOR(s
), GLOBAL_BLOCK
);
2375 s
->free_code
= free_linetable
;
2377 /* Link the new symtab into the list of such. */
2378 s
->next
= symtab_list
;
2384 /* Allocate a new partial_symtab NAME */
2386 static struct partial_symtab
*
2390 struct partial_symtab
*pst
;
2392 pst
= (struct partial_symtab
*)
2393 obstack_alloc (psymbol_obstack
, sizeof (*pst
));
2394 bzero (pst
, sizeof (*pst
));
2396 if (name
== (char*)-1) /* FIXME -- why not null here? */
2397 pst
->filename
= "<no name>";
2399 pst
->filename
= name
;
2401 pst
->next
= partial_symtab_list
;
2402 partial_symtab_list
= pst
;
2404 /* Keep a backpointer to the file's symbols */
2405 /* FIXME, we should use private data that is a proper pointer. */
2406 pst
->ldsymlen
= (int)cur_hdr
;
2408 /* The way to turn this into a symtab is to call... */
2409 pst
->read_symtab
= mipscoff_psymtab_to_symtab
;
2415 /* Allocate a linetable array of the given SIZE */
2418 struct linetable
*new_linetable(size
)
2420 struct linetable
*l
;
2422 size
= size
* sizeof(l
->item
) + sizeof(struct linetable
);
2423 l
= (struct linetable
*)xmalloc(size
);
2428 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
2429 I am not so sure about the 3.4 ones */
2435 struct linetable
*l
= new_linetable(LINETABLE(s
)->nitems
);
2437 bcopy(LINETABLE(s
), l
,
2438 LINETABLE(s
)->nitems
* sizeof(l
->item
) + sizeof(struct linetable
));
2439 free (LINETABLE(s
));
2443 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
2446 struct blockvector
*
2449 struct blockvector
*bv
;
2452 size
= sizeof(struct blockvector
) + nblocks
* sizeof(struct block
*);
2453 bv
= (struct blockvector
*) xzalloc(size
);
2455 BLOCKVECTOR_NBLOCKS(bv
) = nblocks
;
2460 /* Allocate and zero a new block of MAXSYMS symbols */
2466 int size
= sizeof(struct block
) + (maxsyms
-1) * sizeof(struct symbol
*);
2467 struct block
*b
= (struct block
*)xzalloc(size
);
2472 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
2473 Shrink_block can also be used by add_symbol to grow a block. */
2475 static struct block
*
2481 struct blockvector
*bv
= BLOCKVECTOR(s
);
2484 /* Just reallocate it and fix references to the old one */
2486 new = (struct block
*) xrealloc ((char *)b
, sizeof(struct block
) +
2487 (BLOCK_NSYMS(b
)-1) * sizeof(struct symbol
*));
2489 /* Should chase pointers to old one. Fortunately, that`s just
2490 the block`s function and inferior blocks */
2491 if (BLOCK_FUNCTION(new) && SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) == b
)
2492 SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(new)) = new;
2493 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++)
2494 if (BLOCKVECTOR_BLOCK(bv
,i
) == b
)
2495 BLOCKVECTOR_BLOCK(bv
,i
) = new;
2496 else if (BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) == b
)
2497 BLOCK_SUPERBLOCK(BLOCKVECTOR_BLOCK(bv
,i
)) = new;
2501 /* Create a new symbol with printname NAME */
2508 struct symbol
*s
= (struct symbol
*)
2509 obstack_alloc (symbol_obstack
, sizeof (struct symbol
));
2511 bzero (s
, sizeof (*s
));
2512 SYMBOL_NAME(s
) = name
;
2516 /* Create a new type with printname NAME */
2523 struct type
*t
= (struct type
*)
2524 obstack_alloc (symbol_obstack
, sizeof (struct type
));
2526 bzero (t
, sizeof (*t
));
2527 TYPE_NAME(t
) = name
;
2531 /* Create and initialize a new type with printname NAME.
2532 CODE and LENGTH are the initial info we put in,
2533 UNS says whether the type is unsigned or not. */
2537 make_type(code
, length
, uns
, name
)
2538 enum type_code code
;
2542 register struct type
*type
;
2544 type
= (struct type
*) xzalloc(sizeof(struct type
));
2545 TYPE_CODE(type
) = code
;
2546 TYPE_LENGTH(type
) = length
;
2547 TYPE_FLAGS(type
) = uns
? TYPE_FLAG_UNSIGNED
: 0;
2548 TYPE_NAME(type
) = name
;
2553 /* Allocate a new field named NAME to the type TYPE */
2557 new_field(type
,name
)
2563 /* Fields are kept in an array */
2564 if (TYPE_NFIELDS(type
))
2565 TYPE_FIELDS(type
) = (struct field
*)xrealloc(TYPE_FIELDS(type
),
2566 (TYPE_NFIELDS(type
)+1) * sizeof(struct field
));
2568 TYPE_FIELDS(type
) = (struct field
*)xzalloc(sizeof(struct field
));
2569 f
= &(TYPE_FIELD(type
,TYPE_NFIELDS(type
)));
2570 TYPE_NFIELDS(type
)++;
2571 bzero(f
, sizeof(struct field
));
2572 f
->name
= name
; /* Whether or not NAME is zero, this works. */
2576 /* Make an enum constant for a member F of an enumerated type T */
2579 make_enum_constant(f
,t
)
2585 * This is awful, but that`s the way it is supposed to be
2586 * (BTW, no need to free the real 'type', it's a builtin)
2588 f
->type
= (struct type
*) f
->bitpos
;
2590 s
= new_symbol(f
->name
);
2591 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
2592 SYMBOL_CLASS(s
) = LOC_CONST
;
2594 SYMBOL_VALUE(s
) = f
->bitpos
;
2595 add_symbol(s
, top_stack
->cur_block
);
2600 /* Things used for calling functions in the inferior.
2601 These functions are exported to our companion
2602 mips-dep.c file and are here because they play
2603 with the symbol-table explicitly. */
2606 /* Need to make a new symbol on the fly for the dummy
2607 frame we put on the stack. Which goes in the.. */
2609 static struct symtab
*dummy_symtab
;
2611 /* Make up a dummy symbol for the code we put at END_PC,
2612 of size SIZE, invoking a function with NARGS arguments
2613 and using a frame of FRAMESIZE bytes */
2615 mips_create_dummy_symbol(end_pc
, size
, nargs
, framesize
)
2619 struct mips_extra_func_info
*gdbinfo
;
2621 /* Allocate symtab if not done already */
2622 if (dummy_symtab
== 0)
2623 dummy_symtab
= new_symtab(".dummy_symtab.", 100, 0);
2625 /* Make a new block. Only needs one symbol */
2627 BLOCK_START(bl
) = end_pc
- size
;
2628 BLOCK_END(bl
) = end_pc
;
2630 BLOCK_SUPERBLOCK(bl
) =
2631 BLOCKVECTOR_BLOCK(BLOCKVECTOR(dummy_symtab
),GLOBAL_BLOCK
);
2632 add_block(bl
, dummy_symtab
);
2633 sort_blocks(dummy_symtab
);
2635 BLOCK_FUNCTION(bl
) = new_symbol("??");
2636 SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(bl
)) = bl
;
2637 g
= new_symbol(".gdbinfo.");
2638 BLOCK_SYM(bl
,BLOCK_NSYMS(bl
)++) = g
;
2640 SYMBOL_NAMESPACE(g
) = LABEL_NAMESPACE
;
2641 SYMBOL_CLASS(g
) = LOC_CONST
;
2642 SYMBOL_TYPE(g
) = builtin_type_void
;
2643 gdbinfo
= (struct mips_extra_func_info
*)
2644 xzalloc(sizeof(struct mips_extra_func_info
));
2646 SYMBOL_VALUE(g
) = (long) gdbinfo
;
2648 gdbinfo
->numargs
= nargs
;
2649 gdbinfo
->framesize
= framesize
;
2650 gdbinfo
->framereg
= 29;
2651 gdbinfo
->pcreg
= 31;
2652 gdbinfo
->regmask
= -2;
2653 gdbinfo
->regoffset
= -4;
2654 gdbinfo
->fregmask
= 0; /* XXX */
2655 gdbinfo
->fregoffset
= 0; /* XXX */
2658 /* We just returned from the dummy code at END_PC, drop its symbol */
2660 mips_destroy_dummy_symbol(end_pc
)
2663 struct blockvector
*bv
= BLOCKVECTOR(dummy_symtab
);
2666 bl
= block_for_pc(end_pc
);
2667 free(BLOCK_FUNCTION(bl
));
2668 free(SYMBOL_VALUE(BLOCK_SYM(bl
,0)));
2669 free(BLOCK_SYM(bl
,0));
2671 for (i
= FIRST_LOCAL_BLOCK
; i
< BLOCKVECTOR_NBLOCKS(bv
); i
++)
2672 if (BLOCKVECTOR_BLOCK(bv
,i
) == bl
)
2674 for (; i
< BLOCKVECTOR_NBLOCKS(bv
) - 1; i
++)
2675 BLOCKVECTOR_BLOCK(bv
,i
) = BLOCKVECTOR_BLOCK(bv
,i
+1);
2676 BLOCKVECTOR_NBLOCKS(bv
)--;
2677 sort_blocks(dummy_symtab
);
2682 /* Sigtramp: make sure we have all the necessary information
2683 about the signal trampoline code. Since the official code
2684 from MIPS does not do so, we make up that information ourselves.
2685 If they fix the library (unlikely) this code will neutralize itself. */
2692 struct block
*b
, *b0
;
2694 sigtramp_address
= -1;
2696 /* We know it is sold as sigvec */
2697 s
= lookup_symbol("sigvec", 0, VAR_NAMESPACE
, 0, NULL
);
2699 /* Most programs do not play with signals */
2703 b0
= SYMBOL_BLOCK_VALUE(s
);
2705 /* A label of sigvec, to be more precise */
2706 s
= lookup_symbol("sigtramp", b0
, VAR_NAMESPACE
, 0, NULL
);
2708 /* But maybe this program uses its own version of sigvec */
2712 sigtramp_address
= SYMBOL_VALUE(s
);
2713 sigtramp_end
= sigtramp_address
+ 0x88; /* black magic */
2715 /* Did we or MIPSco fix the library ? */
2716 if (SYMBOL_CLASS(s
) == LOC_BLOCK
)
2719 /* But what symtab does it live in ? */
2720 st
= find_pc_symtab(SYMBOL_VALUE(s
));
2723 * Ok, there goes the fix: turn it into a procedure, with all the
2724 * needed info. Note we make it a nested procedure of sigvec,
2725 * which is the way the (assembly) code is actually written.
2727 SYMBOL_NAMESPACE(s
) = VAR_NAMESPACE
;
2728 SYMBOL_CLASS(s
) = LOC_BLOCK
;
2729 SYMBOL_TYPE(s
) = make_type(TYPE_CODE_FUNC
, 4, 0, 0);
2730 TYPE_TARGET_TYPE(SYMBOL_TYPE(s
)) = builtin_type_void
;
2732 /* Need a block to allocate .gdbinfo. in */
2734 SYMBOL_BLOCK_VALUE(s
) = b
;
2735 BLOCK_START(b
) = sigtramp_address
;
2736 BLOCK_END(b
) = sigtramp_end
;
2737 BLOCK_FUNCTION(b
) = s
;
2738 BLOCK_SUPERBLOCK(b
) = BLOCK_SUPERBLOCK(b0
);
2742 /* Make a .gdbinfo. for it */
2744 struct mips_extra_func_info
*e
=
2745 (struct mips_extra_func_info
*)
2746 xzalloc(sizeof(struct mips_extra_func_info
));
2748 e
->numargs
= 0; /* the kernel thinks otherwise */
2749 /* align_longword(sigcontext + SIGFRAME) */
2750 e
->framesize
= 0x150;
2751 e
->framereg
= SP_REGNUM
;
2754 e
->regoffset
= -(41 * sizeof(int));
2756 e
->fregoffset
= -(37 * sizeof(int));
2759 s
= new_symbol(".gdbinfo.");
2760 SYMBOL_VALUE(s
) = (int) e
;
2761 SYMBOL_NAMESPACE(s
) = LABEL_NAMESPACE
;
2762 SYMBOL_CLASS(s
) = LOC_CONST
;
2763 SYMBOL_TYPE(s
) = builtin_type_void
;
2766 BLOCK_SYM(b
,BLOCK_NSYMS(b
)++) = s
;
2769 /* Initialization */
2771 static struct sym_fns ecoff_sym_fns
= {"ecoff", 5,
2772 mipscoff_new_init
, mipscoff_symfile_init
,
2773 mipscoff_symfile_read
};
2775 _initialize_mipsread ()
2777 add_symtab_fns (&ecoff_sym_fns
);
2779 /* Missing basic types */
2780 builtin_type_string
= make_type(TYPE_CODE_PASCAL_ARRAY
,
2782 builtin_type_complex
= make_type(TYPE_CODE_FLT
,
2783 2 * sizeof(float), 0, "complex");
2784 builtin_type_double_complex
= make_type(TYPE_CODE_FLT
,
2785 2 * sizeof(double), 0, "double_complex");
2786 builtin_type_fixed_dec
= make_type(TYPE_CODE_INT
, sizeof(int),
2787 0, "fixed_decimal");
2788 builtin_type_float_dec
= make_type(TYPE_CODE_FLT
, sizeof(double),
2789 0, "floating_decimal");
2791 /* Templates types */
2792 builtin_type_ptr
= lookup_pointer_type (builtin_type_void
);
2793 builtin_type_struct
= make_type(TYPE_CODE_STRUCT
, 0, 0, 0);
2794 builtin_type_union
= make_type(TYPE_CODE_UNION
, 0, 0, 0);
2795 builtin_type_enum
= make_type(TYPE_CODE_ENUM
, 0, 0, 0);
2796 builtin_type_range
= make_type(TYPE_CODE_RANGE
, 0, 0, 0);
2797 builtin_type_set
= make_type(TYPE_CODE_SET
, 0, 0, 0);