* configure.in: Check for working mmap, ansi headers, string.h,
[deliverable/binutils-gdb.git] / gdb / mdebugread.c
1 /* Read a symbol table in ECOFF format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995
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
6 at Cygnus Support.
7
8 This file is part of GDB.
9
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.
14
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.
19
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. */
23
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.
31
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.
38
39 This module can read all four of the known byte-order combinations,
40 on any type of host. */
41
42 #include "defs.h"
43 #include "symtab.h"
44 #include "gdbtypes.h"
45 #include "gdbcore.h"
46 #include "symfile.h"
47 #include "objfiles.h"
48 #include "obstack.h"
49 #include "buildsym.h"
50 #include "stabsread.h"
51 #include "complaints.h"
52
53 #if !defined (SEEK_SET)
54 #define SEEK_SET 0
55 #define SEEK_CUR 1
56 #endif
57
58 /* These are needed if the tm.h file does not contain the necessary
59 mips specific definitions. */
60
61 #ifndef MIPS_EFI_SYMBOL_NAME
62 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
63 #include "coff/sym.h"
64 #include "coff/symconst.h"
65 typedef struct mips_extra_func_info {
66 long numargs;
67 PDR pdr;
68 } *mips_extra_func_info_t;
69 #ifndef RA_REGNUM
70 #define RA_REGNUM 0
71 #endif
72 #endif
73
74 #ifdef USG
75 #include <sys/types.h>
76 #endif
77
78 #include <sys/param.h>
79 #include <sys/file.h>
80 #include "gdb_stat.h"
81 #include "gdb_string.h"
82
83 #include "gdb-stabs.h"
84
85 #include "bfd.h"
86
87 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
88
89 #include "libaout.h" /* Private BFD a.out information. */
90 #include "aout/aout64.h"
91 #include "aout/stab_gnu.h" /* STABS information */
92
93 #include "expression.h"
94 #include "language.h" /* Needed inside partial-stab.h */
95
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)
99 #endif
100 \f
101 /* We put a pointer to this structure in the read_symtab_private field
102 of the psymtab. */
103
104 struct symloc
105 {
106 /* Index of the FDR that this psymtab represents. */
107 int fdr_idx;
108 /* The BFD that the psymtab was created from. */
109 bfd *cur_bfd;
110 const struct ecoff_debug_swap *debug_swap;
111 struct ecoff_debug_info *debug_info;
112 struct mdebug_pending **pending_list;
113 /* Pointer to external symbols for this file. */
114 EXTR *extern_tab;
115 /* Size of extern_tab. */
116 int extern_count;
117 enum language pst_language;
118 };
119
120 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
121 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
122 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
123 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
124 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
125 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
126 \f
127 /* Things we import explicitly from other modules */
128
129 extern int info_verbose;
130
131 /* Various complaints about symbol reading that don't abort the process */
132
133 static struct complaint bad_file_number_complaint =
134 {"bad file number %d", 0, 0};
135
136 static struct complaint index_complaint =
137 {"bad aux index at symbol %s", 0, 0};
138
139 static struct complaint aux_index_complaint =
140 {"bad proc end in aux found from symbol %s", 0, 0};
141
142 static struct complaint block_index_complaint =
143 {"bad aux index at block symbol %s", 0, 0};
144
145 static struct complaint unknown_ext_complaint =
146 {"unknown external symbol %s", 0, 0};
147
148 static struct complaint unknown_sym_complaint =
149 {"unknown local symbol %s", 0, 0};
150
151 static struct complaint unknown_st_complaint =
152 {"with type %d", 0, 0};
153
154 static struct complaint block_overflow_complaint =
155 {"block containing %s overfilled", 0, 0};
156
157 static struct complaint basic_type_complaint =
158 {"cannot map ECOFF basic type 0x%x for %s", 0, 0};
159
160 static struct complaint unknown_type_qual_complaint =
161 {"unknown type qualifier 0x%x", 0, 0};
162
163 static struct complaint array_index_type_complaint =
164 {"illegal array index type for %s, assuming int", 0, 0};
165
166 static struct complaint bad_tag_guess_complaint =
167 {"guessed tag type of %s incorrectly", 0, 0};
168
169 static struct complaint block_member_complaint =
170 {"declaration block contains unhandled symbol type %d", 0, 0};
171
172 static struct complaint stEnd_complaint =
173 {"stEnd with storage class %d not handled", 0, 0};
174
175 static struct complaint unknown_mdebug_symtype_complaint =
176 {"unknown symbol type 0x%x", 0, 0};
177
178 static struct complaint stab_unknown_complaint =
179 {"unknown stabs symbol %s", 0, 0};
180
181 static struct complaint pdr_for_nonsymbol_complaint =
182 {"PDR for %s, but no symbol", 0, 0};
183
184 static struct complaint pdr_static_symbol_complaint =
185 {"can't handle PDR for static proc at 0x%lx", 0, 0};
186
187 static struct complaint bad_setjmp_pdr_complaint =
188 {"fixing bad setjmp PDR from libc", 0, 0};
189
190 static struct complaint bad_fbitfield_complaint =
191 {"can't handle TIR fBitfield for %s", 0, 0};
192
193 static struct complaint bad_continued_complaint =
194 {"illegal TIR continued for %s", 0, 0};
195
196 static struct complaint bad_rfd_entry_complaint =
197 {"bad rfd entry for %s: file %d, index %d", 0, 0};
198
199 static struct complaint unexpected_type_code_complaint =
200 {"unexpected type code for %s", 0, 0};
201
202 static struct complaint unable_to_cross_ref_complaint =
203 {"unable to cross ref btTypedef for %s", 0, 0};
204
205 static struct complaint illegal_forward_tq0_complaint =
206 {"illegal tq0 in forward typedef for %s", 0, 0};
207
208 static struct complaint illegal_forward_bt_complaint =
209 {"illegal bt %d in forward typedef for %s", 0, 0};
210
211 static struct complaint bad_linetable_guess_complaint =
212 {"guessed size of linetable for %s incorrectly", 0, 0};
213
214 static struct complaint bad_ext_ifd_complaint =
215 {"bad ifd for external symbol: %d (max %d)", 0, 0};
216
217 static struct complaint bad_ext_iss_complaint =
218 {"bad iss for external symbol: %ld (max %ld)", 0, 0};
219
220 /* Macros and extra defs */
221
222 /* Puns: hard to find whether -g was used and how */
223
224 #define MIN_GLEVEL GLEVEL_0
225 #define compare_glevel(a,b) \
226 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
227 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
228 \f
229 /* Things that really are local to this module */
230
231 /* Remember what we deduced to be the source language of this psymtab. */
232
233 static enum language psymtab_language = language_unknown;
234
235 /* Current BFD. */
236
237 static bfd *cur_bfd;
238
239 /* How to parse debugging information for CUR_BFD. */
240
241 static const struct ecoff_debug_swap *debug_swap;
242
243 /* Pointers to debugging information for CUR_BFD. */
244
245 static struct ecoff_debug_info *debug_info;
246
247 /* Pointer to current file decriptor record, and its index */
248
249 static FDR *cur_fdr;
250 static int cur_fd;
251
252 /* Index of current symbol */
253
254 static int cur_sdx;
255
256 /* Note how much "debuggable" this image is. We would like
257 to see at least one FDR with full symbols */
258
259 static max_gdbinfo;
260 static max_glevel;
261
262 /* When examining .o files, report on undefined symbols */
263
264 static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
265
266 /* Pseudo symbol to use when putting stabs into the symbol table. */
267
268 static char stabs_symbol[] = STABS_SYMBOL;
269
270 /* Types corresponding to mdebug format bt* basic types. */
271
272 static struct type *mdebug_type_void;
273 static struct type *mdebug_type_char;
274 static struct type *mdebug_type_short;
275 static struct type *mdebug_type_int_32;
276 #define mdebug_type_int mdebug_type_int_32
277 static struct type *mdebug_type_int_64;
278 static struct type *mdebug_type_long_32;
279 static struct type *mdebug_type_long_64;
280 static struct type *mdebug_type_long_long_64;
281 static struct type *mdebug_type_unsigned_char;
282 static struct type *mdebug_type_unsigned_short;
283 static struct type *mdebug_type_unsigned_int_32;
284 static struct type *mdebug_type_unsigned_int_64;
285 static struct type *mdebug_type_unsigned_long_32;
286 static struct type *mdebug_type_unsigned_long_64;
287 static struct type *mdebug_type_unsigned_long_long_64;
288 static struct type *mdebug_type_adr_32;
289 static struct type *mdebug_type_adr_64;
290 static struct type *mdebug_type_float;
291 static struct type *mdebug_type_double;
292 static struct type *mdebug_type_complex;
293 static struct type *mdebug_type_double_complex;
294 static struct type *mdebug_type_fixed_dec;
295 static struct type *mdebug_type_float_dec;
296 static struct type *mdebug_type_string;
297
298 /* Types for symbols from files compiled without debugging info. */
299
300 static struct type *nodebug_func_symbol_type;
301 static struct type *nodebug_var_symbol_type;
302
303 /* Nonzero if we have seen ecoff debugging info for a file. */
304
305 static int found_ecoff_debugging_info;
306
307 /* Forward declarations */
308
309 static int
310 upgrade_type PARAMS ((int, struct type **, int, union aux_ext *, int, char *));
311
312 static void
313 parse_partial_symbols PARAMS ((struct objfile *,
314 struct section_offsets *));
315
316 static FDR
317 *get_rfd PARAMS ((int, int));
318
319 static int
320 has_opaque_xref PARAMS ((FDR *, SYMR *));
321
322 static int
323 cross_ref PARAMS ((int, union aux_ext *, struct type **, enum type_code,
324 char **, int, char *));
325
326 static struct symbol *
327 new_symbol PARAMS ((char *));
328
329 static struct type *
330 new_type PARAMS ((char *));
331
332 static struct block *
333 new_block PARAMS ((int));
334
335 static struct symtab *
336 new_symtab PARAMS ((char *, int, int, struct objfile *));
337
338 static struct linetable *
339 new_linetable PARAMS ((int));
340
341 static struct blockvector *
342 new_bvect PARAMS ((int));
343
344 static int
345 parse_symbol PARAMS ((SYMR *, union aux_ext *, char *, int, struct section_offsets *));
346
347 static struct type *
348 parse_type PARAMS ((int, union aux_ext *, unsigned int, int *, int, char *));
349
350 static struct symbol *
351 mylookup_symbol PARAMS ((char *, struct block *, enum namespace,
352 enum address_class));
353
354 static struct block *
355 shrink_block PARAMS ((struct block *, struct symtab *));
356
357 static PTR
358 xzalloc PARAMS ((unsigned int));
359
360 static void
361 sort_blocks PARAMS ((struct symtab *));
362
363 static int
364 compare_blocks PARAMS ((const void *, const void *));
365
366 static struct partial_symtab *
367 new_psymtab PARAMS ((char *, struct objfile *, struct section_offsets *));
368
369 static void
370 psymtab_to_symtab_1 PARAMS ((struct partial_symtab *, char *));
371
372 static void
373 add_block PARAMS ((struct block *, struct symtab *));
374
375 static void
376 add_symbol PARAMS ((struct symbol *, struct block *));
377
378 static int
379 add_line PARAMS ((struct linetable *, int, CORE_ADDR, int));
380
381 static struct linetable *
382 shrink_linetable PARAMS ((struct linetable *));
383
384 static void
385 handle_psymbol_enumerators PARAMS ((struct objfile *, FDR *, int));
386
387 static char *
388 mdebug_next_symbol_text PARAMS ((void));
389 \f
390 /* Address bounds for the signal trampoline in inferior, if any */
391
392 CORE_ADDR sigtramp_address, sigtramp_end;
393
394 /* Allocate zeroed memory */
395
396 static PTR
397 xzalloc (size)
398 unsigned int size;
399 {
400 PTR p = xmalloc (size);
401
402 memset (p, 0, size);
403 return p;
404 }
405
406 /* Exported procedure: Builds a symtab from the PST partial one.
407 Restores the environment in effect when PST was created, delegates
408 most of the work to an ancillary procedure, and sorts
409 and reorders the symtab list at the end */
410
411 static void
412 mdebug_psymtab_to_symtab (pst)
413 struct partial_symtab *pst;
414 {
415
416 if (!pst)
417 return;
418
419 if (info_verbose)
420 {
421 printf_filtered ("Reading in symbols for %s...", pst->filename);
422 gdb_flush (gdb_stdout);
423 }
424
425 next_symbol_text_func = mdebug_next_symbol_text;
426
427 psymtab_to_symtab_1 (pst, pst->filename);
428
429 /* Match with global symbols. This only needs to be done once,
430 after all of the symtabs and dependencies have been read in. */
431 scan_file_globals (pst->objfile);
432
433 if (info_verbose)
434 printf_filtered ("done.\n");
435 }
436 \f
437 /* File-level interface functions */
438
439 /* Find a file descriptor given its index RF relative to a file CF */
440
441 static FDR *
442 get_rfd (cf, rf)
443 int cf, rf;
444 {
445 FDR *fdrs;
446 register FDR *f;
447 RFDT rfd;
448
449 fdrs = debug_info->fdr;
450 f = fdrs + cf;
451 /* Object files do not have the RFD table, all refs are absolute */
452 if (f->rfdBase == 0)
453 return fdrs + rf;
454 (*debug_swap->swap_rfd_in) (cur_bfd,
455 ((char *) debug_info->external_rfd
456 + ((f->rfdBase + rf)
457 * debug_swap->external_rfd_size)),
458 &rfd);
459 return fdrs + rfd;
460 }
461
462 /* Return a safer print NAME for a file descriptor */
463
464 static char *
465 fdr_name (f)
466 FDR *f;
467 {
468 if (f->rss == -1)
469 return "<stripped file>";
470 if (f->rss == 0)
471 return "<NFY>";
472 return debug_info->ss + f->issBase + f->rss;
473 }
474
475
476 /* Read in and parse the symtab of the file OBJFILE. Symbols from
477 different sections are relocated via the SECTION_OFFSETS. */
478
479 void
480 mdebug_build_psymtabs (objfile, swap, info, section_offsets)
481 struct objfile *objfile;
482 const struct ecoff_debug_swap *swap;
483 struct ecoff_debug_info *info;
484 struct section_offsets *section_offsets;
485 {
486 cur_bfd = objfile->obfd;
487 debug_swap = swap;
488 debug_info = info;
489
490 /* Make sure all the FDR information is swapped in. */
491 if (info->fdr == (FDR *) NULL)
492 {
493 char *fdr_src;
494 char *fdr_end;
495 FDR *fdr_ptr;
496
497 info->fdr = (FDR *) obstack_alloc (&objfile->psymbol_obstack,
498 (info->symbolic_header.ifdMax
499 * sizeof (FDR)));
500 fdr_src = info->external_fdr;
501 fdr_end = (fdr_src
502 + info->symbolic_header.ifdMax * swap->external_fdr_size);
503 fdr_ptr = info->fdr;
504 for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++)
505 (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);
506 }
507
508 parse_partial_symbols (objfile, section_offsets);
509
510 #if 0
511 /* Check to make sure file was compiled with -g. If not, warn the
512 user of this limitation. */
513 if (compare_glevel (max_glevel, GLEVEL_2) < 0)
514 {
515 if (max_gdbinfo == 0)
516 printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
517 objfile->name);
518 printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
519 gdb_flush (gdb_stdout);
520 }
521 #endif
522 }
523 \f
524 /* Local utilities */
525
526 /* Map of FDR indexes to partial symtabs */
527
528 struct pst_map
529 {
530 struct partial_symtab *pst; /* the psymtab proper */
531 long n_globals; /* exported globals (external symbols) */
532 long globals_offset; /* cumulative */
533 };
534
535
536 /* Utility stack, used to nest procedures and blocks properly.
537 It is a doubly linked list, to avoid too many alloc/free.
538 Since we might need it quite a few times it is NOT deallocated
539 after use. */
540
541 static struct parse_stack
542 {
543 struct parse_stack *next, *prev;
544 struct symtab *cur_st; /* Current symtab. */
545 struct block *cur_block; /* Block in it. */
546
547 /* What are we parsing. stFile, or stBlock are for files and
548 blocks. stProc or stStaticProc means we have seen the start of a
549 procedure, but not the start of the block within in. When we see
550 the start of that block, we change it to stNil, without pushing a
551 new block, i.e. stNil means both a procedure and a block. */
552
553 int blocktype;
554
555 int maxsyms; /* Max symbols in this block. */
556 struct type *cur_type; /* Type we parse fields for. */
557 int cur_field; /* Field number in cur_type. */
558 CORE_ADDR procadr; /* Start addres of this procedure */
559 int numargs; /* Its argument count */
560 }
561
562 *top_stack; /* Top stack ptr */
563
564
565 /* Enter a new lexical context */
566
567 static void
568 push_parse_stack ()
569 {
570 struct parse_stack *new;
571
572 /* Reuse frames if possible */
573 if (top_stack && top_stack->prev)
574 new = top_stack->prev;
575 else
576 new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
577 /* Initialize new frame with previous content */
578 if (top_stack)
579 {
580 register struct parse_stack *prev = new->prev;
581
582 *new = *top_stack;
583 top_stack->prev = new;
584 new->prev = prev;
585 new->next = top_stack;
586 }
587 top_stack = new;
588 }
589
590 /* Exit a lexical context */
591
592 static void
593 pop_parse_stack ()
594 {
595 if (!top_stack)
596 return;
597 if (top_stack->next)
598 top_stack = top_stack->next;
599 }
600
601
602 /* Cross-references might be to things we haven't looked at
603 yet, e.g. type references. To avoid too many type
604 duplications we keep a quick fixup table, an array
605 of lists of references indexed by file descriptor */
606
607 struct mdebug_pending
608 {
609 struct mdebug_pending *next; /* link */
610 char *s; /* the unswapped symbol */
611 struct type *t; /* its partial type descriptor */
612 };
613
614
615 /* The pending information is kept for an entire object file, and used
616 to be in the sym_private field. I took it out when I split
617 mdebugread from mipsread, because this might not be the only type
618 of symbols read from an object file. Instead, we allocate the
619 pending information table when we create the partial symbols, and
620 we store a pointer to the single table in each psymtab. */
621
622 static struct mdebug_pending **pending_list;
623
624 /* Check whether we already saw symbol SH in file FH */
625
626 static struct mdebug_pending *
627 is_pending_symbol (fh, sh)
628 FDR *fh;
629 char *sh;
630 {
631 int f_idx = fh - debug_info->fdr;
632 register struct mdebug_pending *p;
633
634 /* Linear search is ok, list is typically no more than 10 deep */
635 for (p = pending_list[f_idx]; p; p = p->next)
636 if (p->s == sh)
637 break;
638 return p;
639 }
640
641 /* Add a new symbol SH of type T */
642
643 static void
644 add_pending (fh, sh, t)
645 FDR *fh;
646 char *sh;
647 struct type *t;
648 {
649 int f_idx = fh - debug_info->fdr;
650 struct mdebug_pending *p = is_pending_symbol (fh, sh);
651
652 /* Make sure we do not make duplicates */
653 if (!p)
654 {
655 p = ((struct mdebug_pending *)
656 obstack_alloc (&current_objfile->psymbol_obstack,
657 sizeof (struct mdebug_pending)));
658 p->s = sh;
659 p->t = t;
660 p->next = pending_list[f_idx];
661 pending_list[f_idx] = p;
662 }
663 }
664 \f
665
666 /* Parsing Routines proper. */
667
668 /* Parse a single symbol. Mostly just make up a GDB symbol for it.
669 For blocks, procedures and types we open a new lexical context.
670 This is basically just a big switch on the symbol's type. Argument
671 AX is the base pointer of aux symbols for this file (fh->iauxBase).
672 EXT_SH points to the unswapped symbol, which is needed for struct,
673 union, etc., types; it is NULL for an EXTR. BIGEND says whether
674 aux symbols are big-endian or little-endian. Return count of
675 SYMR's handled (normally one). */
676
677 static int
678 parse_symbol (sh, ax, ext_sh, bigend, section_offsets)
679 SYMR *sh;
680 union aux_ext *ax;
681 char *ext_sh;
682 int bigend;
683 struct section_offsets *section_offsets;
684 {
685 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
686 void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *)) =
687 debug_swap->swap_sym_in;
688 char *name;
689 struct symbol *s;
690 struct block *b;
691 struct mdebug_pending *pend;
692 struct type *t;
693 struct field *f;
694 int count = 1;
695 enum address_class class;
696 TIR tir;
697 long svalue = sh->value;
698 int bitsize;
699
700 if (ext_sh == (char *) NULL)
701 name = debug_info->ssext + sh->iss;
702 else
703 name = debug_info->ss + cur_fdr->issBase + sh->iss;
704
705 switch (sh->sc)
706 {
707 case scText:
708 /* Do not relocate relative values.
709 The value of a stEnd symbol is the displacement from the
710 corresponding start symbol value.
711 The value of a stBlock symbol is the displacement from the
712 procedure address. */
713 if (sh->st != stEnd && sh->st != stBlock)
714 sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
715 break;
716 case scData:
717 case scSData:
718 case scRData:
719 case scPData:
720 case scXData:
721 sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA);
722 break;
723 case scBss:
724 case scSBss:
725 sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS);
726 break;
727 }
728
729 switch (sh->st)
730 {
731 case stNil:
732 break;
733
734 case stGlobal: /* external symbol, goes into global block */
735 class = LOC_STATIC;
736 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
737 GLOBAL_BLOCK);
738 s = new_symbol (name);
739 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
740 goto data;
741
742 case stStatic: /* static data, goes into current block. */
743 class = LOC_STATIC;
744 b = top_stack->cur_block;
745 s = new_symbol (name);
746 if (sh->sc == scCommon || sh->sc == scSCommon)
747 {
748 /* It is a FORTRAN common block. At least for SGI Fortran the
749 address is not in the symbol; we need to fix it later in
750 scan_file_globals. */
751 int bucket = hashname (SYMBOL_NAME (s));
752 SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
753 global_sym_chain[bucket] = s;
754 }
755 else
756 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
757 goto data;
758
759 case stLocal: /* local variable, goes into current block */
760 if (sh->sc == scRegister)
761 {
762 class = LOC_REGISTER;
763 svalue = ECOFF_REG_TO_REGNUM (svalue);
764 }
765 else
766 class = LOC_LOCAL;
767 b = top_stack->cur_block;
768 s = new_symbol (name);
769 SYMBOL_VALUE (s) = svalue;
770
771 data: /* Common code for symbols describing data */
772 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
773 SYMBOL_CLASS (s) = class;
774 add_symbol (s, b);
775
776 /* Type could be missing if file is compiled without debugging info. */
777 if (sh->sc == scUndefined || sh->sc == scNil || sh->index == indexNil)
778 SYMBOL_TYPE (s) = nodebug_var_symbol_type;
779 else
780 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
781 /* Value of a data symbol is its memory address */
782 break;
783
784 case stParam: /* arg to procedure, goes into current block */
785 max_gdbinfo++;
786 found_ecoff_debugging_info = 1;
787 top_stack->numargs++;
788
789 /* Special GNU C++ name. */
790 if (name[0] == CPLUS_MARKER && name[1] == 't' && name[2] == 0)
791 name = "this"; /* FIXME, not alloc'd in obstack */
792 s = new_symbol (name);
793
794 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
795 switch (sh->sc)
796 {
797 case scRegister:
798 /* Pass by value in register. */
799 SYMBOL_CLASS(s) = LOC_REGPARM;
800 svalue = ECOFF_REG_TO_REGNUM (svalue);
801 break;
802 case scVar:
803 /* Pass by reference on stack. */
804 SYMBOL_CLASS(s) = LOC_REF_ARG;
805 break;
806 case scVarRegister:
807 /* Pass by reference in register. */
808 SYMBOL_CLASS(s) = LOC_REGPARM_ADDR;
809 svalue = ECOFF_REG_TO_REGNUM (svalue);
810 break;
811 default:
812 /* Pass by value on stack. */
813 SYMBOL_CLASS(s) = LOC_ARG;
814 break;
815 }
816 SYMBOL_VALUE (s) = svalue;
817 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
818 add_symbol (s, top_stack->cur_block);
819 break;
820
821 case stLabel: /* label, goes into current block */
822 s = new_symbol (name);
823 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; /* so that it can be used */
824 SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused */
825 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
826 SYMBOL_TYPE (s) = mdebug_type_int;
827 add_symbol (s, top_stack->cur_block);
828 break;
829
830 case stProc: /* Procedure, usually goes into global block */
831 case stStaticProc: /* Static procedure, goes into current block */
832 s = new_symbol (name);
833 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
834 SYMBOL_CLASS (s) = LOC_BLOCK;
835 /* Type of the return value */
836 if (sh->sc == scUndefined || sh->sc == scNil)
837 t = mdebug_type_int;
838 else
839 t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
840 b = top_stack->cur_block;
841 if (sh->st == stProc)
842 {
843 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
844 /* The next test should normally be true, but provides a
845 hook for nested functions (which we don't want to make
846 global). */
847 if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
848 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
849 /* Irix 5 sometimes has duplicate names for the same
850 function. We want to add such names up at the global
851 level, not as a nested function. */
852 else if (sh->value == top_stack->procadr)
853 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
854 }
855 add_symbol (s, b);
856
857 /* Make a type for the procedure itself */
858 SYMBOL_TYPE (s) = lookup_function_type (t);
859
860 /* Create and enter a new lexical context */
861 b = new_block (top_stack->maxsyms);
862 SYMBOL_BLOCK_VALUE (s) = b;
863 BLOCK_FUNCTION (b) = s;
864 BLOCK_START (b) = BLOCK_END (b) = sh->value;
865 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
866 add_block (b, top_stack->cur_st);
867
868 /* Not if we only have partial info */
869 if (sh->sc == scUndefined || sh->sc == scNil)
870 break;
871
872 push_parse_stack ();
873 top_stack->cur_block = b;
874 top_stack->blocktype = sh->st;
875 top_stack->cur_type = SYMBOL_TYPE (s);
876 top_stack->cur_field = -1;
877 top_stack->procadr = sh->value;
878 top_stack->numargs = 0;
879 break;
880
881 /* Beginning of code for structure, union, and enum definitions.
882 They all share a common set of local variables, defined here. */
883 {
884 enum type_code type_code;
885 char *ext_tsym;
886 int nfields;
887 long max_value;
888 struct field *f;
889
890 case stStruct: /* Start a block defining a struct type */
891 type_code = TYPE_CODE_STRUCT;
892 goto structured_common;
893
894 case stUnion: /* Start a block defining a union type */
895 type_code = TYPE_CODE_UNION;
896 goto structured_common;
897
898 case stEnum: /* Start a block defining an enum type */
899 type_code = TYPE_CODE_ENUM;
900 goto structured_common;
901
902 case stBlock: /* Either a lexical block, or some type */
903 if (sh->sc != scInfo && sh->sc != scCommon && sh->sc != scSCommon)
904 goto case_stBlock_code; /* Lexical block */
905
906 type_code = TYPE_CODE_UNDEF; /* We have a type. */
907
908 /* Common code for handling struct, union, enum, and/or as-yet-
909 unknown-type blocks of info about structured data. `type_code'
910 has been set to the proper TYPE_CODE, if we know it. */
911 structured_common:
912 found_ecoff_debugging_info = 1;
913 push_parse_stack ();
914 top_stack->blocktype = stBlock;
915
916 /* First count the number of fields and the highest value. */
917 nfields = 0;
918 max_value = 0;
919 for (ext_tsym = ext_sh + external_sym_size;
920 ;
921 ext_tsym += external_sym_size)
922 {
923 SYMR tsym;
924
925 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
926
927 switch (tsym.st)
928 {
929 case stEnd:
930 goto end_of_fields;
931
932 case stMember:
933 if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
934 /* If the type of the member is Nil (or Void),
935 without qualifiers, assume the tag is an
936 enumeration. */
937 if (tsym.index == indexNil)
938 type_code = TYPE_CODE_ENUM;
939 else
940 {
941 (*debug_swap->swap_tir_in) (bigend,
942 &ax[tsym.index].a_ti,
943 &tir);
944 if ((tir.bt == btNil || tir.bt == btVoid)
945 && tir.tq0 == tqNil)
946 type_code = TYPE_CODE_ENUM;
947 }
948 nfields++;
949 if (tsym.value > max_value)
950 max_value = tsym.value;
951 break;
952
953 case stBlock:
954 case stUnion:
955 case stEnum:
956 case stStruct:
957 {
958 #if 0
959 /* This is a no-op; is it trying to tell us something
960 we should be checking? */
961 if (tsym.sc == scVariant); /*UNIMPLEMENTED*/
962 #endif
963 if (tsym.index != 0)
964 {
965 /* This is something like a struct within a
966 struct. Skip over the fields of the inner
967 struct. The -1 is because the for loop will
968 increment ext_tsym. */
969 ext_tsym = ((char *) debug_info->external_sym
970 + ((cur_fdr->isymBase + tsym.index - 1)
971 * external_sym_size));
972 }
973 }
974 break;
975
976 case stTypedef:
977 /* mips cc puts out a typedef for struct x if it is not yet
978 defined when it encounters
979 struct y { struct x *xp; };
980 Just ignore it. */
981 break;
982
983 case stIndirect:
984 /* Irix5 cc puts out a stIndirect for struct x if it is not
985 yet defined when it encounters
986 struct y { struct x *xp; };
987 Just ignore it. */
988 break;
989
990 default:
991 complain (&block_member_complaint, tsym.st);
992 }
993 }
994 end_of_fields:;
995
996 /* In an stBlock, there is no way to distinguish structs,
997 unions, and enums at this point. This is a bug in the
998 original design (that has been fixed with the recent
999 addition of the stStruct, stUnion, and stEnum symbol
1000 types.) The way you can tell is if/when you see a variable
1001 or field of that type. In that case the variable's type
1002 (in the AUX table) says if the type is struct, union, or
1003 enum, and points back to the stBlock here. So you can
1004 patch the tag kind up later - but only if there actually is
1005 a variable or field of that type.
1006
1007 So until we know for sure, we will guess at this point.
1008 The heuristic is:
1009 If the first member has index==indexNil or a void type,
1010 assume we have an enumeration.
1011 Otherwise, if there is more than one member, and all
1012 the members have offset 0, assume we have a union.
1013 Otherwise, assume we have a struct.
1014
1015 The heuristic could guess wrong in the case of of an
1016 enumeration with no members or a union with one (or zero)
1017 members, or when all except the last field of a struct have
1018 width zero. These are uncommon and/or illegal situations,
1019 and in any case guessing wrong probably doesn't matter
1020 much.
1021
1022 But if we later do find out we were wrong, we fixup the tag
1023 kind. Members of an enumeration must be handled
1024 differently from struct/union fields, and that is harder to
1025 patch up, but luckily we shouldn't need to. (If there are
1026 any enumeration members, we can tell for sure it's an enum
1027 here.) */
1028
1029 if (type_code == TYPE_CODE_UNDEF)
1030 if (nfields > 1 && max_value == 0)
1031 type_code = TYPE_CODE_UNION;
1032 else
1033 type_code = TYPE_CODE_STRUCT;
1034
1035 /* Create a new type or use the pending type. */
1036 pend = is_pending_symbol (cur_fdr, ext_sh);
1037 if (pend == (struct mdebug_pending *) NULL)
1038 {
1039 t = new_type (NULL);
1040 add_pending (cur_fdr, ext_sh, t);
1041 }
1042 else
1043 t = pend->t;
1044
1045 /* Do not set the tag name if it is a compiler generated tag name
1046 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1047 Alpha cc puts out an sh->iss of zero for those. */
1048 if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
1049 TYPE_TAG_NAME (t) = NULL;
1050 else
1051 TYPE_TAG_NAME (t) = obconcat (&current_objfile->symbol_obstack,
1052 "", "", name);
1053
1054 TYPE_CODE (t) = type_code;
1055 TYPE_LENGTH (t) = sh->value;
1056 TYPE_NFIELDS (t) = nfields;
1057 TYPE_FIELDS (t) = f = ((struct field *)
1058 TYPE_ALLOC (t,
1059 nfields * sizeof (struct field)));
1060
1061 if (type_code == TYPE_CODE_ENUM)
1062 {
1063 /* This is a non-empty enum. */
1064
1065 /* DEC c89 has the number of enumerators in the sh.value field,
1066 not the type length, so we have to compensate for that
1067 incompatibility quirk.
1068 This might do the wrong thing for an enum with one or two
1069 enumerators and gcc -gcoff -fshort-enums, but these cases
1070 are hopefully rare enough. */
1071 if (TYPE_LENGTH (t) == TYPE_NFIELDS (t))
1072 TYPE_LENGTH (t) = TARGET_INT_BIT / HOST_CHAR_BIT;
1073 for (ext_tsym = ext_sh + external_sym_size;
1074 ;
1075 ext_tsym += external_sym_size)
1076 {
1077 SYMR tsym;
1078 struct symbol *enum_sym;
1079
1080 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
1081
1082 if (tsym.st != stMember)
1083 break;
1084
1085 f->bitpos = tsym.value;
1086 f->type = t;
1087 f->name = debug_info->ss + cur_fdr->issBase + tsym.iss;
1088 f->bitsize = 0;
1089
1090 enum_sym = ((struct symbol *)
1091 obstack_alloc (&current_objfile->symbol_obstack,
1092 sizeof (struct symbol)));
1093 memset ((PTR) enum_sym, 0, sizeof (struct symbol));
1094 SYMBOL_NAME (enum_sym) = f->name;
1095 SYMBOL_CLASS (enum_sym) = LOC_CONST;
1096 SYMBOL_TYPE (enum_sym) = t;
1097 SYMBOL_NAMESPACE (enum_sym) = VAR_NAMESPACE;
1098 SYMBOL_VALUE (enum_sym) = tsym.value;
1099 add_symbol (enum_sym, top_stack->cur_block);
1100
1101 /* Skip the stMembers that we've handled. */
1102 count++;
1103 f++;
1104 }
1105 }
1106 /* make this the current type */
1107 top_stack->cur_type = t;
1108 top_stack->cur_field = 0;
1109
1110 /* Do not create a symbol for alpha cc unnamed structs. */
1111 if (sh->iss == 0)
1112 break;
1113
1114 /* gcc puts out an empty struct for an opaque struct definitions,
1115 do not create a symbol for it either. */
1116 if (TYPE_NFIELDS (t) == 0)
1117 {
1118 TYPE_FLAGS (t) |= TYPE_FLAG_STUB;
1119 break;
1120 }
1121
1122 s = new_symbol (name);
1123 SYMBOL_NAMESPACE (s) = STRUCT_NAMESPACE;
1124 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1125 SYMBOL_VALUE (s) = 0;
1126 SYMBOL_TYPE (s) = t;
1127 add_symbol (s, top_stack->cur_block);
1128 break;
1129
1130 /* End of local variables shared by struct, union, enum, and
1131 block (as yet unknown struct/union/enum) processing. */
1132 }
1133
1134 case_stBlock_code:
1135 found_ecoff_debugging_info = 1;
1136 /* beginnning of (code) block. Value of symbol
1137 is the displacement from procedure start */
1138 push_parse_stack ();
1139
1140 /* Do not start a new block if this is the outermost block of a
1141 procedure. This allows the LOC_BLOCK symbol to point to the
1142 block with the local variables, so funcname::var works. */
1143 if (top_stack->blocktype == stProc
1144 || top_stack->blocktype == stStaticProc)
1145 {
1146 top_stack->blocktype = stNil;
1147 break;
1148 }
1149
1150 top_stack->blocktype = stBlock;
1151 b = new_block (top_stack->maxsyms);
1152 BLOCK_START (b) = sh->value + top_stack->procadr;
1153 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1154 top_stack->cur_block = b;
1155 add_block (b, top_stack->cur_st);
1156 break;
1157
1158 case stEnd: /* end (of anything) */
1159 if (sh->sc == scInfo || sh->sc == scCommon || sh->sc == scSCommon)
1160 {
1161 /* Finished with type */
1162 top_stack->cur_type = 0;
1163 }
1164 else if (sh->sc == scText &&
1165 (top_stack->blocktype == stProc ||
1166 top_stack->blocktype == stStaticProc))
1167 {
1168 /* Finished with procedure */
1169 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
1170 struct mips_extra_func_info *e;
1171 struct block *b;
1172 struct type *ftype = top_stack->cur_type;
1173 int i;
1174
1175 BLOCK_END (top_stack->cur_block) += sh->value; /* size */
1176
1177 /* Make up special symbol to contain procedure specific info */
1178 s = new_symbol (MIPS_EFI_SYMBOL_NAME);
1179 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
1180 SYMBOL_CLASS (s) = LOC_CONST;
1181 SYMBOL_TYPE (s) = mdebug_type_void;
1182 e = ((struct mips_extra_func_info *)
1183 obstack_alloc (&current_objfile->symbol_obstack,
1184 sizeof (struct mips_extra_func_info)));
1185 memset ((PTR) e, 0, sizeof (struct mips_extra_func_info));
1186 SYMBOL_VALUE (s) = (long) e;
1187 e->numargs = top_stack->numargs;
1188 e->pdr.framereg = -1;
1189 add_symbol (s, top_stack->cur_block);
1190
1191 /* Reallocate symbols, saving memory */
1192 b = shrink_block (top_stack->cur_block, top_stack->cur_st);
1193
1194 /* f77 emits proc-level with address bounds==[0,0],
1195 So look for such child blocks, and patch them. */
1196 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
1197 {
1198 struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
1199 if (BLOCK_SUPERBLOCK (b_bad) == b
1200 && BLOCK_START (b_bad) == top_stack->procadr
1201 && BLOCK_END (b_bad) == top_stack->procadr)
1202 {
1203 BLOCK_START (b_bad) = BLOCK_START (b);
1204 BLOCK_END (b_bad) = BLOCK_END (b);
1205 }
1206 }
1207
1208 if (TYPE_NFIELDS (ftype) <= 0)
1209 {
1210 /* No parameter type information is recorded with the function's
1211 type. Set that from the type of the parameter symbols. */
1212 int nparams = top_stack->numargs;
1213 int iparams;
1214 struct symbol *sym;
1215
1216 if (nparams > 0)
1217 {
1218 TYPE_NFIELDS (ftype) = nparams;
1219 TYPE_FIELDS (ftype) = (struct field *)
1220 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
1221
1222 for (i = iparams = 0; iparams < nparams; i++)
1223 {
1224 sym = BLOCK_SYM (b, i);
1225 switch (SYMBOL_CLASS (sym))
1226 {
1227 case LOC_ARG:
1228 case LOC_REF_ARG:
1229 case LOC_REGPARM:
1230 case LOC_REGPARM_ADDR:
1231 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
1232 iparams++;
1233 break;
1234 default:
1235 break;
1236 }
1237 }
1238 }
1239 }
1240 }
1241 else if (sh->sc == scText && top_stack->blocktype == stBlock)
1242 {
1243 /* End of (code) block. The value of the symbol is the
1244 displacement from the procedure`s start address of the
1245 end of this block. */
1246 BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
1247 shrink_block (top_stack->cur_block, top_stack->cur_st);
1248 }
1249 else if (sh->sc == scText && top_stack->blocktype == stNil)
1250 {
1251 /* End of outermost block. Pop parse stack and ignore. The
1252 following stEnd of stProc will take care of the block. */
1253 ;
1254 }
1255 else if (sh->sc == scText && top_stack->blocktype == stFile)
1256 {
1257 /* End of file. Pop parse stack and ignore. Higher
1258 level code deals with this. */
1259 ;
1260 }
1261 else
1262 complain (&stEnd_complaint, sh->sc);
1263
1264 pop_parse_stack (); /* restore previous lexical context */
1265 break;
1266
1267 case stMember: /* member of struct or union */
1268 f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
1269 f->name = name;
1270 f->bitpos = sh->value;
1271 bitsize = 0;
1272 f->type = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name);
1273 f->bitsize = bitsize;
1274 break;
1275
1276 case stIndirect: /* forward declaration on Irix5 */
1277 /* Forward declarations from Irix5 cc are handled by cross_ref,
1278 skip them. */
1279 break;
1280
1281 case stTypedef: /* type definition */
1282 found_ecoff_debugging_info = 1;
1283
1284 /* Typedefs for forward declarations and opaque structs from alpha cc
1285 are handled by cross_ref, skip them. */
1286 if (sh->iss == 0)
1287 break;
1288
1289 /* Parse the type or use the pending type. */
1290 pend = is_pending_symbol (cur_fdr, ext_sh);
1291 if (pend == (struct mdebug_pending *) NULL)
1292 {
1293 t = parse_type (cur_fd, ax, sh->index, (int *)NULL, bigend, name);
1294 add_pending (cur_fdr, ext_sh, t);
1295 }
1296 else
1297 t = pend->t;
1298
1299 /* mips cc puts out a typedef with the name of the struct for forward
1300 declarations. These should not go into the symbol table and
1301 TYPE_NAME should not be set for them.
1302 They can't be distinguished from an intentional typedef to
1303 the same name however:
1304 x.h:
1305 struct x { int ix; int jx; };
1306 struct xx;
1307 x.c:
1308 typedef struct x x;
1309 struct xx {int ixx; int jxx; };
1310 generates a cross referencing stTypedef for x and xx.
1311 The user visible effect of this is that the type of a pointer
1312 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1313 The problem is fixed with alpha cc and Irix5 cc. */
1314
1315 /* However if the typedef cross references to an opaque aggregate, it
1316 is safe to omit it from the symbol table. */
1317
1318 if (has_opaque_xref (cur_fdr, sh))
1319 break;
1320 s = new_symbol (name);
1321 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
1322 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1323 SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
1324 SYMBOL_TYPE (s) = t;
1325 add_symbol (s, top_stack->cur_block);
1326
1327 /* Incomplete definitions of structs should not get a name. */
1328 if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
1329 && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0
1330 || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT
1331 && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION)))
1332 {
1333 if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR
1334 || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC)
1335 {
1336 /* If we are giving a name to a type such as "pointer to
1337 foo" or "function returning foo", we better not set
1338 the TYPE_NAME. If the program contains "typedef char
1339 *caddr_t;", we don't want all variables of type char
1340 * to print as caddr_t. This is not just a
1341 consequence of GDB's type management; CC and GCC (at
1342 least through version 2.4) both output variables of
1343 either type char * or caddr_t with the type
1344 refering to the stTypedef symbol for caddr_t. If a future
1345 compiler cleans this up it GDB is not ready for it
1346 yet, but if it becomes ready we somehow need to
1347 disable this check (without breaking the PCC/GCC2.4
1348 case).
1349
1350 Sigh.
1351
1352 Fortunately, this check seems not to be necessary
1353 for anything except pointers or functions. */
1354 }
1355 else
1356 TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_NAME (s);
1357 }
1358 break;
1359
1360 case stFile: /* file name */
1361 push_parse_stack ();
1362 top_stack->blocktype = sh->st;
1363 break;
1364
1365 /* I`ve never seen these for C */
1366 case stRegReloc:
1367 break; /* register relocation */
1368 case stForward:
1369 break; /* forwarding address */
1370 case stConstant:
1371 break; /* constant */
1372 default:
1373 complain (&unknown_mdebug_symtype_complaint, sh->st);
1374 break;
1375 }
1376
1377 return count;
1378 }
1379
1380 /* Parse the type information provided in the raw AX entries for
1381 the symbol SH. Return the bitfield size in BS, in case.
1382 We must byte-swap the AX entries before we use them; BIGEND says whether
1383 they are big-endian or little-endian (from fh->fBigendian). */
1384
1385 static struct type *
1386 parse_type (fd, ax, aux_index, bs, bigend, sym_name)
1387 int fd;
1388 union aux_ext *ax;
1389 unsigned int aux_index;
1390 int *bs;
1391 int bigend;
1392 char *sym_name;
1393 {
1394 /* Null entries in this map are treated specially */
1395 static struct type **map_bt[] =
1396 {
1397 &mdebug_type_void, /* btNil */
1398 &mdebug_type_adr_32, /* btAdr */
1399 &mdebug_type_char, /* btChar */
1400 &mdebug_type_unsigned_char, /* btUChar */
1401 &mdebug_type_short, /* btShort */
1402 &mdebug_type_unsigned_short, /* btUShort */
1403 &mdebug_type_int_32, /* btInt */
1404 &mdebug_type_unsigned_int_32, /* btUInt */
1405 &mdebug_type_long_32, /* btLong */
1406 &mdebug_type_unsigned_long_32, /* btULong */
1407 &mdebug_type_float, /* btFloat */
1408 &mdebug_type_double, /* btDouble */
1409 0, /* btStruct */
1410 0, /* btUnion */
1411 0, /* btEnum */
1412 0, /* btTypedef */
1413 0, /* btRange */
1414 0, /* btSet */
1415 &mdebug_type_complex, /* btComplex */
1416 &mdebug_type_double_complex, /* btDComplex */
1417 0, /* btIndirect */
1418 &mdebug_type_fixed_dec, /* btFixedDec */
1419 &mdebug_type_float_dec, /* btFloatDec */
1420 &mdebug_type_string, /* btString */
1421 0, /* btBit */
1422 0, /* btPicture */
1423 &mdebug_type_void, /* btVoid */
1424 0, /* DEC C++: Pointer to member */
1425 0, /* DEC C++: Virtual function table */
1426 0, /* DEC C++: Class (Record) */
1427 &mdebug_type_long_64, /* btLong64 */
1428 &mdebug_type_unsigned_long_64, /* btULong64 */
1429 &mdebug_type_long_long_64, /* btLongLong64 */
1430 &mdebug_type_unsigned_long_long_64, /* btULongLong64 */
1431 &mdebug_type_adr_64, /* btAdr64 */
1432 &mdebug_type_int_64, /* btInt64 */
1433 &mdebug_type_unsigned_int_64, /* btUInt64 */
1434 };
1435
1436 TIR t[1];
1437 struct type *tp = 0;
1438 enum type_code type_code = TYPE_CODE_UNDEF;
1439
1440 /* Handle undefined types, they have indexNil. */
1441 if (aux_index == indexNil)
1442 return mdebug_type_int;
1443
1444 /* Handle corrupt aux indices. */
1445 if (aux_index >= (debug_info->fdr + fd)->caux)
1446 {
1447 complain (&index_complaint, sym_name);
1448 return mdebug_type_int;
1449 }
1450 ax += aux_index;
1451
1452 /* Use aux as a type information record, map its basic type. */
1453 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1454 if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt)))
1455 {
1456 complain (&basic_type_complaint, t->bt, sym_name);
1457 return mdebug_type_int;
1458 }
1459 if (map_bt[t->bt])
1460 {
1461 tp = *map_bt[t->bt];
1462 }
1463 else
1464 {
1465 tp = NULL;
1466 /* Cannot use builtin types -- build our own */
1467 switch (t->bt)
1468 {
1469 case btStruct:
1470 type_code = TYPE_CODE_STRUCT;
1471 break;
1472 case btUnion:
1473 type_code = TYPE_CODE_UNION;
1474 break;
1475 case btEnum:
1476 type_code = TYPE_CODE_ENUM;
1477 break;
1478 case btRange:
1479 type_code = TYPE_CODE_RANGE;
1480 break;
1481 case btSet:
1482 type_code = TYPE_CODE_SET;
1483 break;
1484 case btTypedef:
1485 /* alpha cc uses this for typedefs. The true type will be
1486 obtained by crossreferencing below. */
1487 type_code = TYPE_CODE_ERROR;
1488 break;
1489 default:
1490 complain (&basic_type_complaint, t->bt, sym_name);
1491 return mdebug_type_int;
1492 }
1493 }
1494
1495 /* Move on to next aux */
1496 ax++;
1497
1498 if (t->fBitfield)
1499 {
1500 /* Inhibit core dumps with some cfront generated objects that
1501 corrupt the TIR. */
1502 if (bs == (int *)NULL)
1503 {
1504 complain (&bad_fbitfield_complaint, sym_name);
1505 return mdebug_type_int;
1506 }
1507 *bs = AUX_GET_WIDTH (bigend, ax);
1508 ax++;
1509 }
1510
1511 /* All these types really point to some (common) MIPS type
1512 definition, and only the type-qualifiers fully identify
1513 them. We'll make the same effort at sharing. */
1514 if (t->bt == btStruct ||
1515 t->bt == btUnion ||
1516 t->bt == btEnum ||
1517
1518 /* btSet (I think) implies that the name is a tag name, not a typedef
1519 name. This apparently is a MIPS extension for C sets. */
1520 t->bt == btSet)
1521 {
1522 char *name;
1523
1524 /* Try to cross reference this type, build new type on failure. */
1525 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1526 if (tp == (struct type *) NULL)
1527 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1528
1529 /* DEC c89 produces cross references to qualified aggregate types,
1530 dereference them. */
1531 while (TYPE_CODE (tp) == TYPE_CODE_PTR
1532 || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
1533 tp = tp->target_type;
1534
1535 /* Make sure that TYPE_CODE(tp) has an expected type code.
1536 Any type may be returned from cross_ref if file indirect entries
1537 are corrupted. */
1538 if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
1539 && TYPE_CODE (tp) != TYPE_CODE_UNION
1540 && TYPE_CODE (tp) != TYPE_CODE_ENUM)
1541 {
1542 complain (&unexpected_type_code_complaint, sym_name);
1543 }
1544 else
1545 {
1546
1547 /* Usually, TYPE_CODE(tp) is already type_code. The main
1548 exception is if we guessed wrong re struct/union/enum.
1549 But for struct vs. union a wrong guess is harmless, so
1550 don't complain(). */
1551 if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
1552 && type_code != TYPE_CODE_ENUM)
1553 || (TYPE_CODE (tp) != TYPE_CODE_ENUM
1554 && type_code == TYPE_CODE_ENUM))
1555 {
1556 complain (&bad_tag_guess_complaint, sym_name);
1557 }
1558
1559 if (TYPE_CODE (tp) != type_code)
1560 {
1561 TYPE_CODE (tp) = type_code;
1562 }
1563
1564 /* Do not set the tag name if it is a compiler generated tag name
1565 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1566 if (name[0] == '.' || name[0] == '\0')
1567 TYPE_TAG_NAME (tp) = NULL;
1568 else if (TYPE_TAG_NAME (tp) == NULL
1569 || !STREQ (TYPE_TAG_NAME (tp), name))
1570 TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name),
1571 &current_objfile->type_obstack);
1572 }
1573 }
1574
1575 /* All these types really point to some (common) MIPS type
1576 definition, and only the type-qualifiers fully identify
1577 them. We'll make the same effort at sharing.
1578 FIXME: btIndirect cannot happen here as it is handled by the
1579 switch t->bt above. And we are not doing any guessing on range types. */
1580 if (t->bt == btIndirect ||
1581 t->bt == btRange)
1582 {
1583 char *name;
1584
1585 /* Try to cross reference this type, build new type on failure. */
1586 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1587 if (tp == (struct type *) NULL)
1588 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1589
1590 /* Make sure that TYPE_CODE(tp) has an expected type code.
1591 Any type may be returned from cross_ref if file indirect entries
1592 are corrupted. */
1593 if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
1594 {
1595 complain (&unexpected_type_code_complaint, sym_name);
1596 }
1597 else
1598 {
1599 /* Usually, TYPE_CODE(tp) is already type_code. The main
1600 exception is if we guessed wrong re struct/union/enum. */
1601 if (TYPE_CODE (tp) != type_code)
1602 {
1603 complain (&bad_tag_guess_complaint, sym_name);
1604 TYPE_CODE (tp) = type_code;
1605 }
1606 if (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name))
1607 TYPE_NAME (tp) = obsavestring (name, strlen (name),
1608 &current_objfile->type_obstack);
1609 }
1610 }
1611 if (t->bt == btTypedef)
1612 {
1613 char *name;
1614
1615 /* Try to cross reference this type, it should succeed. */
1616 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1617 if (tp == (struct type *) NULL)
1618 {
1619 complain (&unable_to_cross_ref_complaint, sym_name);
1620 tp = mdebug_type_int;
1621 }
1622 }
1623
1624 /* Deal with range types */
1625 if (t->bt == btRange)
1626 {
1627 TYPE_NFIELDS (tp) = 2;
1628 TYPE_FIELDS (tp) = ((struct field *)
1629 TYPE_ALLOC (tp, 2 * sizeof (struct field)));
1630 TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
1631 &current_objfile->type_obstack);
1632 TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
1633 ax++;
1634 TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
1635 &current_objfile->type_obstack);
1636 TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
1637 ax++;
1638 }
1639
1640 /* Parse all the type qualifiers now. If there are more
1641 than 6 the game will continue in the next aux */
1642
1643 while (1)
1644 {
1645 #define PARSE_TQ(tq) \
1646 if (t->tq != tqNil) \
1647 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1648 else \
1649 break;
1650
1651 PARSE_TQ (tq0);
1652 PARSE_TQ (tq1);
1653 PARSE_TQ (tq2);
1654 PARSE_TQ (tq3);
1655 PARSE_TQ (tq4);
1656 PARSE_TQ (tq5);
1657 #undef PARSE_TQ
1658
1659 /* mips cc 2.x and gcc never put out continued aux entries. */
1660 if (!t->continued)
1661 break;
1662
1663 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1664 ax++;
1665 }
1666
1667 /* Complain for illegal continuations due to corrupt aux entries. */
1668 if (t->continued)
1669 complain (&bad_continued_complaint, sym_name);
1670
1671 return tp;
1672 }
1673
1674 /* Make up a complex type from a basic one. Type is passed by
1675 reference in TPP and side-effected as necessary. The type
1676 qualifier TQ says how to handle the aux symbols at AX for
1677 the symbol SX we are currently analyzing. BIGEND says whether
1678 aux symbols are big-endian or little-endian.
1679 Returns the number of aux symbols we parsed. */
1680
1681 static int
1682 upgrade_type (fd, tpp, tq, ax, bigend, sym_name)
1683 int fd;
1684 struct type **tpp;
1685 int tq;
1686 union aux_ext *ax;
1687 int bigend;
1688 char *sym_name;
1689 {
1690 int off;
1691 struct type *t;
1692
1693 /* Used in array processing */
1694 int rf, id;
1695 FDR *fh;
1696 struct type *range;
1697 struct type *indx;
1698 int lower, upper;
1699 RNDXR rndx;
1700
1701 switch (tq)
1702 {
1703 case tqPtr:
1704 t = lookup_pointer_type (*tpp);
1705 *tpp = t;
1706 return 0;
1707
1708 case tqProc:
1709 t = lookup_function_type (*tpp);
1710 *tpp = t;
1711 return 0;
1712
1713 case tqArray:
1714 off = 0;
1715
1716 /* Determine and record the domain type (type of index) */
1717 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx);
1718 id = rndx.index;
1719 rf = rndx.rfd;
1720 if (rf == 0xfff)
1721 {
1722 ax++;
1723 rf = AUX_GET_ISYM (bigend, ax);
1724 off++;
1725 }
1726 fh = get_rfd (fd, rf);
1727
1728 indx = parse_type (fd, debug_info->external_aux + fh->iauxBase,
1729 id, (int *) NULL, bigend, sym_name);
1730
1731 /* The bounds type should be an integer type, but might be anything
1732 else due to corrupt aux entries. */
1733 if (TYPE_CODE (indx) != TYPE_CODE_INT)
1734 {
1735 complain (&array_index_type_complaint, sym_name);
1736 indx = mdebug_type_int;
1737 }
1738
1739 /* Get the bounds, and create the array type. */
1740 ax++;
1741 lower = AUX_GET_DNLOW (bigend, ax);
1742 ax++;
1743 upper = AUX_GET_DNHIGH (bigend, ax);
1744 ax++;
1745 rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */
1746
1747 range = create_range_type ((struct type *) NULL, indx,
1748 lower, upper);
1749
1750 t = create_array_type ((struct type *) NULL, *tpp, range);
1751
1752 /* We used to fill in the supplied array element bitsize
1753 here if the TYPE_LENGTH of the target type was zero.
1754 This happens for a `pointer to an array of anonymous structs',
1755 but in this case the array element bitsize is also zero,
1756 so nothing is gained.
1757 And we used to check the TYPE_LENGTH of the target type against
1758 the supplied array element bitsize.
1759 gcc causes a mismatch for `pointer to array of object',
1760 since the sdb directives it uses do not have a way of
1761 specifying the bitsize, but it does no harm (the
1762 TYPE_LENGTH should be correct) and we should be able to
1763 ignore the erroneous bitsize from the auxiliary entry safely.
1764 dbx seems to ignore it too. */
1765
1766 *tpp = t;
1767 return 4 + off;
1768
1769 case tqVol:
1770 /* Volatile -- currently ignored */
1771 return 0;
1772
1773 case tqConst:
1774 /* Const -- currently ignored */
1775 return 0;
1776
1777 default:
1778 complain (&unknown_type_qual_complaint, tq);
1779 return 0;
1780 }
1781 }
1782
1783
1784 /* Parse a procedure descriptor record PR. Note that the procedure is
1785 parsed _after_ the local symbols, now we just insert the extra
1786 information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
1787 already been placed in the procedure's main block. Note also that
1788 images that have been partially stripped (ld -x) have been deprived
1789 of local symbols, and we have to cope with them here. FIRST_OFF is
1790 the offset of the first procedure for this FDR; we adjust the
1791 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1792 to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
1793 in question, or NULL to use top_stack->cur_block. */
1794
1795 static void parse_procedure PARAMS ((PDR *, struct symtab *, unsigned long,
1796 struct partial_symtab *));
1797
1798 static void
1799 parse_procedure (pr, search_symtab, first_off, pst)
1800 PDR *pr;
1801 struct symtab *search_symtab;
1802 unsigned long first_off;
1803 struct partial_symtab *pst;
1804 {
1805 struct symbol *s, *i;
1806 struct block *b;
1807 struct mips_extra_func_info *e;
1808 char *sh_name;
1809
1810 /* Simple rule to find files linked "-x" */
1811 if (cur_fdr->rss == -1)
1812 {
1813 if (pr->isym == -1)
1814 {
1815 /* Static procedure at address pr->adr. Sigh. */
1816 /* FIXME-32x64. assuming pr->adr fits in long. */
1817 complain (&pdr_static_symbol_complaint, (unsigned long) pr->adr);
1818 return;
1819 }
1820 else
1821 {
1822 /* external */
1823 EXTR she;
1824
1825 (*debug_swap->swap_ext_in) (cur_bfd,
1826 ((char *) debug_info->external_ext
1827 + (pr->isym
1828 * debug_swap->external_ext_size)),
1829 &she);
1830 sh_name = debug_info->ssext + she.asym.iss;
1831 }
1832 }
1833 else
1834 {
1835 /* Full symbols */
1836 SYMR sh;
1837
1838 (*debug_swap->swap_sym_in) (cur_bfd,
1839 ((char *) debug_info->external_sym
1840 + ((cur_fdr->isymBase + pr->isym)
1841 * debug_swap->external_sym_size)),
1842 &sh);
1843 sh_name = debug_info->ss + cur_fdr->issBase + sh.iss;
1844 }
1845
1846 if (search_symtab != NULL)
1847 {
1848 #if 0
1849 /* This loses both in the case mentioned (want a static, find a global),
1850 but also if we are looking up a non-mangled name which happens to
1851 match the name of a mangled function. */
1852 /* We have to save the cur_fdr across the call to lookup_symbol.
1853 If the pdr is for a static function and if a global function with
1854 the same name exists, lookup_symbol will eventually read in the symtab
1855 for the global function and clobber cur_fdr. */
1856 FDR *save_cur_fdr = cur_fdr;
1857 s = lookup_symbol (sh_name, NULL, VAR_NAMESPACE, 0, NULL);
1858 cur_fdr = save_cur_fdr;
1859 #else
1860 s = mylookup_symbol
1861 (sh_name,
1862 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
1863 VAR_NAMESPACE,
1864 LOC_BLOCK);
1865 #endif
1866 }
1867 else
1868 s = mylookup_symbol (sh_name, top_stack->cur_block,
1869 VAR_NAMESPACE, LOC_BLOCK);
1870
1871 if (s != 0)
1872 {
1873 b = SYMBOL_BLOCK_VALUE (s);
1874 }
1875 else
1876 {
1877 complain (&pdr_for_nonsymbol_complaint, sh_name);
1878 #if 1
1879 return;
1880 #else
1881 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */
1882 s = new_symbol (sh_name);
1883 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
1884 SYMBOL_CLASS (s) = LOC_BLOCK;
1885 /* Donno its type, hope int is ok */
1886 SYMBOL_TYPE (s) = lookup_function_type (mdebug_type_int);
1887 add_symbol (s, top_stack->cur_block);
1888 /* Wont have symbols for this one */
1889 b = new_block (2);
1890 SYMBOL_BLOCK_VALUE (s) = b;
1891 BLOCK_FUNCTION (b) = s;
1892 BLOCK_START (b) = pr->adr;
1893 /* BOUND used to be the end of procedure's text, but the
1894 argument is no longer passed in. */
1895 BLOCK_END (b) = bound;
1896 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1897 add_block (b, top_stack->cur_st);
1898 #endif
1899 }
1900
1901 i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, LOC_CONST);
1902
1903 if (i)
1904 {
1905 e = (struct mips_extra_func_info *) SYMBOL_VALUE (i);
1906 e->pdr = *pr;
1907 e->pdr.isym = (long) s;
1908 e->pdr.adr += pst->textlow - first_off;
1909
1910 /* Correct incorrect setjmp procedure descriptor from the library
1911 to make backtrace through setjmp work. */
1912 if (e->pdr.pcreg == 0 && STREQ (sh_name, "setjmp"))
1913 {
1914 complain (&bad_setjmp_pdr_complaint, 0);
1915 e->pdr.pcreg = RA_REGNUM;
1916 e->pdr.regmask = 0x80000000;
1917 e->pdr.regoffset = -4;
1918 }
1919 }
1920
1921 /* It would be reasonable that functions that have been compiled
1922 without debugging info have a btNil type for their return value,
1923 and functions that are void and are compiled with debugging info
1924 have btVoid.
1925 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
1926 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
1927 case right.
1928 The glevel field in cur_fdr could be used to determine the presence
1929 of debugging info, but GCC doesn't always pass the -g switch settings
1930 to the assembler and GAS doesn't set the glevel field from the -g switch
1931 settings.
1932 To work around these problems, the return value type of a TYPE_CODE_VOID
1933 function is adjusted accordingly if no debugging info was found in the
1934 compilation unit. */
1935
1936 if (processing_gcc_compilation == 0
1937 && found_ecoff_debugging_info == 0
1938 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
1939 SYMBOL_TYPE (s) = nodebug_func_symbol_type;
1940 }
1941
1942 /* Relocate the extra function info pointed to by the symbol table. */
1943
1944 void
1945 ecoff_relocate_efi (sym, delta)
1946 struct symbol *sym;
1947 CORE_ADDR delta;
1948 {
1949 struct mips_extra_func_info *e;
1950
1951 e = (struct mips_extra_func_info *) SYMBOL_VALUE (sym);
1952
1953 e->pdr.adr += delta;
1954 }
1955
1956 /* Parse the external symbol ES. Just call parse_symbol() after
1957 making sure we know where the aux are for it.
1958 BIGEND says whether aux entries are big-endian or little-endian.
1959
1960 This routine clobbers top_stack->cur_block and ->cur_st. */
1961
1962 static void parse_external PARAMS ((EXTR *, int, struct section_offsets *));
1963
1964 static void
1965 parse_external (es, bigend, section_offsets)
1966 EXTR *es;
1967 int bigend;
1968 struct section_offsets *section_offsets;
1969 {
1970 union aux_ext *ax;
1971
1972 if (es->ifd != ifdNil)
1973 {
1974 cur_fd = es->ifd;
1975 cur_fdr = debug_info->fdr + cur_fd;
1976 ax = debug_info->external_aux + cur_fdr->iauxBase;
1977 }
1978 else
1979 {
1980 cur_fdr = debug_info->fdr;
1981 ax = 0;
1982 }
1983
1984 /* Reading .o files */
1985 if (es->asym.sc == scUndefined || es->asym.sc == scNil)
1986 {
1987 char *what;
1988 switch (es->asym.st)
1989 {
1990 case stNil:
1991 /* These are generated for static symbols in .o files,
1992 ignore them. */
1993 return;
1994 case stStaticProc:
1995 case stProc:
1996 what = "procedure";
1997 n_undef_procs++;
1998 break;
1999 case stGlobal:
2000 what = "variable";
2001 n_undef_vars++;
2002 break;
2003 case stLabel:
2004 what = "label";
2005 n_undef_labels++;
2006 break;
2007 default:
2008 what = "symbol";
2009 break;
2010 }
2011 n_undef_symbols++;
2012 /* FIXME: Turn this into a complaint? */
2013 if (info_verbose)
2014 printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
2015 what, debug_info->ssext + es->asym.iss,
2016 fdr_name (cur_fdr));
2017 return;
2018 }
2019
2020 switch (es->asym.st)
2021 {
2022 case stProc:
2023 case stStaticProc:
2024 /* There is no need to parse the external procedure symbols.
2025 If they are from objects compiled without -g, their index will
2026 be indexNil, and the symbol definition from the minimal symbol
2027 is preferrable (yielding a function returning int instead of int).
2028 If the index points to a local procedure symbol, the local
2029 symbol already provides the correct type.
2030 Note that the index of the external procedure symbol points
2031 to the local procedure symbol in the local symbol table, and
2032 _not_ to the auxiliary symbol info. */
2033 break;
2034 case stGlobal:
2035 case stLabel:
2036 /* Global common symbols are resolved by the runtime loader,
2037 ignore them. */
2038 if (es->asym.sc == scCommon || es->asym.sc == scSCommon)
2039 break;
2040
2041 /* Note that the case of a symbol with indexNil must be handled
2042 anyways by parse_symbol(). */
2043 parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets);
2044 break;
2045 default:
2046 break;
2047 }
2048 }
2049
2050 /* Parse the line number info for file descriptor FH into
2051 GDB's linetable LT. MIPS' encoding requires a little bit
2052 of magic to get things out. Note also that MIPS' line
2053 numbers can go back and forth, apparently we can live
2054 with that and do not need to reorder our linetables */
2055
2056 static void parse_lines PARAMS ((FDR *, PDR *, struct linetable *, int,
2057 struct partial_symtab *));
2058
2059 static void
2060 parse_lines (fh, pr, lt, maxlines, pst)
2061 FDR *fh;
2062 PDR *pr;
2063 struct linetable *lt;
2064 int maxlines;
2065 struct partial_symtab *pst;
2066 {
2067 unsigned char *base;
2068 int j, k;
2069 int delta, count, lineno = 0;
2070 unsigned long first_off = pr->adr;
2071
2072 if (fh->cbLine == 0)
2073 return;
2074
2075 /* Scan by procedure descriptors */
2076 k = 0;
2077 for (j = 0; j < fh->cpd; j++, pr++)
2078 {
2079 long l;
2080 unsigned long adr;
2081 unsigned char *halt;
2082
2083 /* No code for this one */
2084 if (pr->iline == ilineNil ||
2085 pr->lnLow == -1 || pr->lnHigh == -1)
2086 continue;
2087
2088 /* Determine start and end address of compressed line bytes for
2089 this procedure. */
2090 base = debug_info->line + fh->cbLineOffset;
2091 if (j != (fh->cpd - 1))
2092 halt = base + pr[1].cbLineOffset;
2093 else
2094 halt = base + fh->cbLine;
2095 base += pr->cbLineOffset;
2096
2097 adr = pst->textlow + pr->adr - first_off;
2098
2099 l = adr >> 2; /* in words */
2100 for (lineno = pr->lnLow; base < halt; )
2101 {
2102 count = *base & 0x0f;
2103 delta = *base++ >> 4;
2104 if (delta >= 8)
2105 delta -= 16;
2106 if (delta == -8)
2107 {
2108 delta = (base[0] << 8) | base[1];
2109 if (delta >= 0x8000)
2110 delta -= 0x10000;
2111 base += 2;
2112 }
2113 lineno += delta; /* first delta is 0 */
2114
2115 /* Complain if the line table overflows. Could happen
2116 with corrupt binaries. */
2117 if (lt->nitems >= maxlines)
2118 {
2119 complain (&bad_linetable_guess_complaint, fdr_name (fh));
2120 break;
2121 }
2122 k = add_line (lt, lineno, l, k);
2123 l += count + 1;
2124 }
2125 }
2126 }
2127 \f
2128 /* Master parsing procedure for first-pass reading of file symbols
2129 into a partial_symtab. */
2130
2131 static void
2132 parse_partial_symbols (objfile, section_offsets)
2133 struct objfile *objfile;
2134 struct section_offsets *section_offsets;
2135 {
2136 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
2137 const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
2138 const bfd_size_type external_ext_size = debug_swap->external_ext_size;
2139 void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
2140 = debug_swap->swap_ext_in;
2141 void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
2142 = debug_swap->swap_sym_in;
2143 void (* const swap_rfd_in) PARAMS ((bfd *, PTR, RFDT *))
2144 = debug_swap->swap_rfd_in;
2145 int f_idx, s_idx;
2146 HDRR *hdr = &debug_info->symbolic_header;
2147 /* Running pointers */
2148 FDR *fh;
2149 char *ext_out;
2150 char *ext_out_end;
2151 EXTR *ext_block;
2152 register EXTR *ext_in;
2153 EXTR *ext_in_end;
2154 SYMR sh;
2155 struct partial_symtab *pst;
2156
2157 int past_first_source_file = 0;
2158
2159 /* List of current psymtab's include files */
2160 char **psymtab_include_list;
2161 int includes_allocated;
2162 int includes_used;
2163 EXTR *extern_tab;
2164 struct pst_map *fdr_to_pst;
2165 /* Index within current psymtab dependency list */
2166 struct partial_symtab **dependency_list;
2167 int dependencies_used, dependencies_allocated;
2168 struct cleanup *old_chain;
2169 char *name;
2170 enum language prev_language;
2171 asection *text_sect;
2172 int relocatable = 0;
2173
2174 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2175 the shared libraries are prelinked at a high memory address.
2176 We have to adjust the start address of the object file for this case,
2177 by setting it to the start address of the first procedure in the file.
2178 But we should do no adjustments if we are debugging a .o file, where
2179 the text section (and fh->adr) really starts at zero. */
2180 text_sect = bfd_get_section_by_name (cur_bfd, ".text");
2181 if (text_sect != NULL
2182 && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
2183 relocatable = 1;
2184
2185 extern_tab = (EXTR *) obstack_alloc (&objfile->psymbol_obstack,
2186 sizeof (EXTR) * hdr->iextMax);
2187
2188 includes_allocated = 30;
2189 includes_used = 0;
2190 psymtab_include_list = (char **) alloca (includes_allocated *
2191 sizeof (char *));
2192 next_symbol_text_func = mdebug_next_symbol_text;
2193
2194 dependencies_allocated = 30;
2195 dependencies_used = 0;
2196 dependency_list =
2197 (struct partial_symtab **) alloca (dependencies_allocated *
2198 sizeof (struct partial_symtab *));
2199
2200 last_source_file = NULL;
2201
2202 /*
2203 * Big plan:
2204 *
2205 * Only parse the Local and External symbols, and the Relative FDR.
2206 * Fixup enough of the loader symtab to be able to use it.
2207 * Allocate space only for the file's portions we need to
2208 * look at. (XXX)
2209 */
2210
2211 max_gdbinfo = 0;
2212 max_glevel = MIN_GLEVEL;
2213
2214 /* Allocate the map FDR -> PST.
2215 Minor hack: -O3 images might claim some global data belongs
2216 to FDR -1. We`ll go along with that */
2217 fdr_to_pst = (struct pst_map *) xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
2218 old_chain = make_cleanup (free, fdr_to_pst);
2219 fdr_to_pst++;
2220 {
2221 struct partial_symtab *pst = new_psymtab ("", objfile, section_offsets);
2222 fdr_to_pst[-1].pst = pst;
2223 FDR_IDX (pst) = -1;
2224 }
2225
2226 /* Allocate the global pending list. */
2227 pending_list =
2228 ((struct mdebug_pending **)
2229 obstack_alloc (&objfile->psymbol_obstack,
2230 hdr->ifdMax * sizeof (struct mdebug_pending *)));
2231 memset ((PTR) pending_list, 0,
2232 hdr->ifdMax * sizeof (struct mdebug_pending *));
2233
2234 /* Pass 0 over external syms: swap them in. */
2235 ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
2236 make_cleanup (free, ext_block);
2237
2238 ext_out = (char *) debug_info->external_ext;
2239 ext_out_end = ext_out + hdr->iextMax * external_ext_size;
2240 ext_in = ext_block;
2241 for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
2242 (*swap_ext_in) (cur_bfd, ext_out, ext_in);
2243
2244 /* Pass 1 over external syms: Presize and partition the list */
2245 ext_in = ext_block;
2246 ext_in_end = ext_in + hdr->iextMax;
2247 for (; ext_in < ext_in_end; ext_in++)
2248 {
2249 /* See calls to complain below. */
2250 if (ext_in->ifd >= -1
2251 && ext_in->ifd < hdr->ifdMax
2252 && ext_in->asym.iss >= 0
2253 && ext_in->asym.iss < hdr->issExtMax)
2254 fdr_to_pst[ext_in->ifd].n_globals++;
2255 }
2256
2257 /* Pass 1.5 over files: partition out global symbol space */
2258 s_idx = 0;
2259 for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++)
2260 {
2261 fdr_to_pst[f_idx].globals_offset = s_idx;
2262 s_idx += fdr_to_pst[f_idx].n_globals;
2263 fdr_to_pst[f_idx].n_globals = 0;
2264 }
2265
2266 /* Pass 2 over external syms: fill in external symbols */
2267 ext_in = ext_block;
2268 ext_in_end = ext_in + hdr->iextMax;
2269 for (; ext_in < ext_in_end; ext_in++)
2270 {
2271 enum minimal_symbol_type ms_type = mst_text;
2272 CORE_ADDR svalue = ext_in->asym.value;
2273
2274 /* The Irix 5 native tools seem to sometimes generate bogus
2275 external symbols. */
2276 if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
2277 {
2278 complain (&bad_ext_ifd_complaint, ext_in->ifd, hdr->ifdMax);
2279 continue;
2280 }
2281 if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
2282 {
2283 complain (&bad_ext_iss_complaint, ext_in->asym.iss,
2284 hdr->issExtMax);
2285 continue;
2286 }
2287
2288 extern_tab[fdr_to_pst[ext_in->ifd].globals_offset
2289 + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in;
2290
2291 if (ext_in->asym.sc == scUndefined || ext_in->asym.sc == scNil)
2292 continue;
2293
2294 name = debug_info->ssext + ext_in->asym.iss;
2295 switch (ext_in->asym.st)
2296 {
2297 case stProc:
2298 svalue += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2299 break;
2300 case stStaticProc:
2301 ms_type = mst_file_text;
2302 svalue += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2303 break;
2304 case stGlobal:
2305 if (ext_in->asym.sc == scCommon || ext_in->asym.sc == scSCommon)
2306 {
2307 /* The value of a common symbol is its size, not its address.
2308 Ignore it. */
2309 continue;
2310 }
2311 else if (ext_in->asym.sc == scData
2312 || ext_in->asym.sc == scSData
2313 || ext_in->asym.sc == scRData
2314 || ext_in->asym.sc == scPData
2315 || ext_in->asym.sc == scXData)
2316 {
2317 ms_type = mst_data;
2318 svalue += ANOFFSET (section_offsets, SECT_OFF_DATA);
2319 }
2320 else
2321 {
2322 ms_type = mst_bss;
2323 svalue += ANOFFSET (section_offsets, SECT_OFF_BSS);
2324 }
2325 break;
2326 case stLabel:
2327 if (ext_in->asym.sc == scAbs)
2328 ms_type = mst_abs;
2329 else if (ext_in->asym.sc == scText
2330 || ext_in->asym.sc == scInit
2331 || ext_in->asym.sc == scFini)
2332 {
2333 ms_type = mst_file_text;
2334 svalue += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2335 }
2336 else if (ext_in->asym.sc == scData
2337 || ext_in->asym.sc == scSData
2338 || ext_in->asym.sc == scRData
2339 || ext_in->asym.sc == scPData
2340 || ext_in->asym.sc == scXData)
2341 {
2342 ms_type = mst_file_data;
2343 svalue += ANOFFSET (section_offsets, SECT_OFF_DATA);
2344 }
2345 else
2346 {
2347 ms_type = mst_file_bss;
2348 svalue += ANOFFSET (section_offsets, SECT_OFF_BSS);
2349 }
2350 break;
2351 case stLocal:
2352 /* The alpha has the section start addresses in stLocal symbols
2353 whose name starts with a `.'. Skip those but complain for all
2354 other stLocal symbols. */
2355 if (name[0] == '.')
2356 continue;
2357 /* Fall through. */
2358 default:
2359 ms_type = mst_unknown;
2360 complain (&unknown_ext_complaint, name);
2361 }
2362 prim_record_minimal_symbol (name, svalue, ms_type, objfile);
2363 }
2364
2365 /* Pass 3 over files, over local syms: fill in static symbols */
2366 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
2367 {
2368 struct partial_symtab *save_pst;
2369 EXTR *ext_ptr;
2370 CORE_ADDR textlow;
2371
2372 cur_fdr = fh = debug_info->fdr + f_idx;
2373
2374 if (fh->csym == 0)
2375 {
2376 fdr_to_pst[f_idx].pst = NULL;
2377 continue;
2378 }
2379
2380 /* Determine the start address for this object file from the
2381 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2382 if (fh->cpd)
2383 {
2384 textlow = fh->adr;
2385 if (relocatable || textlow != 0)
2386 textlow += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2387 }
2388 else
2389 textlow = 0;
2390 pst = start_psymtab_common (objfile, section_offsets,
2391 fdr_name (fh),
2392 textlow,
2393 objfile->global_psymbols.next,
2394 objfile->static_psymbols.next);
2395 pst->read_symtab_private = ((char *)
2396 obstack_alloc (&objfile->psymbol_obstack,
2397 sizeof (struct symloc)));
2398 memset ((PTR) pst->read_symtab_private, 0, sizeof (struct symloc));
2399
2400 save_pst = pst;
2401 FDR_IDX (pst) = f_idx;
2402 CUR_BFD (pst) = cur_bfd;
2403 DEBUG_SWAP (pst) = debug_swap;
2404 DEBUG_INFO (pst) = debug_info;
2405 PENDING_LIST (pst) = pending_list;
2406
2407 /* The way to turn this into a symtab is to call... */
2408 pst->read_symtab = mdebug_psymtab_to_symtab;
2409
2410 /* Set up language for the pst.
2411 The language from the FDR is used if it is unambigious (e.g. cfront
2412 with native cc and g++ will set the language to C).
2413 Otherwise we have to deduce the language from the filename.
2414 Native ecoff has every header file in a separate FDR, so
2415 deduce_language_from_filename will return language_unknown for
2416 a header file, which is not what we want.
2417 But the FDRs for the header files are after the FDR for the source
2418 file, so we can assign the language of the source file to the
2419 following header files. Then we save the language in the private
2420 pst data so that we can reuse it when building symtabs. */
2421 prev_language = psymtab_language;
2422
2423 switch (fh->lang)
2424 {
2425 case langCplusplusV2:
2426 psymtab_language = language_cplus;
2427 break;
2428 default:
2429 psymtab_language = deduce_language_from_filename (fdr_name (fh));
2430 break;
2431 }
2432 if (psymtab_language == language_unknown)
2433 psymtab_language = prev_language;
2434 PST_PRIVATE (pst)->pst_language = psymtab_language;
2435
2436 pst->texthigh = pst->textlow;
2437
2438 /* For stabs-in-ecoff files, the second symbol must be @stab.
2439 This symbol is emitted by mips-tfile to signal that the
2440 current object file uses encapsulated stabs instead of mips
2441 ecoff for local symbols. (It is the second symbol because
2442 the first symbol is the stFile used to signal the start of a
2443 file). */
2444 processing_gcc_compilation = 0;
2445 if (fh->csym >= 2)
2446 {
2447 (*swap_sym_in) (cur_bfd,
2448 ((char *) debug_info->external_sym
2449 + (fh->isymBase + 1) * external_sym_size),
2450 &sh);
2451 if (STREQ (debug_info->ss + fh->issBase + sh.iss, stabs_symbol))
2452 processing_gcc_compilation = 2;
2453 }
2454
2455 if (processing_gcc_compilation != 0)
2456 {
2457 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
2458 {
2459 int type_code;
2460 char *namestring;
2461
2462 (*swap_sym_in) (cur_bfd,
2463 (((char *) debug_info->external_sym)
2464 + (fh->isymBase + cur_sdx) * external_sym_size),
2465 &sh);
2466 type_code = ECOFF_UNMARK_STAB (sh.index);
2467 if (!ECOFF_IS_STAB (&sh))
2468 {
2469 if (sh.st == stProc || sh.st == stStaticProc)
2470 {
2471 long procaddr;
2472 long isym;
2473
2474 sh.value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2475 if (sh.st == stStaticProc)
2476 {
2477 namestring = debug_info->ss + fh->issBase + sh.iss;
2478 prim_record_minimal_symbol_and_info (namestring,
2479 sh.value,
2480 mst_file_text,
2481 NULL,
2482 SECT_OFF_TEXT,
2483 objfile);
2484 }
2485 procaddr = sh.value;
2486
2487 isym = AUX_GET_ISYM (fh->fBigendian,
2488 (debug_info->external_aux
2489 + fh->iauxBase
2490 + sh.index));
2491 (*swap_sym_in) (cur_bfd,
2492 ((char *) debug_info->external_sym
2493 + ((fh->isymBase + isym - 1)
2494 * external_sym_size)),
2495 &sh);
2496 if (sh.st == stEnd)
2497 {
2498 long high = procaddr + sh.value;
2499
2500 /* Kludge for Irix 5.2 zero fh->adr. */
2501 if (!relocatable
2502 && (pst->textlow == 0 || procaddr < pst->textlow))
2503 pst->textlow = procaddr;
2504 if (high > pst->texthigh)
2505 pst->texthigh = high;
2506 }
2507 }
2508 else if (sh.st == stStatic)
2509 {
2510 switch (sh.sc)
2511 {
2512 case scUndefined:
2513 case scNil:
2514 case scAbs:
2515 break;
2516
2517 case scData:
2518 case scSData:
2519 case scRData:
2520 case scPData:
2521 case scXData:
2522 namestring = debug_info->ss + fh->issBase + sh.iss;
2523 sh.value += ANOFFSET (section_offsets, SECT_OFF_DATA);
2524 prim_record_minimal_symbol_and_info (namestring,
2525 sh.value,
2526 mst_file_data,
2527 NULL,
2528 SECT_OFF_DATA,
2529 objfile);
2530 break;
2531
2532 default:
2533 namestring = debug_info->ss + fh->issBase + sh.iss;
2534 sh.value += ANOFFSET (section_offsets, SECT_OFF_BSS);
2535 prim_record_minimal_symbol_and_info (namestring,
2536 sh.value,
2537 mst_file_bss,
2538 NULL,
2539 SECT_OFF_BSS,
2540 objfile);
2541 break;
2542 }
2543 }
2544 continue;
2545 }
2546 #define SET_NAMESTRING() \
2547 namestring = debug_info->ss + fh->issBase + sh.iss
2548 #define CUR_SYMBOL_TYPE type_code
2549 #define CUR_SYMBOL_VALUE sh.value
2550 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
2551 pst = save_pst
2552 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
2553 #define HANDLE_RBRAC(val) \
2554 if ((val) > save_pst->texthigh) save_pst->texthigh = (val);
2555 #include "partial-stab.h"
2556 }
2557 }
2558 else
2559 {
2560 for (cur_sdx = 0; cur_sdx < fh->csym;)
2561 {
2562 char *name;
2563 enum address_class class;
2564
2565 (*swap_sym_in) (cur_bfd,
2566 ((char *) debug_info->external_sym
2567 + ((fh->isymBase + cur_sdx)
2568 * external_sym_size)),
2569 &sh);
2570
2571 if (ECOFF_IS_STAB (&sh))
2572 {
2573 cur_sdx++;
2574 continue;
2575 }
2576
2577 /* Non absolute static symbols go into the minimal table. */
2578 if (sh.sc == scUndefined || sh.sc == scNil
2579 || (sh.index == indexNil
2580 && (sh.st != stStatic || sh.sc == scAbs)))
2581 {
2582 /* FIXME, premature? */
2583 cur_sdx++;
2584 continue;
2585 }
2586
2587 name = debug_info->ss + fh->issBase + sh.iss;
2588
2589 switch (sh.sc)
2590 {
2591 case scText:
2592 /* The value of a stEnd symbol is the displacement from the
2593 corresponding start symbol value, do not relocate it. */
2594 if (sh.st != stEnd)
2595 sh.value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2596 break;
2597 case scData:
2598 case scSData:
2599 case scRData:
2600 case scPData:
2601 case scXData:
2602 sh.value += ANOFFSET (section_offsets, SECT_OFF_DATA);
2603 break;
2604 case scBss:
2605 case scSBss:
2606 sh.value += ANOFFSET (section_offsets, SECT_OFF_BSS);
2607 break;
2608 }
2609
2610 switch (sh.st)
2611 {
2612 long high;
2613 long procaddr;
2614 int new_sdx;
2615
2616 case stStaticProc:
2617 prim_record_minimal_symbol_and_info (name, sh.value,
2618 mst_file_text, NULL,
2619 SECT_OFF_TEXT, objfile);
2620
2621 /* FALLTHROUGH */
2622
2623 case stProc:
2624 /* Usually there is a local and a global stProc symbol
2625 for a function. This means that the function name
2626 has already been entered into the mimimal symbol table
2627 while processing the global symbols in pass 2 above.
2628 One notable exception is the PROGRAM name from
2629 f77 compiled executables, it is only put out as
2630 local stProc symbol, and a global MAIN__ stProc symbol
2631 points to it. It doesn't matter though, as gdb is
2632 still able to find the PROGRAM name via the partial
2633 symbol table, and the MAIN__ symbol via the minimal
2634 symbol table. */
2635 if (sh.st == stProc)
2636 ADD_PSYMBOL_TO_LIST (name, strlen (name),
2637 VAR_NAMESPACE, LOC_BLOCK,
2638 objfile->global_psymbols,
2639 sh.value, psymtab_language, objfile);
2640 else
2641 ADD_PSYMBOL_TO_LIST (name, strlen (name),
2642 VAR_NAMESPACE, LOC_BLOCK,
2643 objfile->static_psymbols,
2644 sh.value, psymtab_language, objfile);
2645
2646 /* Skip over procedure to next one. */
2647 if (sh.index >= hdr->iauxMax)
2648 {
2649 /* Should not happen, but does when cross-compiling
2650 with the MIPS compiler. FIXME -- pull later. */
2651 complain (&index_complaint, name);
2652 new_sdx = cur_sdx + 1; /* Don't skip at all */
2653 }
2654 else
2655 new_sdx = AUX_GET_ISYM (fh->fBigendian,
2656 (debug_info->external_aux
2657 + fh->iauxBase
2658 + sh.index));
2659 procaddr = sh.value;
2660
2661 if (new_sdx <= cur_sdx)
2662 {
2663 /* This should not happen either... FIXME. */
2664 complain (&aux_index_complaint, name);
2665 new_sdx = cur_sdx + 1; /* Don't skip backward */
2666 }
2667
2668 cur_sdx = new_sdx;
2669 (*swap_sym_in) (cur_bfd,
2670 ((char *) debug_info->external_sym
2671 + ((fh->isymBase + cur_sdx - 1)
2672 * external_sym_size)),
2673 &sh);
2674 if (sh.st != stEnd)
2675 continue;
2676
2677 /* Kludge for Irix 5.2 zero fh->adr. */
2678 if (!relocatable
2679 && (pst->textlow == 0 || procaddr < pst->textlow))
2680 pst->textlow = procaddr;
2681
2682 high = procaddr + sh.value;
2683 if (high > pst->texthigh)
2684 pst->texthigh = high;
2685 continue;
2686
2687 case stStatic: /* Variable */
2688 if (sh.sc == scData
2689 || sh.sc == scSData
2690 || sh.sc == scRData
2691 || sh.sc == scPData
2692 || sh.sc == scXData)
2693 prim_record_minimal_symbol_and_info (name, sh.value,
2694 mst_file_data, NULL,
2695 SECT_OFF_DATA,
2696 objfile);
2697 else
2698 prim_record_minimal_symbol_and_info (name, sh.value,
2699 mst_file_bss, NULL,
2700 SECT_OFF_BSS,
2701 objfile);
2702 class = LOC_STATIC;
2703 break;
2704
2705 case stIndirect:/* Irix5 forward declaration */
2706 /* Skip forward declarations from Irix5 cc */
2707 goto skip;
2708
2709 case stTypedef:/* Typedef */
2710 /* Skip typedefs for forward declarations and opaque
2711 structs from alpha and mips cc. */
2712 if (sh.iss == 0 || has_opaque_xref (fh, &sh))
2713 goto skip;
2714 class = LOC_TYPEDEF;
2715 break;
2716
2717 case stConstant: /* Constant decl */
2718 class = LOC_CONST;
2719 break;
2720
2721 case stUnion:
2722 case stStruct:
2723 case stEnum:
2724 case stBlock: /* { }, str, un, enum*/
2725 /* Do not create a partial symbol for cc unnamed aggregates
2726 and gcc empty aggregates. */
2727 if ((sh.sc == scInfo
2728 || sh.sc == scCommon || sh.sc == scSCommon)
2729 && sh.iss != 0
2730 && sh.index != cur_sdx + 2)
2731 {
2732 ADD_PSYMBOL_TO_LIST (name, strlen (name),
2733 STRUCT_NAMESPACE, LOC_TYPEDEF,
2734 objfile->static_psymbols,
2735 sh.value,
2736 psymtab_language, objfile);
2737 }
2738 handle_psymbol_enumerators (objfile, fh, sh.st);
2739
2740 /* Skip over the block */
2741 new_sdx = sh.index;
2742 if (new_sdx <= cur_sdx)
2743 {
2744 /* This happens with the Ultrix kernel. */
2745 complain (&block_index_complaint, name);
2746 new_sdx = cur_sdx + 1; /* Don't skip backward */
2747 }
2748 cur_sdx = new_sdx;
2749 continue;
2750
2751 case stFile: /* File headers */
2752 case stLabel: /* Labels */
2753 case stEnd: /* Ends of files */
2754 goto skip;
2755
2756 case stLocal: /* Local variables */
2757 /* Normally these are skipped because we skip over
2758 all blocks we see. However, these can occur
2759 as visible symbols in a .h file that contains code. */
2760 goto skip;
2761
2762 default:
2763 /* Both complaints are valid: one gives symbol name,
2764 the other the offending symbol type. */
2765 complain (&unknown_sym_complaint, name);
2766 complain (&unknown_st_complaint, sh.st);
2767 cur_sdx++;
2768 continue;
2769 }
2770 /* Use this gdb symbol */
2771 ADD_PSYMBOL_TO_LIST (name, strlen (name),
2772 VAR_NAMESPACE, class,
2773 objfile->static_psymbols, sh.value,
2774 psymtab_language, objfile);
2775 skip:
2776 cur_sdx++; /* Go to next file symbol */
2777 }
2778
2779 /* Now do enter the external symbols. */
2780 ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset];
2781 cur_sdx = fdr_to_pst[f_idx].n_globals;
2782 PST_PRIVATE (save_pst)->extern_count = cur_sdx;
2783 PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
2784 for (; --cur_sdx >= 0; ext_ptr++)
2785 {
2786 enum address_class class;
2787 SYMR *psh;
2788 char *name;
2789 CORE_ADDR svalue;
2790
2791 if (ext_ptr->ifd != f_idx)
2792 abort ();
2793 psh = &ext_ptr->asym;
2794
2795 /* Do not add undefined symbols to the partial symbol table. */
2796 if (psh->sc == scUndefined || psh->sc == scNil)
2797 continue;
2798
2799 svalue = psh->value;
2800 switch (psh->sc)
2801 {
2802 case scText:
2803 svalue += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2804 break;
2805 case scData:
2806 case scSData:
2807 case scRData:
2808 case scPData:
2809 case scXData:
2810 svalue += ANOFFSET (section_offsets, SECT_OFF_DATA);
2811 break;
2812 case scBss:
2813 case scSBss:
2814 svalue += ANOFFSET (section_offsets, SECT_OFF_BSS);
2815 break;
2816 }
2817
2818 switch (psh->st)
2819 {
2820 case stNil:
2821 /* These are generated for static symbols in .o files,
2822 ignore them. */
2823 continue;
2824 case stProc:
2825 case stStaticProc:
2826 /* External procedure symbols have been entered
2827 into the minimal symbol table in pass 2 above.
2828 Ignore them, as parse_external will ignore them too. */
2829 continue;
2830 case stLabel:
2831 class = LOC_LABEL;
2832 break;
2833 default:
2834 complain (&unknown_ext_complaint,
2835 debug_info->ssext + psh->iss);
2836 /* Fall through, pretend it's global. */
2837 case stGlobal:
2838 /* Global common symbols are resolved by the runtime loader,
2839 ignore them. */
2840 if (psh->sc == scCommon || psh->sc == scSCommon)
2841 continue;
2842
2843 class = LOC_STATIC;
2844 break;
2845 }
2846 name = debug_info->ssext + psh->iss;
2847 ADD_PSYMBOL_ADDR_TO_LIST (name, strlen (name),
2848 VAR_NAMESPACE, class,
2849 objfile->global_psymbols,
2850 svalue,
2851 psymtab_language, objfile);
2852 }
2853 }
2854
2855 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
2856 empty and put on the free list. */
2857 fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
2858 psymtab_include_list, includes_used,
2859 -1, save_pst->texthigh,
2860 dependency_list, dependencies_used);
2861 if (objfile->ei.entry_point >= save_pst->textlow &&
2862 objfile->ei.entry_point < save_pst->texthigh)
2863 {
2864 objfile->ei.entry_file_lowpc = save_pst->textlow;
2865 objfile->ei.entry_file_highpc = save_pst->texthigh;
2866 }
2867
2868 /* The objfile has its functions reordered if this partial symbol
2869 table overlaps any other partial symbol table.
2870 We cannot assume a reordered objfile if a partial symbol table
2871 is contained within another partial symbol table, as partial symbol
2872 tables for include files with executable code are contained
2873 within the partial symbol table for the including source file,
2874 and we do not want to flag the objfile reordered for these cases.
2875
2876 This strategy works well for Irix-5.2 shared libraries, but we
2877 might have to use a more elaborate (and slower) algorithm for
2878 other cases. */
2879 save_pst = fdr_to_pst[f_idx].pst;
2880 if (save_pst != NULL
2881 && save_pst->textlow != 0
2882 && !(objfile->flags & OBJF_REORDERED))
2883 {
2884 ALL_OBJFILE_PSYMTABS (objfile, pst)
2885 {
2886 if (save_pst != pst
2887 && save_pst->textlow >= pst->textlow
2888 && save_pst->textlow < pst->texthigh
2889 && save_pst->texthigh > pst->texthigh)
2890 {
2891 objfile->flags |= OBJF_REORDERED;
2892 break;
2893 }
2894 }
2895 }
2896 }
2897
2898 /* Now scan the FDRs for dependencies */
2899 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
2900 {
2901 fh = f_idx + debug_info->fdr;
2902 pst = fdr_to_pst[f_idx].pst;
2903
2904 if (pst == (struct partial_symtab *)NULL)
2905 continue;
2906
2907 /* This should catch stabs-in-ecoff. */
2908 if (fh->crfd <= 1)
2909 continue;
2910
2911 /* Skip the first file indirect entry as it is a self dependency
2912 for source files or a reverse .h -> .c dependency for header files. */
2913 pst->number_of_dependencies = 0;
2914 pst->dependencies =
2915 ((struct partial_symtab **)
2916 obstack_alloc (&objfile->psymbol_obstack,
2917 ((fh->crfd - 1)
2918 * sizeof (struct partial_symtab *))));
2919 for (s_idx = 1; s_idx < fh->crfd; s_idx++)
2920 {
2921 RFDT rh;
2922
2923 (*swap_rfd_in) (cur_bfd,
2924 ((char *) debug_info->external_rfd
2925 + (fh->rfdBase + s_idx) * external_rfd_size),
2926 &rh);
2927 if (rh < 0 || rh >= hdr->ifdMax)
2928 {
2929 complain (&bad_file_number_complaint, rh);
2930 continue;
2931 }
2932
2933 /* Skip self dependencies of header files. */
2934 if (rh == f_idx)
2935 continue;
2936
2937 /* Do not add to dependeny list if psymtab was empty. */
2938 if (fdr_to_pst[rh].pst == (struct partial_symtab *)NULL)
2939 continue;
2940 pst->dependencies[pst->number_of_dependencies++] = fdr_to_pst[rh].pst;
2941 }
2942 }
2943
2944 /* Remove the dummy psymtab created for -O3 images above, if it is
2945 still empty, to enable the detection of stripped executables. */
2946 if (objfile->psymtabs->next == NULL
2947 && objfile->psymtabs->number_of_dependencies == 0
2948 && objfile->psymtabs->n_global_syms == 0
2949 && objfile->psymtabs->n_static_syms == 0)
2950 objfile->psymtabs = NULL;
2951 do_cleanups (old_chain);
2952 }
2953
2954 /* If the current psymbol has an enumerated type, we need to add
2955 all the the enum constants to the partial symbol table. */
2956
2957 static void
2958 handle_psymbol_enumerators (objfile, fh, stype)
2959 struct objfile *objfile;
2960 FDR *fh;
2961 int stype;
2962 {
2963 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
2964 void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
2965 = debug_swap->swap_sym_in;
2966 char *ext_sym = ((char *) debug_info->external_sym
2967 + ((fh->isymBase + cur_sdx + 1) * external_sym_size));
2968 SYMR sh;
2969 TIR tir;
2970
2971 switch (stype)
2972 {
2973 case stEnum:
2974 break;
2975
2976 case stBlock:
2977 /* It is an enumerated type if the next symbol entry is a stMember
2978 and its auxiliary index is indexNil or its auxiliary entry
2979 is a plain btNil or btVoid. */
2980 (*swap_sym_in) (cur_bfd, ext_sym, &sh);
2981 if (sh.st != stMember)
2982 return;
2983
2984 if (sh.index == indexNil)
2985 break;
2986 (*debug_swap->swap_tir_in) (fh->fBigendian,
2987 &(debug_info->external_aux
2988 + fh->iauxBase + sh.index)->a_ti,
2989 &tir);
2990 if ((tir.bt != btNil && tir.bt != btVoid) || tir.tq0 != tqNil)
2991 return;
2992 break;
2993
2994 default:
2995 return;
2996 }
2997
2998 for (;;)
2999 {
3000 char *name;
3001
3002 (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3003 if (sh.st != stMember)
3004 break;
3005 name = debug_info->ss + cur_fdr->issBase + sh.iss;
3006
3007 /* Note that the value doesn't matter for enum constants
3008 in psymtabs, just in symtabs. */
3009 ADD_PSYMBOL_TO_LIST (name, strlen (name),
3010 VAR_NAMESPACE, LOC_CONST,
3011 objfile->static_psymbols, 0,
3012 psymtab_language, objfile);
3013 ext_sym += external_sym_size;
3014 }
3015 }
3016
3017 static char *
3018 mdebug_next_symbol_text ()
3019 {
3020 SYMR sh;
3021
3022 cur_sdx++;
3023 (*debug_swap->swap_sym_in) (cur_bfd,
3024 ((char *) debug_info->external_sym
3025 + ((cur_fdr->isymBase + cur_sdx)
3026 * debug_swap->external_sym_size)),
3027 &sh);
3028 return debug_info->ss + cur_fdr->issBase + sh.iss;
3029 }
3030
3031 /* Ancillary function to psymtab_to_symtab(). Does all the work
3032 for turning the partial symtab PST into a symtab, recurring
3033 first on all dependent psymtabs. The argument FILENAME is
3034 only passed so we can see in debug stack traces what file
3035 is being read.
3036
3037 This function has a split personality, based on whether the
3038 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3039 The flow of control and even the memory allocation differs. FIXME. */
3040
3041 static void
3042 psymtab_to_symtab_1 (pst, filename)
3043 struct partial_symtab *pst;
3044 char *filename;
3045 {
3046 bfd_size_type external_sym_size;
3047 bfd_size_type external_pdr_size;
3048 void (*swap_sym_in) PARAMS ((bfd *, PTR, SYMR *));
3049 void (*swap_pdr_in) PARAMS ((bfd *, PTR, PDR *));
3050 int i;
3051 struct symtab *st;
3052 FDR *fh;
3053 struct linetable *lines;
3054
3055 if (pst->readin)
3056 return;
3057 pst->readin = 1;
3058
3059 /* Read in all partial symbtabs on which this one is dependent.
3060 NOTE that we do have circular dependencies, sigh. We solved
3061 that by setting pst->readin before this point. */
3062
3063 for (i = 0; i < pst->number_of_dependencies; i++)
3064 if (!pst->dependencies[i]->readin)
3065 {
3066 /* Inform about additional files to be read in. */
3067 if (info_verbose)
3068 {
3069 fputs_filtered (" ", gdb_stdout);
3070 wrap_here ("");
3071 fputs_filtered ("and ", gdb_stdout);
3072 wrap_here ("");
3073 printf_filtered ("%s...",
3074 pst->dependencies[i]->filename);
3075 wrap_here (""); /* Flush output */
3076 gdb_flush (gdb_stdout);
3077 }
3078 /* We only pass the filename for debug purposes */
3079 psymtab_to_symtab_1 (pst->dependencies[i],
3080 pst->dependencies[i]->filename);
3081 }
3082
3083 /* Do nothing if this is a dummy psymtab. */
3084
3085 if (pst->n_global_syms == 0 && pst->n_static_syms == 0
3086 && pst->textlow == 0 && pst->texthigh == 0)
3087 return;
3088
3089 /* Now read the symbols for this symtab */
3090
3091 cur_bfd = CUR_BFD (pst);
3092 debug_swap = DEBUG_SWAP (pst);
3093 debug_info = DEBUG_INFO (pst);
3094 pending_list = PENDING_LIST (pst);
3095 external_sym_size = debug_swap->external_sym_size;
3096 external_pdr_size = debug_swap->external_pdr_size;
3097 swap_sym_in = debug_swap->swap_sym_in;
3098 swap_pdr_in = debug_swap->swap_pdr_in;
3099 current_objfile = pst->objfile;
3100 cur_fd = FDR_IDX (pst);
3101 fh = ((cur_fd == -1)
3102 ? (FDR *) NULL
3103 : debug_info->fdr + cur_fd);
3104 cur_fdr = fh;
3105
3106 /* See comment in parse_partial_symbols about the @stabs sentinel. */
3107 processing_gcc_compilation = 0;
3108 if (fh != (FDR *) NULL && fh->csym >= 2)
3109 {
3110 SYMR sh;
3111
3112 (*swap_sym_in) (cur_bfd,
3113 ((char *) debug_info->external_sym
3114 + (fh->isymBase + 1) * external_sym_size),
3115 &sh);
3116 if (STREQ (debug_info->ss + fh->issBase + sh.iss,
3117 stabs_symbol))
3118 {
3119 /* We indicate that this is a GCC compilation so that certain
3120 features will be enabled in stabsread/dbxread. */
3121 processing_gcc_compilation = 2;
3122 }
3123 }
3124
3125 if (processing_gcc_compilation != 0)
3126 {
3127 char *pdr_ptr;
3128 char *pdr_end;
3129 int first_pdr;
3130 unsigned long first_off = 0;
3131
3132 /* This symbol table contains stabs-in-ecoff entries. */
3133
3134 /* Parse local symbols first */
3135
3136 if (fh->csym <= 2) /* FIXME, this blows psymtab->symtab ptr */
3137 {
3138 current_objfile = NULL;
3139 return;
3140 }
3141 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
3142 {
3143 SYMR sh;
3144 char *name;
3145 CORE_ADDR valu;
3146
3147 (*swap_sym_in) (cur_bfd,
3148 (((char *) debug_info->external_sym)
3149 + (fh->isymBase + cur_sdx) * external_sym_size),
3150 &sh);
3151 name = debug_info->ss + fh->issBase + sh.iss;
3152 valu = sh.value;
3153 if (ECOFF_IS_STAB (&sh))
3154 {
3155 int type_code = ECOFF_UNMARK_STAB (sh.index);
3156
3157 /* We should never get non N_STAB symbols here, but they
3158 should be harmless, so keep process_one_symbol from
3159 complaining about them. */
3160 if (type_code & N_STAB)
3161 {
3162 process_one_symbol (type_code, 0, valu, name,
3163 pst->section_offsets, pst->objfile);
3164 }
3165 if (type_code == N_FUN)
3166 {
3167 /* Make up special symbol to contain
3168 procedure specific info */
3169 struct mips_extra_func_info *e =
3170 ((struct mips_extra_func_info *)
3171 obstack_alloc (&current_objfile->symbol_obstack,
3172 sizeof (struct mips_extra_func_info)));
3173 struct symbol *s = new_symbol (MIPS_EFI_SYMBOL_NAME);
3174
3175 memset ((PTR) e, 0, sizeof (struct mips_extra_func_info));
3176 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
3177 SYMBOL_CLASS (s) = LOC_CONST;
3178 SYMBOL_TYPE (s) = mdebug_type_void;
3179 SYMBOL_VALUE (s) = (long) e;
3180 e->pdr.framereg = -1;
3181 add_symbol_to_list (s, &local_symbols);
3182 }
3183 }
3184 else if (sh.st == stLabel)
3185 {
3186 if (sh.index == indexNil)
3187 {
3188 /* This is what the gcc2_compiled and __gnu_compiled_*
3189 show up as. So don't complain. */
3190 ;
3191 }
3192 else
3193 {
3194 /* Handle encoded stab line number. */
3195 valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT);
3196 record_line (current_subfile, sh.index, valu);
3197 }
3198 }
3199 else if (sh.st == stProc || sh.st == stStaticProc
3200 || sh.st == stStatic || sh.st == stEnd)
3201 /* These are generated by gcc-2.x, do not complain */
3202 ;
3203 else
3204 complain (&stab_unknown_complaint, name);
3205 }
3206 st = end_symtab (pst->texthigh, 0, 0, pst->objfile, SECT_OFF_TEXT);
3207 end_stabs ();
3208
3209 /* Sort the symbol table now, we are done adding symbols to it.
3210 We must do this before parse_procedure calls lookup_symbol. */
3211 sort_symtab_syms (st);
3212
3213 /* There used to be a call to sort_blocks here, but this should not
3214 be necessary for stabs symtabs. And as sort_blocks modifies the
3215 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
3216 it did the wrong thing if the first procedure in a file was
3217 generated via asm statements. */
3218
3219 /* Fill in procedure info next. */
3220 first_pdr = 1;
3221 pdr_ptr = ((char *) debug_info->external_pdr
3222 + fh->ipdFirst * external_pdr_size);
3223 pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
3224 for (; pdr_ptr < pdr_end; pdr_ptr += external_pdr_size)
3225 {
3226 PDR pr;
3227
3228 (*swap_pdr_in) (cur_bfd, pdr_ptr, &pr);
3229 if (first_pdr)
3230 {
3231 first_off = pr.adr;
3232 first_pdr = 0;
3233 }
3234 parse_procedure (&pr, st, first_off, pst);
3235 }
3236 }
3237 else
3238 {
3239 /* This symbol table contains ordinary ecoff entries. */
3240
3241 int f_max;
3242 int maxlines;
3243 EXTR *ext_ptr;
3244
3245 /* How many symbols will we need */
3246 /* FIXME, this does not count enum values. */
3247 f_max = pst->n_global_syms + pst->n_static_syms;
3248 if (fh == 0)
3249 {
3250 maxlines = 0;
3251 st = new_symtab ("unknown", f_max, 0, pst->objfile);
3252 }
3253 else
3254 {
3255 f_max += fh->csym + fh->cpd;
3256 maxlines = 2 * fh->cline;
3257 st = new_symtab (pst->filename, 2 * f_max, maxlines, pst->objfile);
3258
3259 /* The proper language was already determined when building
3260 the psymtab, use it. */
3261 st->language = PST_PRIVATE (pst)->pst_language;
3262 }
3263
3264 psymtab_language = st->language;
3265
3266 lines = LINETABLE (st);
3267
3268 /* Get a new lexical context */
3269
3270 push_parse_stack ();
3271 top_stack->cur_st = st;
3272 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
3273 STATIC_BLOCK);
3274 BLOCK_START (top_stack->cur_block) = pst->textlow;
3275 BLOCK_END (top_stack->cur_block) = 0;
3276 top_stack->blocktype = stFile;
3277 top_stack->maxsyms = 2 * f_max;
3278 top_stack->cur_type = 0;
3279 top_stack->procadr = 0;
3280 top_stack->numargs = 0;
3281 found_ecoff_debugging_info = 0;
3282
3283 if (fh)
3284 {
3285 char *sym_ptr;
3286 char *sym_end;
3287
3288 /* Parse local symbols first */
3289 sym_ptr = ((char *) debug_info->external_sym
3290 + fh->isymBase * external_sym_size);
3291 sym_end = sym_ptr + fh->csym * external_sym_size;
3292 while (sym_ptr < sym_end)
3293 {
3294 SYMR sh;
3295 int c;
3296
3297 (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
3298 c = parse_symbol (&sh,
3299 debug_info->external_aux + fh->iauxBase,
3300 sym_ptr, fh->fBigendian, pst->section_offsets);
3301 sym_ptr += c * external_sym_size;
3302 }
3303
3304 /* Linenumbers. At the end, check if we can save memory.
3305 parse_lines has to look ahead an arbitrary number of PDR
3306 structures, so we swap them all first. */
3307 if (fh->cpd > 0)
3308 {
3309 PDR *pr_block;
3310 struct cleanup *old_chain;
3311 char *pdr_ptr;
3312 char *pdr_end;
3313 PDR *pdr_in;
3314 PDR *pdr_in_end;
3315
3316 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
3317
3318 old_chain = make_cleanup (free, pr_block);
3319
3320 pdr_ptr = ((char *) debug_info->external_pdr
3321 + fh->ipdFirst * external_pdr_size);
3322 pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
3323 pdr_in = pr_block;
3324 for (;
3325 pdr_ptr < pdr_end;
3326 pdr_ptr += external_pdr_size, pdr_in++)
3327 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
3328
3329 parse_lines (fh, pr_block, lines, maxlines, pst);
3330 if (lines->nitems < fh->cline)
3331 lines = shrink_linetable (lines);
3332
3333 /* Fill in procedure info next. */
3334 pdr_in = pr_block;
3335 pdr_in_end = pdr_in + fh->cpd;
3336 for (; pdr_in < pdr_in_end; pdr_in++)
3337 parse_procedure (pdr_in, 0, pr_block->adr, pst);
3338
3339 do_cleanups (old_chain);
3340 }
3341 }
3342
3343 LINETABLE (st) = lines;
3344
3345 /* .. and our share of externals.
3346 XXX use the global list to speed up things here. how?
3347 FIXME, Maybe quit once we have found the right number of ext's? */
3348 top_stack->cur_st = st;
3349 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
3350 GLOBAL_BLOCK);
3351 top_stack->blocktype = stFile;
3352 top_stack->maxsyms
3353 = (debug_info->symbolic_header.isymMax
3354 + debug_info->symbolic_header.ipdMax
3355 + debug_info->symbolic_header.iextMax);
3356
3357 ext_ptr = PST_PRIVATE (pst)->extern_tab;
3358 for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
3359 parse_external (ext_ptr, fh->fBigendian, pst->section_offsets);
3360
3361 /* If there are undefined symbols, tell the user.
3362 The alpha has an undefined symbol for every symbol that is
3363 from a shared library, so tell the user only if verbose is on. */
3364 if (info_verbose && n_undef_symbols)
3365 {
3366 printf_filtered ("File %s contains %d unresolved references:",
3367 st->filename, n_undef_symbols);
3368 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
3369 n_undef_vars, n_undef_procs, n_undef_labels);
3370 n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0;
3371
3372 }
3373 pop_parse_stack ();
3374
3375 st->primary = 1;
3376
3377 /* Sort the symbol table now, we are done adding symbols to it.*/
3378 sort_symtab_syms (st);
3379
3380 sort_blocks (st);
3381 }
3382
3383 /* Now link the psymtab and the symtab. */
3384 pst->symtab = st;
3385
3386 current_objfile = NULL;
3387 }
3388 \f
3389 /* Ancillary parsing procedures. */
3390
3391 /* Return 1 if the symbol pointed to by SH has a cross reference
3392 to an opaque aggregate type, else 0. */
3393
3394 static int
3395 has_opaque_xref (fh, sh)
3396 FDR *fh;
3397 SYMR *sh;
3398 {
3399 TIR tir;
3400 union aux_ext *ax;
3401 RNDXR rn[1];
3402 unsigned int rf;
3403
3404 if (sh->index == indexNil)
3405 return 0;
3406
3407 ax = debug_info->external_aux + fh->iauxBase + sh->index;
3408 (*debug_swap->swap_tir_in) (fh->fBigendian, &ax->a_ti, &tir);
3409 if (tir.bt != btStruct && tir.bt != btUnion && tir.bt != btEnum)
3410 return 0;
3411
3412 ax++;
3413 (*debug_swap->swap_rndx_in) (fh->fBigendian, &ax->a_rndx, rn);
3414 if (rn->rfd == 0xfff)
3415 rf = AUX_GET_ISYM (fh->fBigendian, ax + 1);
3416 else
3417 rf = rn->rfd;
3418 if (rf != -1)
3419 return 0;
3420 return 1;
3421 }
3422
3423 /* Lookup the type at relative index RN. Return it in TPP
3424 if found and in any event come up with its name PNAME.
3425 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
3426 Return value says how many aux symbols we ate. */
3427
3428 static int
3429 cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name)
3430 int fd;
3431 union aux_ext *ax;
3432 struct type **tpp;
3433 enum type_code type_code; /* Use to alloc new type if none is found. */
3434 char **pname;
3435 int bigend;
3436 char *sym_name;
3437 {
3438 RNDXR rn[1];
3439 unsigned int rf;
3440 int result = 1;
3441 FDR *fh;
3442 char *esh;
3443 SYMR sh;
3444 int xref_fd;
3445 struct mdebug_pending *pend;
3446
3447 *tpp = (struct type *)NULL;
3448
3449 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
3450
3451 /* Escape index means 'the next one' */
3452 if (rn->rfd == 0xfff)
3453 {
3454 result++;
3455 rf = AUX_GET_ISYM (bigend, ax + 1);
3456 }
3457 else
3458 {
3459 rf = rn->rfd;
3460 }
3461
3462 /* mips cc uses a rf of -1 for opaque struct definitions.
3463 Set TYPE_FLAG_STUB for these types so that check_stub_type will
3464 resolve them if the struct gets defined in another compilation unit. */
3465 if (rf == -1)
3466 {
3467 *pname = "<undefined>";
3468 *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
3469 TYPE_FLAGS (*tpp) |= TYPE_FLAG_STUB;
3470 return result;
3471 }
3472
3473 /* mips cc uses an escaped rn->index of 0 for struct return types
3474 of procedures that were compiled without -g. These will always remain
3475 undefined. */
3476 if (rn->rfd == 0xfff && rn->index == 0)
3477 {
3478 *pname = "<undefined>";
3479 return result;
3480 }
3481
3482 /* Find the relative file descriptor and the symbol in it. */
3483 fh = get_rfd (fd, rf);
3484 xref_fd = fh - debug_info->fdr;
3485
3486 if (rn->index >= fh->csym)
3487 {
3488 /* File indirect entry is corrupt. */
3489 *pname = "<illegal>";
3490 complain (&bad_rfd_entry_complaint,
3491 sym_name, xref_fd, rn->index);
3492 return result;
3493 }
3494
3495 /* If we have processed this symbol then we left a forwarding
3496 pointer to the type in the pending list. If not, we`ll put
3497 it in a list of pending types, to be processed later when
3498 the file will be. In any event, we collect the name for the
3499 type here. */
3500
3501 esh = ((char *) debug_info->external_sym
3502 + ((fh->isymBase + rn->index)
3503 * debug_swap->external_sym_size));
3504 (*debug_swap->swap_sym_in) (cur_bfd, esh, &sh);
3505
3506 /* Make sure that this type of cross reference can be handled. */
3507 if ((sh.sc != scInfo
3508 || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect
3509 && sh.st != stStruct && sh.st != stUnion
3510 && sh.st != stEnum))
3511 && (sh.st != stBlock || (sh.sc != scCommon && sh.sc != scSCommon)))
3512 {
3513 /* File indirect entry is corrupt. */
3514 *pname = "<illegal>";
3515 complain (&bad_rfd_entry_complaint,
3516 sym_name, xref_fd, rn->index);
3517 return result;
3518 }
3519
3520 *pname = debug_info->ss + fh->issBase + sh.iss;
3521
3522 pend = is_pending_symbol (fh, esh);
3523 if (pend)
3524 *tpp = pend->t;
3525 else
3526 {
3527 /* We have not yet seen this type. */
3528
3529 if ((sh.iss == 0 && sh.st == stTypedef) || sh.st == stIndirect)
3530 {
3531 TIR tir;
3532
3533 /* alpha cc puts out a stTypedef with a sh.iss of zero for
3534 two cases:
3535 a) forward declarations of structs/unions/enums which are not
3536 defined in this compilation unit.
3537 For these the type will be void. This is a bad design decision
3538 as cross referencing across compilation units is impossible
3539 due to the missing name.
3540 b) forward declarations of structs/unions/enums which are defined
3541 later in this file or in another file in the same compilation
3542 unit. Irix5 cc uses a stIndirect symbol for this.
3543 Simply cross reference those again to get the true type.
3544 The forward references are not entered in the pending list and
3545 in the symbol table. */
3546
3547 (*debug_swap->swap_tir_in) (bigend,
3548 &(debug_info->external_aux
3549 + fh->iauxBase + sh.index)->a_ti,
3550 &tir);
3551 if (tir.tq0 != tqNil)
3552 complain (&illegal_forward_tq0_complaint, sym_name);
3553 switch (tir.bt)
3554 {
3555 case btVoid:
3556 *tpp = init_type (type_code, 0, 0, (char *) NULL,
3557 current_objfile);
3558 *pname = "<undefined>";
3559 break;
3560
3561 case btStruct:
3562 case btUnion:
3563 case btEnum:
3564 cross_ref (xref_fd,
3565 (debug_info->external_aux
3566 + fh->iauxBase + sh.index + 1),
3567 tpp, type_code, pname,
3568 fh->fBigendian, sym_name);
3569 break;
3570
3571 default:
3572 complain (&illegal_forward_bt_complaint, tir.bt, sym_name);
3573 *tpp = init_type (type_code, 0, 0, (char *) NULL,
3574 current_objfile);
3575 break;
3576 }
3577 return result;
3578 }
3579 else if (sh.st == stTypedef)
3580 {
3581 /* Parse the type for a normal typedef. This might recursively call
3582 cross_ref till we get a non typedef'ed type.
3583 FIXME: This is not correct behaviour, but gdb currently
3584 cannot handle typedefs without type copying. But type copying is
3585 impossible as we might have mutual forward references between
3586 two files and the copied type would not get filled in when
3587 we later parse its definition. */
3588 *tpp = parse_type (xref_fd,
3589 debug_info->external_aux + fh->iauxBase,
3590 sh.index,
3591 (int *)NULL,
3592 fh->fBigendian,
3593 debug_info->ss + fh->issBase + sh.iss);
3594 }
3595 else
3596 {
3597 /* Cross reference to a struct/union/enum which is defined
3598 in another file in the same compilation unit but that file
3599 has not been parsed yet.
3600 Initialize the type only, it will be filled in when
3601 it's definition is parsed. */
3602 *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
3603 }
3604 add_pending (fh, esh, *tpp);
3605 }
3606
3607 /* We used one auxent normally, two if we got a "next one" rf. */
3608 return result;
3609 }
3610
3611
3612 /* Quick&dirty lookup procedure, to avoid the MI ones that require
3613 keeping the symtab sorted */
3614
3615 static struct symbol *
3616 mylookup_symbol (name, block, namespace, class)
3617 char *name;
3618 register struct block *block;
3619 enum namespace namespace;
3620 enum address_class class;
3621 {
3622 register int bot, top, inc;
3623 register struct symbol *sym;
3624
3625 bot = 0;
3626 top = BLOCK_NSYMS (block);
3627 inc = name[0];
3628 while (bot < top)
3629 {
3630 sym = BLOCK_SYM (block, bot);
3631 if (SYMBOL_NAME (sym)[0] == inc
3632 && SYMBOL_NAMESPACE (sym) == namespace
3633 && SYMBOL_CLASS (sym) == class
3634 && strcmp (SYMBOL_NAME (sym), name) == 0)
3635 return sym;
3636 bot++;
3637 }
3638 block = BLOCK_SUPERBLOCK (block);
3639 if (block)
3640 return mylookup_symbol (name, block, namespace, class);
3641 return 0;
3642 }
3643
3644
3645 /* Add a new symbol S to a block B.
3646 Infrequently, we will need to reallocate the block to make it bigger.
3647 We only detect this case when adding to top_stack->cur_block, since
3648 that's the only time we know how big the block is. FIXME. */
3649
3650 static void
3651 add_symbol (s, b)
3652 struct symbol *s;
3653 struct block *b;
3654 {
3655 int nsyms = BLOCK_NSYMS (b)++;
3656 struct block *origb;
3657 struct parse_stack *stackp;
3658
3659 if (b == top_stack->cur_block &&
3660 nsyms >= top_stack->maxsyms)
3661 {
3662 complain (&block_overflow_complaint, SYMBOL_NAME (s));
3663 /* In this case shrink_block is actually grow_block, since
3664 BLOCK_NSYMS(b) is larger than its current size. */
3665 origb = b;
3666 b = shrink_block (top_stack->cur_block, top_stack->cur_st);
3667
3668 /* Now run through the stack replacing pointers to the
3669 original block. shrink_block has already done this
3670 for the blockvector and BLOCK_FUNCTION. */
3671 for (stackp = top_stack; stackp; stackp = stackp->next)
3672 {
3673 if (stackp->cur_block == origb)
3674 {
3675 stackp->cur_block = b;
3676 stackp->maxsyms = BLOCK_NSYMS (b);
3677 }
3678 }
3679 }
3680 BLOCK_SYM (b, nsyms) = s;
3681 }
3682
3683 /* Add a new block B to a symtab S */
3684
3685 static void
3686 add_block (b, s)
3687 struct block *b;
3688 struct symtab *s;
3689 {
3690 struct blockvector *bv = BLOCKVECTOR (s);
3691
3692 bv = (struct blockvector *) xrealloc ((PTR) bv,
3693 (sizeof (struct blockvector)
3694 + BLOCKVECTOR_NBLOCKS (bv)
3695 * sizeof (bv->block)));
3696 if (bv != BLOCKVECTOR (s))
3697 BLOCKVECTOR (s) = bv;
3698
3699 BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b;
3700 }
3701
3702 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
3703 MIPS' linenumber encoding might need more than one byte
3704 to describe it, LAST is used to detect these continuation lines.
3705
3706 Combining lines with the same line number seems like a bad idea.
3707 E.g: There could be a line number entry with the same line number after the
3708 prologue and GDB should not ignore it (this is a better way to find
3709 a prologue than mips_skip_prologue).
3710 But due to the compressed line table format there are line number entries
3711 for the same line which are needed to bridge the gap to the next
3712 line number entry. These entries have a bogus address info with them
3713 and we are unable to tell them from intended duplicate line number
3714 entries.
3715 This is another reason why -ggdb debugging format is preferable. */
3716
3717 static int
3718 add_line (lt, lineno, adr, last)
3719 struct linetable *lt;
3720 int lineno;
3721 CORE_ADDR adr;
3722 int last;
3723 {
3724 /* DEC c89 sometimes produces zero linenos which confuse gdb.
3725 Change them to something sensible. */
3726 if (lineno == 0)
3727 lineno = 1;
3728 if (last == 0)
3729 last = -2; /* make sure we record first line */
3730
3731 if (last == lineno) /* skip continuation lines */
3732 return lineno;
3733
3734 lt->item[lt->nitems].line = lineno;
3735 lt->item[lt->nitems++].pc = adr << 2;
3736 return lineno;
3737 }
3738 \f
3739 /* Sorting and reordering procedures */
3740
3741 /* Blocks with a smaller low bound should come first */
3742
3743 static int
3744 compare_blocks (arg1, arg2)
3745 const PTR arg1;
3746 const PTR arg2;
3747 {
3748 register int addr_diff;
3749 struct block **b1 = (struct block **) arg1;
3750 struct block **b2 = (struct block **) arg2;
3751
3752 addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2)));
3753 if (addr_diff == 0)
3754 return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1)));
3755 return addr_diff;
3756 }
3757
3758 /* Sort the blocks of a symtab S.
3759 Reorder the blocks in the blockvector by code-address,
3760 as required by some MI search routines */
3761
3762 static void
3763 sort_blocks (s)
3764 struct symtab *s;
3765 {
3766 struct blockvector *bv = BLOCKVECTOR (s);
3767
3768 if (BLOCKVECTOR_NBLOCKS (bv) <= 2)
3769 {
3770 /* Cosmetic */
3771 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0)
3772 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0;
3773 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0)
3774 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0;
3775 return;
3776 }
3777 /*
3778 * This is very unfortunate: normally all functions are compiled in
3779 * the order they are found, but if the file is compiled -O3 things
3780 * are very different. It would be nice to find a reliable test
3781 * to detect -O3 images in advance.
3782 */
3783 if (BLOCKVECTOR_NBLOCKS (bv) > 3)
3784 qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
3785 BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK,
3786 sizeof (struct block *),
3787 compare_blocks);
3788
3789 {
3790 register CORE_ADDR high = 0;
3791 register int i, j = BLOCKVECTOR_NBLOCKS (bv);
3792
3793 for (i = FIRST_LOCAL_BLOCK; i < j; i++)
3794 if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)))
3795 high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i));
3796 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high;
3797 }
3798
3799 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) =
3800 BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK));
3801
3802 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
3803 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
3804 BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
3805 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
3806 }
3807 \f
3808
3809 /* Constructor/restructor/destructor procedures */
3810
3811 /* Allocate a new symtab for NAME. Needs an estimate of how many symbols
3812 MAXSYMS and linenumbers MAXLINES we'll put in it */
3813
3814 static struct symtab *
3815 new_symtab (name, maxsyms, maxlines, objfile)
3816 char *name;
3817 int maxsyms;
3818 int maxlines;
3819 struct objfile *objfile;
3820 {
3821 struct symtab *s = allocate_symtab (name, objfile);
3822
3823 LINETABLE (s) = new_linetable (maxlines);
3824
3825 /* All symtabs must have at least two blocks */
3826 BLOCKVECTOR (s) = new_bvect (2);
3827 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) = new_block (maxsyms);
3828 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) = new_block (maxsyms);
3829 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
3830 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
3831
3832 s->free_code = free_linetable;
3833
3834 return (s);
3835 }
3836
3837 /* Allocate a new partial_symtab NAME */
3838
3839 static struct partial_symtab *
3840 new_psymtab (name, objfile, section_offsets)
3841 char *name;
3842 struct objfile *objfile;
3843 struct section_offsets *section_offsets;
3844 {
3845 struct partial_symtab *psymtab;
3846
3847 psymtab = allocate_psymtab (name, objfile);
3848 psymtab->section_offsets = section_offsets;
3849
3850 /* Keep a backpointer to the file's symbols */
3851
3852 psymtab->read_symtab_private = ((char *)
3853 obstack_alloc (&objfile->psymbol_obstack,
3854 sizeof (struct symloc)));
3855 memset ((PTR) psymtab->read_symtab_private, 0, sizeof (struct symloc));
3856 CUR_BFD (psymtab) = cur_bfd;
3857 DEBUG_SWAP (psymtab) = debug_swap;
3858 DEBUG_INFO (psymtab) = debug_info;
3859 PENDING_LIST (psymtab) = pending_list;
3860
3861 /* The way to turn this into a symtab is to call... */
3862 psymtab->read_symtab = mdebug_psymtab_to_symtab;
3863 return (psymtab);
3864 }
3865
3866
3867 /* Allocate a linetable array of the given SIZE. Since the struct
3868 already includes one item, we subtract one when calculating the
3869 proper size to allocate. */
3870
3871 static struct linetable *
3872 new_linetable (size)
3873 int size;
3874 {
3875 struct linetable *l;
3876
3877 size = (size - 1) * sizeof (l->item) + sizeof (struct linetable);
3878 l = (struct linetable *) xmalloc (size);
3879 l->nitems = 0;
3880 return l;
3881 }
3882
3883 /* Oops, too big. Shrink it. This was important with the 2.4 linetables,
3884 I am not so sure about the 3.4 ones.
3885
3886 Since the struct linetable already includes one item, we subtract one when
3887 calculating the proper size to allocate. */
3888
3889 static struct linetable *
3890 shrink_linetable (lt)
3891 struct linetable *lt;
3892 {
3893
3894 return (struct linetable *) xrealloc ((PTR) lt,
3895 (sizeof (struct linetable)
3896 + ((lt->nitems - 1)
3897 * sizeof (lt->item))));
3898 }
3899
3900 /* Allocate and zero a new blockvector of NBLOCKS blocks. */
3901
3902 static struct blockvector *
3903 new_bvect (nblocks)
3904 int nblocks;
3905 {
3906 struct blockvector *bv;
3907 int size;
3908
3909 size = sizeof (struct blockvector) + nblocks * sizeof (struct block *);
3910 bv = (struct blockvector *) xzalloc (size);
3911
3912 BLOCKVECTOR_NBLOCKS (bv) = nblocks;
3913
3914 return bv;
3915 }
3916
3917 /* Allocate and zero a new block of MAXSYMS symbols */
3918
3919 static struct block *
3920 new_block (maxsyms)
3921 int maxsyms;
3922 {
3923 int size = sizeof (struct block) + (maxsyms - 1) * sizeof (struct symbol *);
3924
3925 return (struct block *) xzalloc (size);
3926 }
3927
3928 /* Ooops, too big. Shrink block B in symtab S to its minimal size.
3929 Shrink_block can also be used by add_symbol to grow a block. */
3930
3931 static struct block *
3932 shrink_block (b, s)
3933 struct block *b;
3934 struct symtab *s;
3935 {
3936 struct block *new;
3937 struct blockvector *bv = BLOCKVECTOR (s);
3938 int i;
3939
3940 /* Just reallocate it and fix references to the old one */
3941
3942 new = (struct block *) xrealloc ((PTR) b,
3943 (sizeof (struct block)
3944 + ((BLOCK_NSYMS (b) - 1)
3945 * sizeof (struct symbol *))));
3946
3947 /* Should chase pointers to old one. Fortunately, that`s just
3948 the block`s function and inferior blocks */
3949 if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b)
3950 SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
3951 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
3952 if (BLOCKVECTOR_BLOCK (bv, i) == b)
3953 BLOCKVECTOR_BLOCK (bv, i) = new;
3954 else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) == b)
3955 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) = new;
3956 return new;
3957 }
3958
3959 /* Create a new symbol with printname NAME */
3960
3961 static struct symbol *
3962 new_symbol (name)
3963 char *name;
3964 {
3965 struct symbol *s = ((struct symbol *)
3966 obstack_alloc (&current_objfile->symbol_obstack,
3967 sizeof (struct symbol)));
3968
3969 memset ((PTR) s, 0, sizeof (*s));
3970 SYMBOL_NAME (s) = name;
3971 SYMBOL_LANGUAGE (s) = psymtab_language;
3972 SYMBOL_INIT_DEMANGLED_NAME (s, &current_objfile->symbol_obstack);
3973 return s;
3974 }
3975
3976 /* Create a new type with printname NAME */
3977
3978 static struct type *
3979 new_type (name)
3980 char *name;
3981 {
3982 struct type *t;
3983
3984 t = alloc_type (current_objfile);
3985 TYPE_NAME (t) = name;
3986 TYPE_CPLUS_SPECIFIC (t) = (struct cplus_struct_type *) &cplus_struct_default;
3987 return t;
3988 }
3989 \f
3990 /* Read ECOFF debugging information from a BFD section. This is
3991 called from elfread.c. It parses the section into a
3992 ecoff_debug_info struct, and then lets the rest of the file handle
3993 it as normal. */
3994
3995 void
3996 elfmdebug_build_psymtabs (objfile, swap, sec, section_offsets)
3997 struct objfile *objfile;
3998 const struct ecoff_debug_swap *swap;
3999 asection *sec;
4000 struct section_offsets *section_offsets;
4001 {
4002 bfd *abfd = objfile->obfd;
4003 struct ecoff_debug_info *info;
4004
4005 info = ((struct ecoff_debug_info *)
4006 obstack_alloc (&objfile->psymbol_obstack,
4007 sizeof (struct ecoff_debug_info)));
4008
4009 if (!(*swap->read_debug_info) (abfd, sec, info))
4010 error ("Error reading ECOFF debugging information: %s",
4011 bfd_errmsg (bfd_get_error ()));
4012
4013 mdebug_build_psymtabs (objfile, swap, info, section_offsets);
4014 }
4015 \f
4016
4017 /* Things used for calling functions in the inferior.
4018 These functions are exported to our companion
4019 mips-tdep.c file and are here because they play
4020 with the symbol-table explicitly. */
4021
4022 /* Sigtramp: make sure we have all the necessary information
4023 about the signal trampoline code. Since the official code
4024 from MIPS does not do so, we make up that information ourselves.
4025 If they fix the library (unlikely) this code will neutralize itself. */
4026
4027 /* FIXME: This function is called only by mips-tdep.c. It needs to be
4028 here because it calls functions defined in this file, but perhaps
4029 this could be handled in a better way. */
4030
4031 void
4032 fixup_sigtramp ()
4033 {
4034 struct symbol *s;
4035 struct symtab *st;
4036 struct block *b, *b0 = NULL;
4037
4038 sigtramp_address = -1;
4039
4040 /* We have to handle the following cases here:
4041 a) The Mips library has a sigtramp label within sigvec.
4042 b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
4043 s = lookup_symbol ("sigvec", 0, VAR_NAMESPACE, 0, NULL);
4044 if (s != 0)
4045 {
4046 b0 = SYMBOL_BLOCK_VALUE (s);
4047 s = lookup_symbol ("sigtramp", b0, VAR_NAMESPACE, 0, NULL);
4048 }
4049 if (s == 0)
4050 {
4051 /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
4052 s = lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE, 0, NULL);
4053 }
4054
4055 /* But maybe this program uses its own version of sigvec */
4056 if (s == 0)
4057 return;
4058
4059 /* Did we or MIPSco fix the library ? */
4060 if (SYMBOL_CLASS (s) == LOC_BLOCK)
4061 {
4062 sigtramp_address = BLOCK_START (SYMBOL_BLOCK_VALUE (s));
4063 sigtramp_end = BLOCK_END (SYMBOL_BLOCK_VALUE (s));
4064 return;
4065 }
4066
4067 sigtramp_address = SYMBOL_VALUE (s);
4068 sigtramp_end = sigtramp_address + 0x88; /* black magic */
4069
4070 /* But what symtab does it live in ? */
4071 st = find_pc_symtab (SYMBOL_VALUE (s));
4072
4073 /*
4074 * Ok, there goes the fix: turn it into a procedure, with all the
4075 * needed info. Note we make it a nested procedure of sigvec,
4076 * which is the way the (assembly) code is actually written.
4077 */
4078 SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
4079 SYMBOL_CLASS (s) = LOC_BLOCK;
4080 SYMBOL_TYPE (s) = init_type (TYPE_CODE_FUNC, 4, 0, (char *) NULL,
4081 st->objfile);
4082 TYPE_TARGET_TYPE (SYMBOL_TYPE (s)) = mdebug_type_void;
4083
4084 /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
4085 b = new_block (1);
4086 SYMBOL_BLOCK_VALUE (s) = b;
4087 BLOCK_START (b) = sigtramp_address;
4088 BLOCK_END (b) = sigtramp_end;
4089 BLOCK_FUNCTION (b) = s;
4090 BLOCK_SUPERBLOCK (b) = BLOCK_SUPERBLOCK (b0);
4091 add_block (b, st);
4092 sort_blocks (st);
4093
4094 /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
4095 {
4096 struct mips_extra_func_info *e =
4097 ((struct mips_extra_func_info *)
4098 xzalloc (sizeof (struct mips_extra_func_info)));
4099
4100 e->numargs = 0; /* the kernel thinks otherwise */
4101 e->pdr.frameoffset = 32;
4102 e->pdr.framereg = SP_REGNUM;
4103 /* Note that setting pcreg is no longer strictly necessary as
4104 mips_frame_saved_pc is now aware of signal handler frames. */
4105 e->pdr.pcreg = PC_REGNUM;
4106 e->pdr.regmask = -2;
4107 /* Offset to saved r31, in the sigtramp case the saved registers
4108 are above the frame in the sigcontext.
4109 We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
4110 32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
4111 and 32 * 4 bytes for the floating point registers. */
4112 e->pdr.regoffset = 4 + 12 + 31 * 4;
4113 e->pdr.fregmask = -1;
4114 /* Offset to saved f30 (first saved *double* register). */
4115 e->pdr.fregoffset = 4 + 12 + 32 * 4 + 12 + 30 * 4;
4116 e->pdr.isym = (long) s;
4117 e->pdr.adr = sigtramp_address;
4118
4119 current_objfile = st->objfile; /* Keep new_symbol happy */
4120 s = new_symbol (MIPS_EFI_SYMBOL_NAME);
4121 SYMBOL_VALUE (s) = (long) e;
4122 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
4123 SYMBOL_CLASS (s) = LOC_CONST;
4124 SYMBOL_TYPE (s) = mdebug_type_void;
4125 current_objfile = NULL;
4126 }
4127
4128 BLOCK_SYM (b, BLOCK_NSYMS (b)++) = s;
4129 }
4130
4131 void
4132 _initialize_mdebugread ()
4133 {
4134 mdebug_type_void =
4135 init_type (TYPE_CODE_VOID, 1,
4136 0,
4137 "void", (struct objfile *) NULL);
4138 mdebug_type_char =
4139 init_type (TYPE_CODE_INT, 1,
4140 0,
4141 "char", (struct objfile *) NULL);
4142 mdebug_type_unsigned_char =
4143 init_type (TYPE_CODE_INT, 1,
4144 TYPE_FLAG_UNSIGNED,
4145 "unsigned char", (struct objfile *) NULL);
4146 mdebug_type_short =
4147 init_type (TYPE_CODE_INT, 2,
4148 0,
4149 "short", (struct objfile *) NULL);
4150 mdebug_type_unsigned_short =
4151 init_type (TYPE_CODE_INT, 2,
4152 TYPE_FLAG_UNSIGNED,
4153 "unsigned short", (struct objfile *) NULL);
4154 mdebug_type_int_32 =
4155 init_type (TYPE_CODE_INT, 4,
4156 0,
4157 "int", (struct objfile *) NULL);
4158 mdebug_type_unsigned_int_32 =
4159 init_type (TYPE_CODE_INT, 4,
4160 TYPE_FLAG_UNSIGNED,
4161 "unsigned int", (struct objfile *) NULL);
4162 mdebug_type_int_64 =
4163 init_type (TYPE_CODE_INT, 8,
4164 0,
4165 "int", (struct objfile *) NULL);
4166 mdebug_type_unsigned_int_64 =
4167 init_type (TYPE_CODE_INT, 8,
4168 TYPE_FLAG_UNSIGNED,
4169 "unsigned int", (struct objfile *) NULL);
4170 mdebug_type_long_32 =
4171 init_type (TYPE_CODE_INT, 4,
4172 0,
4173 "long", (struct objfile *) NULL);
4174 mdebug_type_unsigned_long_32 =
4175 init_type (TYPE_CODE_INT, 4,
4176 TYPE_FLAG_UNSIGNED,
4177 "unsigned long", (struct objfile *) NULL);
4178 mdebug_type_long_64 =
4179 init_type (TYPE_CODE_INT, 8,
4180 0,
4181 "long", (struct objfile *) NULL);
4182 mdebug_type_unsigned_long_64 =
4183 init_type (TYPE_CODE_INT, 8,
4184 TYPE_FLAG_UNSIGNED,
4185 "unsigned long", (struct objfile *) NULL);
4186 mdebug_type_long_long_64 =
4187 init_type (TYPE_CODE_INT, 8,
4188 0,
4189 "long long", (struct objfile *) NULL);
4190 mdebug_type_unsigned_long_long_64 =
4191 init_type (TYPE_CODE_INT, 8,
4192 TYPE_FLAG_UNSIGNED,
4193 "unsigned long long", (struct objfile *) NULL);
4194 mdebug_type_adr_32 =
4195 init_type (TYPE_CODE_PTR, 4,
4196 TYPE_FLAG_UNSIGNED,
4197 "adr_32", (struct objfile *) NULL);
4198 TYPE_TARGET_TYPE (mdebug_type_adr_32) = mdebug_type_void;
4199 mdebug_type_adr_64 =
4200 init_type (TYPE_CODE_PTR, 8,
4201 TYPE_FLAG_UNSIGNED,
4202 "adr_64", (struct objfile *) NULL);
4203 TYPE_TARGET_TYPE (mdebug_type_adr_64) = mdebug_type_void;
4204 mdebug_type_float =
4205 init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
4206 0,
4207 "float", (struct objfile *) NULL);
4208 mdebug_type_double =
4209 init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
4210 0,
4211 "double", (struct objfile *) NULL);
4212 mdebug_type_complex =
4213 init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
4214 0,
4215 "complex", (struct objfile *) NULL);
4216 TYPE_TARGET_TYPE (mdebug_type_complex) = mdebug_type_float;
4217 mdebug_type_double_complex =
4218 init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
4219 0,
4220 "double complex", (struct objfile *) NULL);
4221 TYPE_TARGET_TYPE (mdebug_type_double_complex) = mdebug_type_double;
4222
4223 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
4224 FIXME. */
4225 mdebug_type_string =
4226 init_type (TYPE_CODE_STRING,
4227 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
4228 0, "string",
4229 (struct objfile *) NULL);
4230
4231 /* We use TYPE_CODE_INT to print these as integers. Does this do any
4232 good? Would we be better off with TYPE_CODE_ERROR? Should
4233 TYPE_CODE_ERROR print things in hex if it knows the size? */
4234 mdebug_type_fixed_dec =
4235 init_type (TYPE_CODE_INT,
4236 TARGET_INT_BIT / TARGET_CHAR_BIT,
4237 0, "fixed decimal",
4238 (struct objfile *) NULL);
4239
4240 mdebug_type_float_dec =
4241 init_type (TYPE_CODE_ERROR,
4242 TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
4243 0, "floating decimal",
4244 (struct objfile *) NULL);
4245
4246 nodebug_func_symbol_type = init_type (TYPE_CODE_FUNC, 1, 0,
4247 "<function, no debug info>", NULL);
4248 TYPE_TARGET_TYPE (nodebug_func_symbol_type) = mdebug_type_int;
4249 nodebug_var_symbol_type =
4250 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
4251 "<variable, no debug info>", NULL);
4252 }
This page took 0.114865 seconds and 5 git commands to generate.