Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / mdebugread.c
CommitLineData
5796c8dc
SS
1/* Read a symbol table in ECOFF format (Third-Eye).
2
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
6 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
7 at Cygnus Support.
8
9 This file is part of GDB.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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"
c50c785c 46#include "filenames.h"
5796c8dc
SS
47#include "objfiles.h"
48#include "gdb_obstack.h"
49#include "buildsym.h"
50#include "stabsread.h"
51#include "complaints.h"
52#include "demangle.h"
a45ae5f8 53#include "gdb-demangle.h"
5796c8dc
SS
54#include "gdb_assert.h"
55#include "block.h"
56#include "dictionary.h"
57#include "mdebugread.h"
58#include "gdb_stat.h"
59#include "gdb_string.h"
cf7f2e2d 60#include "psympriv.h"
ef5ccd6c 61#include "source.h"
5796c8dc
SS
62
63#include "bfd.h"
64
c50c785c 65#include "coff/ecoff.h" /* COFF-like aspects of ecoff files. */
5796c8dc
SS
66
67#include "libaout.h" /* Private BFD a.out information. */
68#include "aout/aout64.h"
c50c785c 69#include "aout/stab_gnu.h" /* STABS information. */
5796c8dc
SS
70
71#include "expression.h"
72
73extern void _initialize_mdebugread (void);
74
c50c785c 75/* Provide a way to test if we have both ECOFF and ELF symbol tables.
5796c8dc
SS
76 We use this define in order to know whether we should override a
77 symbol's ECOFF section with its ELF section. This is necessary in
78 case the symbol's ELF section could not be represented in ECOFF. */
79#define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
80 && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
a45ae5f8
JM
81
82/* The objfile we are currently reading. */
83
84static struct objfile *mdebugread_objfile;
85
5796c8dc
SS
86\f
87
88/* We put a pointer to this structure in the read_symtab_private field
89 of the psymtab. */
90
91struct symloc
92 {
93 /* Index of the FDR that this psymtab represents. */
94 int fdr_idx;
95 /* The BFD that the psymtab was created from. */
96 bfd *cur_bfd;
97 const struct ecoff_debug_swap *debug_swap;
98 struct ecoff_debug_info *debug_info;
99 struct mdebug_pending **pending_list;
100 /* Pointer to external symbols for this file. */
101 EXTR *extern_tab;
102 /* Size of extern_tab. */
103 int extern_count;
104 enum language pst_language;
105 };
106
107#define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
108#define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
109#define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
110#define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
111#define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
112#define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
113
114#define SC_IS_TEXT(sc) ((sc) == scText \
115 || (sc) == scRConst \
116 || (sc) == scInit \
117 || (sc) == scFini)
118#define SC_IS_DATA(sc) ((sc) == scData \
119 || (sc) == scSData \
120 || (sc) == scRData \
121 || (sc) == scPData \
122 || (sc) == scXData)
123#define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
124#define SC_IS_BSS(sc) ((sc) == scBss)
125#define SC_IS_SBSS(sc) ((sc) == scSBss)
126#define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
127\f
c50c785c 128/* Various complaints about symbol reading that don't abort the process. */
5796c8dc
SS
129static void
130index_complaint (const char *arg1)
131{
132 complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
133}
134
135static void
136unknown_ext_complaint (const char *arg1)
137{
138 complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
139}
140
141static void
142basic_type_complaint (int arg1, const char *arg2)
143{
144 complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
145 arg1, arg2);
146}
147
148static void
149bad_tag_guess_complaint (const char *arg1)
150{
c50c785c
JM
151 complaint (&symfile_complaints,
152 _("guessed tag type of %s incorrectly"), arg1);
5796c8dc
SS
153}
154
155static void
156bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
157{
158 complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
159 arg1, arg2, arg3);
160}
161
162static void
163unexpected_type_code_complaint (const char *arg1)
164{
165 complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
166}
167
c50c785c 168/* Macros and extra defs. */
5796c8dc 169
c50c785c 170/* Puns: hard to find whether -g was used and how. */
5796c8dc
SS
171
172#define MIN_GLEVEL GLEVEL_0
173#define compare_glevel(a,b) \
174 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
175 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
176\f
c50c785c 177/* Things that really are local to this module. */
5796c8dc 178
c50c785c 179/* Remember what we deduced to be the source language of this psymtab. */
5796c8dc
SS
180
181static enum language psymtab_language = language_unknown;
182
183/* Current BFD. */
184
185static bfd *cur_bfd;
186
187/* How to parse debugging information for CUR_BFD. */
188
189static const struct ecoff_debug_swap *debug_swap;
190
191/* Pointers to debugging information for CUR_BFD. */
192
193static struct ecoff_debug_info *debug_info;
194
c50c785c 195/* Pointer to current file decriptor record, and its index. */
5796c8dc
SS
196
197static FDR *cur_fdr;
198static int cur_fd;
199
c50c785c 200/* Index of current symbol. */
5796c8dc
SS
201
202static int cur_sdx;
203
204/* Note how much "debuggable" this image is. We would like
c50c785c 205 to see at least one FDR with full symbols. */
5796c8dc
SS
206
207static int max_gdbinfo;
208static int max_glevel;
209
c50c785c 210/* When examining .o files, report on undefined symbols. */
5796c8dc
SS
211
212static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
213
214/* Pseudo symbol to use when putting stabs into the symbol table. */
215
216static char stabs_symbol[] = STABS_SYMBOL;
217
218/* Nonzero if we have seen ecoff debugging info for a file. */
219
220static int found_ecoff_debugging_info;
221
c50c785c 222/* Forward declarations. */
5796c8dc
SS
223
224static int upgrade_type (int, struct type **, int, union aux_ext *,
225 int, char *);
226
227static void parse_partial_symbols (struct objfile *);
228
229static int has_opaque_xref (FDR *, SYMR *);
230
231static int cross_ref (int, union aux_ext *, struct type **, enum type_code,
232 char **, int, char *);
233
234static struct symbol *new_symbol (char *);
235
236static struct type *new_type (char *);
237
238enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };
239
240static struct block *new_block (enum block_type);
241
c50c785c 242static struct symtab *new_symtab (const char *, int, struct objfile *);
5796c8dc
SS
243
244static struct linetable *new_linetable (int);
245
246static struct blockvector *new_bvect (int);
247
248static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
249 int, char *);
250
251static struct symbol *mylookup_symbol (char *, struct block *, domain_enum,
252 enum address_class);
253
254static void sort_blocks (struct symtab *);
255
256static struct partial_symtab *new_psymtab (char *, struct objfile *);
257
ef5ccd6c
JM
258static void psymtab_to_symtab_1 (struct objfile *objfile,
259 struct partial_symtab *, const char *);
5796c8dc
SS
260
261static void add_block (struct block *, struct symtab *);
262
263static void add_symbol (struct symbol *, struct symtab *, struct block *);
264
265static int add_line (struct linetable *, int, CORE_ADDR, int);
266
267static struct linetable *shrink_linetable (struct linetable *);
268
269static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
270 CORE_ADDR);
271
272static char *mdebug_next_symbol_text (struct objfile *);
273\f
ef5ccd6c
JM
274/* Exported procedure: Builds a symtab from the partial symtab SELF.
275 Restores the environment in effect when SELF was created, delegates
5796c8dc 276 most of the work to an ancillary procedure, and sorts
ef5ccd6c 277 and reorders the symtab list at the end. SELF is not NULL. */
5796c8dc
SS
278
279static void
ef5ccd6c 280mdebug_read_symtab (struct partial_symtab *self, struct objfile *objfile)
5796c8dc 281{
5796c8dc
SS
282 if (info_verbose)
283 {
ef5ccd6c 284 printf_filtered (_("Reading in symbols for %s..."), self->filename);
5796c8dc
SS
285 gdb_flush (gdb_stdout);
286 }
287
288 next_symbol_text_func = mdebug_next_symbol_text;
289
ef5ccd6c 290 psymtab_to_symtab_1 (objfile, self, self->filename);
5796c8dc
SS
291
292 /* Match with global symbols. This only needs to be done once,
c50c785c 293 after all of the symtabs and dependencies have been read in. */
ef5ccd6c 294 scan_file_globals (objfile);
5796c8dc
SS
295
296 if (info_verbose)
297 printf_filtered (_("done.\n"));
298}
299\f
c50c785c 300/* File-level interface functions. */
5796c8dc 301
c50c785c 302/* Find a file descriptor given its index RF relative to a file CF. */
5796c8dc
SS
303
304static FDR *
305get_rfd (int cf, int rf)
306{
307 FDR *fdrs;
308 FDR *f;
309 RFDT rfd;
310
311 fdrs = debug_info->fdr;
312 f = fdrs + cf;
c50c785c 313 /* Object files do not have the RFD table, all refs are absolute. */
5796c8dc
SS
314 if (f->rfdBase == 0)
315 return fdrs + rf;
316 (*debug_swap->swap_rfd_in) (cur_bfd,
317 ((char *) debug_info->external_rfd
318 + ((f->rfdBase + rf)
319 * debug_swap->external_rfd_size)),
320 &rfd);
321 return fdrs + rfd;
322}
323
c50c785c 324/* Return a safer print NAME for a file descriptor. */
5796c8dc
SS
325
326static char *
327fdr_name (FDR *f)
328{
329 if (f->rss == -1)
330 return "<stripped file>";
331 if (f->rss == 0)
332 return "<NFY>";
333 return debug_info->ss + f->issBase + f->rss;
334}
335
336
337/* Read in and parse the symtab of the file OBJFILE. Symbols from
338 different sections are relocated via the SECTION_OFFSETS. */
339
340void
341mdebug_build_psymtabs (struct objfile *objfile,
342 const struct ecoff_debug_swap *swap,
343 struct ecoff_debug_info *info)
344{
345 cur_bfd = objfile->obfd;
346 debug_swap = swap;
347 debug_info = info;
348
349 stabsread_new_init ();
350 buildsym_new_init ();
351 free_header_files ();
352 init_header_files ();
353
354 /* Make sure all the FDR information is swapped in. */
355 if (info->fdr == (FDR *) NULL)
356 {
357 char *fdr_src;
358 char *fdr_end;
359 FDR *fdr_ptr;
360
361 info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack,
362 (info->symbolic_header.ifdMax
363 * sizeof (FDR)));
364 fdr_src = info->external_fdr;
365 fdr_end = (fdr_src
366 + info->symbolic_header.ifdMax * swap->external_fdr_size);
367 fdr_ptr = info->fdr;
368 for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++)
369 (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);
370 }
371
372 parse_partial_symbols (objfile);
373
374#if 0
375 /* Check to make sure file was compiled with -g. If not, warn the
376 user of this limitation. */
377 if (compare_glevel (max_glevel, GLEVEL_2) < 0)
378 {
379 if (max_gdbinfo == 0)
c50c785c
JM
380 printf_unfiltered (_("\n%s not compiled with -g, "
381 "debugging support is limited.\n"),
5796c8dc 382 objfile->name);
c50c785c
JM
383 printf_unfiltered (_("You should compile with -g2 or "
384 "-g3 for best debugging support.\n"));
5796c8dc
SS
385 gdb_flush (gdb_stdout);
386 }
387#endif
388}
389\f
390/* Local utilities */
391
c50c785c 392/* Map of FDR indexes to partial symtabs. */
5796c8dc
SS
393
394struct pst_map
395{
396 struct partial_symtab *pst; /* the psymtab proper */
397 long n_globals; /* exported globals (external symbols) */
398 long globals_offset; /* cumulative */
399};
400
401
402/* Utility stack, used to nest procedures and blocks properly.
403 It is a doubly linked list, to avoid too many alloc/free.
404 Since we might need it quite a few times it is NOT deallocated
c50c785c 405 after use. */
5796c8dc
SS
406
407static struct parse_stack
408 {
409 struct parse_stack *next, *prev;
c50c785c
JM
410 struct symtab *cur_st; /* Current symtab. */
411 struct block *cur_block; /* Block in it. */
5796c8dc
SS
412
413 /* What are we parsing. stFile, or stBlock are for files and
414 blocks. stProc or stStaticProc means we have seen the start of a
415 procedure, but not the start of the block within in. When we see
416 the start of that block, we change it to stNil, without pushing a
417 new block, i.e. stNil means both a procedure and a block. */
418
419 int blocktype;
420
c50c785c
JM
421 struct type *cur_type; /* Type we parse fields for. */
422 int cur_field; /* Field number in cur_type. */
423 CORE_ADDR procadr; /* Start addres of this procedure. */
424 int numargs; /* Its argument count. */
5796c8dc
SS
425 }
426
427 *top_stack; /* Top stack ptr */
428
429
c50c785c 430/* Enter a new lexical context. */
5796c8dc
SS
431
432static void
433push_parse_stack (void)
434{
435 struct parse_stack *new;
436
c50c785c 437 /* Reuse frames if possible. */
5796c8dc
SS
438 if (top_stack && top_stack->prev)
439 new = top_stack->prev;
440 else
441 new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
c50c785c 442 /* Initialize new frame with previous content. */
5796c8dc
SS
443 if (top_stack)
444 {
445 struct parse_stack *prev = new->prev;
446
447 *new = *top_stack;
448 top_stack->prev = new;
449 new->prev = prev;
450 new->next = top_stack;
451 }
452 top_stack = new;
453}
454
c50c785c 455/* Exit a lexical context. */
5796c8dc
SS
456
457static void
458pop_parse_stack (void)
459{
460 if (!top_stack)
461 return;
462 if (top_stack->next)
463 top_stack = top_stack->next;
464}
465
466
467/* Cross-references might be to things we haven't looked at
468 yet, e.g. type references. To avoid too many type
469 duplications we keep a quick fixup table, an array
c50c785c 470 of lists of references indexed by file descriptor. */
5796c8dc
SS
471
472struct mdebug_pending
473{
474 struct mdebug_pending *next; /* link */
475 char *s; /* the unswapped symbol */
476 struct type *t; /* its partial type descriptor */
477};
478
479
ef5ccd6c
JM
480/* The pending information is kept for an entire object file. We
481 allocate the pending information table when we create the partial
482 symbols, and we store a pointer to the single table in each
483 psymtab. */
5796c8dc
SS
484
485static struct mdebug_pending **pending_list;
486
c50c785c 487/* Check whether we already saw symbol SH in file FH. */
5796c8dc
SS
488
489static struct mdebug_pending *
490is_pending_symbol (FDR *fh, char *sh)
491{
492 int f_idx = fh - debug_info->fdr;
493 struct mdebug_pending *p;
494
c50c785c 495 /* Linear search is ok, list is typically no more than 10 deep. */
5796c8dc
SS
496 for (p = pending_list[f_idx]; p; p = p->next)
497 if (p->s == sh)
498 break;
499 return p;
500}
501
c50c785c 502/* Add a new symbol SH of type T. */
5796c8dc
SS
503
504static void
505add_pending (FDR *fh, char *sh, struct type *t)
506{
507 int f_idx = fh - debug_info->fdr;
508 struct mdebug_pending *p = is_pending_symbol (fh, sh);
509
c50c785c 510 /* Make sure we do not make duplicates. */
5796c8dc
SS
511 if (!p)
512 {
513 p = ((struct mdebug_pending *)
a45ae5f8 514 obstack_alloc (&mdebugread_objfile->objfile_obstack,
5796c8dc
SS
515 sizeof (struct mdebug_pending)));
516 p->s = sh;
517 p->t = t;
518 p->next = pending_list[f_idx];
519 pending_list[f_idx] = p;
520 }
521}
522\f
523
c50c785c 524/* Parsing Routines proper. */
5796c8dc 525
c50c785c 526/* Parse a single symbol. Mostly just make up a GDB symbol for it.
5796c8dc
SS
527 For blocks, procedures and types we open a new lexical context.
528 This is basically just a big switch on the symbol's type. Argument
529 AX is the base pointer of aux symbols for this file (fh->iauxBase).
530 EXT_SH points to the unswapped symbol, which is needed for struct,
531 union, etc., types; it is NULL for an EXTR. BIGEND says whether
532 aux symbols are big-endian or little-endian. Return count of
533 SYMR's handled (normally one). */
534
535static int
536mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
537{
538 return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
539}
540
541static const struct symbol_register_ops mdebug_register_funcs = {
542 mdebug_reg_to_regnum
543};
544
545static int
546parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
547 struct section_offsets *section_offsets, struct objfile *objfile)
548{
549 struct gdbarch *gdbarch = get_objfile_arch (objfile);
550 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
551 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
552 char *name;
553 struct symbol *s;
554 struct block *b;
555 struct mdebug_pending *pend;
556 struct type *t;
557 struct field *f;
558 int count = 1;
559 enum address_class class;
560 TIR tir;
561 long svalue = sh->value;
562 int bitsize;
563
564 if (ext_sh == (char *) NULL)
565 name = debug_info->ssext + sh->iss;
566 else
567 name = debug_info->ss + cur_fdr->issBase + sh->iss;
568
569 switch (sh->sc)
570 {
571 case scText:
572 case scRConst:
573 /* Do not relocate relative values.
574 The value of a stEnd symbol is the displacement from the
575 corresponding start symbol value.
576 The value of a stBlock symbol is the displacement from the
577 procedure address. */
578 if (sh->st != stEnd && sh->st != stBlock)
579 sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
580 break;
581 case scData:
582 case scSData:
583 case scRData:
584 case scPData:
585 case scXData:
586 sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
587 break;
588 case scBss:
589 case scSBss:
590 sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
591 break;
592 }
593
594 switch (sh->st)
595 {
596 case stNil:
597 break;
598
c50c785c 599 case stGlobal: /* External symbol, goes into global block. */
5796c8dc
SS
600 class = LOC_STATIC;
601 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
602 GLOBAL_BLOCK);
603 s = new_symbol (name);
604 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
605 goto data;
606
c50c785c 607 case stStatic: /* Static data, goes into current block. */
5796c8dc
SS
608 class = LOC_STATIC;
609 b = top_stack->cur_block;
610 s = new_symbol (name);
611 if (SC_IS_COMMON (sh->sc))
612 {
613 /* It is a FORTRAN common block. At least for SGI Fortran the
614 address is not in the symbol; we need to fix it later in
615 scan_file_globals. */
616 int bucket = hashname (SYMBOL_LINKAGE_NAME (s));
617 SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
618 global_sym_chain[bucket] = s;
619 }
620 else
621 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
622 goto data;
623
c50c785c 624 case stLocal: /* Local variable, goes into current block. */
5796c8dc
SS
625 b = top_stack->cur_block;
626 s = new_symbol (name);
627 SYMBOL_VALUE (s) = svalue;
628 if (sh->sc == scRegister)
629 {
630 class = LOC_REGISTER;
631 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
632 }
633 else
634 class = LOC_LOCAL;
635
c50c785c 636 data: /* Common code for symbols describing data. */
5796c8dc
SS
637 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
638 SYMBOL_CLASS (s) = class;
639 add_symbol (s, top_stack->cur_st, b);
640
641 /* Type could be missing if file is compiled without debugging info. */
642 if (SC_IS_UNDEF (sh->sc)
643 || sh->sc == scNil || sh->index == indexNil)
644 SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol;
645 else
646 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
c50c785c 647 /* Value of a data symbol is its memory address. */
5796c8dc
SS
648 break;
649
c50c785c
JM
650 case stParam: /* Arg to procedure, goes into current
651 block. */
5796c8dc
SS
652 max_gdbinfo++;
653 found_ecoff_debugging_info = 1;
654 top_stack->numargs++;
655
656 /* Special GNU C++ name. */
657 if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0)
c50c785c 658 name = "this"; /* FIXME, not alloc'd in obstack. */
5796c8dc
SS
659 s = new_symbol (name);
660
661 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
662 SYMBOL_IS_ARGUMENT (s) = 1;
663 switch (sh->sc)
664 {
665 case scRegister:
666 /* Pass by value in register. */
667 SYMBOL_CLASS (s) = LOC_REGISTER;
668 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
669 break;
670 case scVar:
671 /* Pass by reference on stack. */
672 SYMBOL_CLASS (s) = LOC_REF_ARG;
673 break;
674 case scVarRegister:
675 /* Pass by reference in register. */
676 SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
677 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
678 break;
679 default:
680 /* Pass by value on stack. */
681 SYMBOL_CLASS (s) = LOC_ARG;
682 break;
683 }
684 SYMBOL_VALUE (s) = svalue;
685 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
686 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
687 break;
688
c50c785c 689 case stLabel: /* label, goes into current block. */
5796c8dc 690 s = new_symbol (name);
c50c785c
JM
691 SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* So that it can be used */
692 SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused. */
5796c8dc
SS
693 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
694 SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
695 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
696 break;
697
c50c785c
JM
698 case stProc: /* Procedure, usually goes into global block. */
699 case stStaticProc: /* Static procedure, goes into current block. */
5796c8dc
SS
700 /* For stProc symbol records, we need to check the storage class
701 as well, as only (stProc, scText) entries represent "real"
702 procedures - See the Compaq document titled "Object File /
703 Symbol Table Format Specification" for more information.
704 If the storage class is not scText, we discard the whole block
705 of symbol records for this stProc. */
706 if (sh->st == stProc && sh->sc != scText)
707 {
708 char *ext_tsym = ext_sh;
709 int keep_counting = 1;
710 SYMR tsym;
711
712 while (keep_counting)
713 {
714 ext_tsym += external_sym_size;
715 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
716 count++;
717 switch (tsym.st)
718 {
719 case stParam:
720 break;
721 case stEnd:
722 keep_counting = 0;
723 break;
724 default:
725 complaint (&symfile_complaints,
726 _("unknown symbol type 0x%x"), sh->st);
727 break;
728 }
729 }
730 break;
731 }
732 s = new_symbol (name);
733 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
734 SYMBOL_CLASS (s) = LOC_BLOCK;
c50c785c 735 /* Type of the return value. */
5796c8dc
SS
736 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
737 t = objfile_type (objfile)->builtin_int;
738 else
739 {
740 t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
741 if (strcmp (name, "malloc") == 0
742 && TYPE_CODE (t) == TYPE_CODE_VOID)
743 {
744 /* I don't know why, but, at least under Alpha GNU/Linux,
745 when linking against a malloc without debugging
746 symbols, its read as a function returning void---this
747 is bad because it means we cannot call functions with
748 string arguments interactively; i.e., "call
749 printf("howdy\n")" would fail with the error message
750 "program has no memory available". To avoid this, we
751 patch up the type and make it void*
c50c785c 752 instead. (davidm@azstarnet.com). */
5796c8dc
SS
753 t = make_pointer_type (t, NULL);
754 }
755 }
756 b = top_stack->cur_block;
757 if (sh->st == stProc)
758 {
759 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
cf7f2e2d 760
5796c8dc
SS
761 /* The next test should normally be true, but provides a
762 hook for nested functions (which we don't want to make
763 global). */
764 if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
765 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
766 /* Irix 5 sometimes has duplicate names for the same
767 function. We want to add such names up at the global
768 level, not as a nested function. */
769 else if (sh->value == top_stack->procadr)
770 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
771 }
772 add_symbol (s, top_stack->cur_st, b);
773
c50c785c 774 /* Make a type for the procedure itself. */
5796c8dc
SS
775 SYMBOL_TYPE (s) = lookup_function_type (t);
776
777 /* All functions in C++ have prototypes. For C we don't have enough
778 information in the debug info. */
779 if (SYMBOL_LANGUAGE (s) == language_cplus)
780 TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
781
c50c785c 782 /* Create and enter a new lexical context. */
5796c8dc
SS
783 b = new_block (FUNCTION_BLOCK);
784 SYMBOL_BLOCK_VALUE (s) = b;
785 BLOCK_FUNCTION (b) = s;
786 BLOCK_START (b) = BLOCK_END (b) = sh->value;
787 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
788 add_block (b, top_stack->cur_st);
789
c50c785c 790 /* Not if we only have partial info. */
5796c8dc
SS
791 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
792 break;
793
794 push_parse_stack ();
795 top_stack->cur_block = b;
796 top_stack->blocktype = sh->st;
797 top_stack->cur_type = SYMBOL_TYPE (s);
798 top_stack->cur_field = -1;
799 top_stack->procadr = sh->value;
800 top_stack->numargs = 0;
801 break;
802
803 /* Beginning of code for structure, union, and enum definitions.
804 They all share a common set of local variables, defined here. */
805 {
806 enum type_code type_code;
807 char *ext_tsym;
808 int nfields;
809 long max_value;
810 struct field *f;
811
c50c785c 812 case stStruct: /* Start a block defining a struct type. */
5796c8dc
SS
813 type_code = TYPE_CODE_STRUCT;
814 goto structured_common;
815
c50c785c 816 case stUnion: /* Start a block defining a union type. */
5796c8dc
SS
817 type_code = TYPE_CODE_UNION;
818 goto structured_common;
819
c50c785c 820 case stEnum: /* Start a block defining an enum type. */
5796c8dc
SS
821 type_code = TYPE_CODE_ENUM;
822 goto structured_common;
823
c50c785c 824 case stBlock: /* Either a lexical block, or some type. */
5796c8dc
SS
825 if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc))
826 goto case_stBlock_code; /* Lexical block */
827
828 type_code = TYPE_CODE_UNDEF; /* We have a type. */
829
830 /* Common code for handling struct, union, enum, and/or as-yet-
831 unknown-type blocks of info about structured data. `type_code'
832 has been set to the proper TYPE_CODE, if we know it. */
833 structured_common:
834 found_ecoff_debugging_info = 1;
835 push_parse_stack ();
836 top_stack->blocktype = stBlock;
837
c50c785c 838 /* First count the number of fields and the highest value. */
5796c8dc
SS
839 nfields = 0;
840 max_value = 0;
841 for (ext_tsym = ext_sh + external_sym_size;
842 ;
843 ext_tsym += external_sym_size)
844 {
845 SYMR tsym;
846
847 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
848
849 switch (tsym.st)
850 {
851 case stEnd:
852 /* C++ encodes class types as structures where there the
c50c785c 853 methods are encoded as stProc. The scope of stProc
5796c8dc
SS
854 symbols also ends with stEnd, thus creating a risk of
855 taking the wrong stEnd symbol record as the end of
856 the current struct, which would cause GDB to undercount
857 the real number of fields in this struct. To make sure
858 we really reached the right stEnd symbol record, we
859 check the associated name, and match it against the
860 struct name. Since method names are mangled while
861 the class name is not, there is no risk of having a
862 method whose name is identical to the class name
863 (in particular constructor method names are different
864 from the class name). There is therefore no risk that
865 this check stops the count on the StEnd of a method.
866
867 Also, assume that we're really at the end when tsym.iss
868 is 0 (issNull). */
869 if (tsym.iss == issNull
870 || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss,
871 name) == 0)
872 goto end_of_fields;
873 break;
874
875 case stMember:
876 if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
877 {
878 /* If the type of the member is Nil (or Void),
879 without qualifiers, assume the tag is an
880 enumeration.
881 Alpha cc -migrate enums are recognized by a zero
882 index and a zero symbol value.
883 DU 4.0 cc enums are recognized by a member type of
884 btEnum without qualifiers and a zero symbol value. */
885 if (tsym.index == indexNil
886 || (tsym.index == 0 && sh->value == 0))
887 type_code = TYPE_CODE_ENUM;
888 else
889 {
890 (*debug_swap->swap_tir_in) (bigend,
891 &ax[tsym.index].a_ti,
892 &tir);
893 if ((tir.bt == btNil || tir.bt == btVoid
894 || (tir.bt == btEnum && sh->value == 0))
895 && tir.tq0 == tqNil)
896 type_code = TYPE_CODE_ENUM;
897 }
898 }
899 nfields++;
900 if (tsym.value > max_value)
901 max_value = tsym.value;
902 break;
903
904 case stBlock:
905 case stUnion:
906 case stEnum:
907 case stStruct:
908 {
909#if 0
910 /* This is a no-op; is it trying to tell us something
911 we should be checking? */
912 if (tsym.sc == scVariant); /*UNIMPLEMENTED */
913#endif
914 if (tsym.index != 0)
915 {
916 /* This is something like a struct within a
917 struct. Skip over the fields of the inner
918 struct. The -1 is because the for loop will
919 increment ext_tsym. */
920 ext_tsym = ((char *) debug_info->external_sym
921 + ((cur_fdr->isymBase + tsym.index - 1)
922 * external_sym_size));
923 }
924 }
925 break;
926
927 case stTypedef:
928 /* mips cc puts out a typedef for struct x if it is not yet
929 defined when it encounters
930 struct y { struct x *xp; };
c50c785c 931 Just ignore it. */
5796c8dc
SS
932 break;
933
934 case stIndirect:
935 /* Irix5 cc puts out a stIndirect for struct x if it is not
936 yet defined when it encounters
937 struct y { struct x *xp; };
c50c785c 938 Just ignore it. */
5796c8dc
SS
939 break;
940
941 default:
942 complaint (&symfile_complaints,
c50c785c
JM
943 _("declaration block contains "
944 "unhandled symbol type %d"),
5796c8dc
SS
945 tsym.st);
946 }
947 }
c50c785c 948 end_of_fields:
5796c8dc
SS
949
950 /* In an stBlock, there is no way to distinguish structs,
951 unions, and enums at this point. This is a bug in the
952 original design (that has been fixed with the recent
953 addition of the stStruct, stUnion, and stEnum symbol
954 types.) The way you can tell is if/when you see a variable
955 or field of that type. In that case the variable's type
956 (in the AUX table) says if the type is struct, union, or
957 enum, and points back to the stBlock here. So you can
958 patch the tag kind up later - but only if there actually is
959 a variable or field of that type.
960
961 So until we know for sure, we will guess at this point.
962 The heuristic is:
963 If the first member has index==indexNil or a void type,
964 assume we have an enumeration.
965 Otherwise, if there is more than one member, and all
966 the members have offset 0, assume we have a union.
967 Otherwise, assume we have a struct.
968
969 The heuristic could guess wrong in the case of of an
970 enumeration with no members or a union with one (or zero)
971 members, or when all except the last field of a struct have
972 width zero. These are uncommon and/or illegal situations,
973 and in any case guessing wrong probably doesn't matter
974 much.
975
976 But if we later do find out we were wrong, we fixup the tag
977 kind. Members of an enumeration must be handled
978 differently from struct/union fields, and that is harder to
979 patch up, but luckily we shouldn't need to. (If there are
980 any enumeration members, we can tell for sure it's an enum
c50c785c 981 here.) */
5796c8dc
SS
982
983 if (type_code == TYPE_CODE_UNDEF)
984 {
985 if (nfields > 1 && max_value == 0)
986 type_code = TYPE_CODE_UNION;
987 else
988 type_code = TYPE_CODE_STRUCT;
989 }
990
991 /* Create a new type or use the pending type. */
992 pend = is_pending_symbol (cur_fdr, ext_sh);
993 if (pend == (struct mdebug_pending *) NULL)
994 {
995 t = new_type (NULL);
996 add_pending (cur_fdr, ext_sh, t);
997 }
998 else
999 t = pend->t;
1000
1001 /* Do not set the tag name if it is a compiler generated tag name
1002 (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1003 Alpha cc puts out an sh->iss of zero for those. */
1004 if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
1005 TYPE_TAG_NAME (t) = NULL;
1006 else
a45ae5f8 1007 TYPE_TAG_NAME (t) = obconcat (&mdebugread_objfile->objfile_obstack,
c50c785c 1008 name, (char *) NULL);
5796c8dc
SS
1009
1010 TYPE_CODE (t) = type_code;
1011 TYPE_LENGTH (t) = sh->value;
1012 TYPE_NFIELDS (t) = nfields;
1013 TYPE_FIELDS (t) = f = ((struct field *)
1014 TYPE_ALLOC (t,
1015 nfields * sizeof (struct field)));
1016
1017 if (type_code == TYPE_CODE_ENUM)
1018 {
1019 int unsigned_enum = 1;
1020
c50c785c 1021 /* This is a non-empty enum. */
5796c8dc
SS
1022
1023 /* DEC c89 has the number of enumerators in the sh.value field,
1024 not the type length, so we have to compensate for that
1025 incompatibility quirk.
1026 This might do the wrong thing for an enum with one or two
1027 enumerators and gcc -gcoff -fshort-enums, but these cases
1028 are hopefully rare enough.
1029 Alpha cc -migrate has a sh.value field of zero, we adjust
1030 that too. */
1031 if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
1032 || TYPE_LENGTH (t) == 0)
1033 TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
1034 for (ext_tsym = ext_sh + external_sym_size;
1035 ;
1036 ext_tsym += external_sym_size)
1037 {
1038 SYMR tsym;
1039 struct symbol *enum_sym;
1040
1041 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
1042
1043 if (tsym.st != stMember)
1044 break;
1045
ef5ccd6c 1046 SET_FIELD_ENUMVAL (*f, tsym.value);
5796c8dc
SS
1047 FIELD_TYPE (*f) = t;
1048 FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
1049 FIELD_BITSIZE (*f) = 0;
1050
1051 enum_sym = ((struct symbol *)
a45ae5f8 1052 obstack_alloc (&mdebugread_objfile->objfile_obstack,
5796c8dc
SS
1053 sizeof (struct symbol)));
1054 memset (enum_sym, 0, sizeof (struct symbol));
1055 SYMBOL_SET_LINKAGE_NAME
ef5ccd6c
JM
1056 (enum_sym,
1057 obstack_copy0 (&mdebugread_objfile->objfile_obstack,
1058 f->name, strlen (f->name)));
5796c8dc
SS
1059 SYMBOL_CLASS (enum_sym) = LOC_CONST;
1060 SYMBOL_TYPE (enum_sym) = t;
1061 SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
1062 SYMBOL_VALUE (enum_sym) = tsym.value;
1063 if (SYMBOL_VALUE (enum_sym) < 0)
1064 unsigned_enum = 0;
1065 add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block);
1066
c50c785c 1067 /* Skip the stMembers that we've handled. */
5796c8dc
SS
1068 count++;
1069 f++;
1070 }
1071 if (unsigned_enum)
1072 TYPE_UNSIGNED (t) = 1;
1073 }
c50c785c 1074 /* Make this the current type. */
5796c8dc
SS
1075 top_stack->cur_type = t;
1076 top_stack->cur_field = 0;
1077
1078 /* Do not create a symbol for alpha cc unnamed structs. */
1079 if (sh->iss == 0)
1080 break;
1081
1082 /* gcc puts out an empty struct for an opaque struct definitions,
1083 do not create a symbol for it either. */
1084 if (TYPE_NFIELDS (t) == 0)
1085 {
1086 TYPE_STUB (t) = 1;
1087 break;
1088 }
1089
1090 s = new_symbol (name);
1091 SYMBOL_DOMAIN (s) = STRUCT_DOMAIN;
1092 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1093 SYMBOL_VALUE (s) = 0;
1094 SYMBOL_TYPE (s) = t;
1095 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1096 break;
1097
1098 /* End of local variables shared by struct, union, enum, and
1099 block (as yet unknown struct/union/enum) processing. */
1100 }
1101
1102 case_stBlock_code:
1103 found_ecoff_debugging_info = 1;
c50c785c
JM
1104 /* Beginnning of (code) block. Value of symbol
1105 is the displacement from procedure start. */
5796c8dc
SS
1106 push_parse_stack ();
1107
1108 /* Do not start a new block if this is the outermost block of a
1109 procedure. This allows the LOC_BLOCK symbol to point to the
1110 block with the local variables, so funcname::var works. */
1111 if (top_stack->blocktype == stProc
1112 || top_stack->blocktype == stStaticProc)
1113 {
1114 top_stack->blocktype = stNil;
1115 break;
1116 }
1117
1118 top_stack->blocktype = stBlock;
1119 b = new_block (NON_FUNCTION_BLOCK);
1120 BLOCK_START (b) = sh->value + top_stack->procadr;
1121 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1122 top_stack->cur_block = b;
1123 add_block (b, top_stack->cur_st);
1124 break;
1125
1126 case stEnd: /* end (of anything) */
1127 if (sh->sc == scInfo || SC_IS_COMMON (sh->sc))
1128 {
1129 /* Finished with type */
1130 top_stack->cur_type = 0;
1131 }
1132 else if (sh->sc == scText &&
1133 (top_stack->blocktype == stProc ||
1134 top_stack->blocktype == stStaticProc))
1135 {
1136 /* Finished with procedure */
1137 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
1138 struct mdebug_extra_func_info *e;
1139 struct block *b = top_stack->cur_block;
1140 struct type *ftype = top_stack->cur_type;
1141 int i;
1142
1143 BLOCK_END (top_stack->cur_block) += sh->value; /* size */
1144
c50c785c 1145 /* Make up special symbol to contain procedure specific info. */
5796c8dc
SS
1146 s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
1147 SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
1148 SYMBOL_CLASS (s) = LOC_CONST;
a45ae5f8 1149 SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->builtin_void;
5796c8dc 1150 e = ((struct mdebug_extra_func_info *)
a45ae5f8 1151 obstack_alloc (&mdebugread_objfile->objfile_obstack,
5796c8dc
SS
1152 sizeof (struct mdebug_extra_func_info)));
1153 memset (e, 0, sizeof (struct mdebug_extra_func_info));
1154 SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
1155 e->numargs = top_stack->numargs;
1156 e->pdr.framereg = -1;
1157 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1158
1159 /* f77 emits proc-level with address bounds==[0,0],
1160 So look for such child blocks, and patch them. */
1161 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
1162 {
1163 struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
cf7f2e2d 1164
5796c8dc
SS
1165 if (BLOCK_SUPERBLOCK (b_bad) == b
1166 && BLOCK_START (b_bad) == top_stack->procadr
1167 && BLOCK_END (b_bad) == top_stack->procadr)
1168 {
1169 BLOCK_START (b_bad) = BLOCK_START (b);
1170 BLOCK_END (b_bad) = BLOCK_END (b);
1171 }
1172 }
1173
1174 if (TYPE_NFIELDS (ftype) <= 0)
1175 {
1176 /* No parameter type information is recorded with the function's
c50c785c 1177 type. Set that from the type of the parameter symbols. */
5796c8dc
SS
1178 int nparams = top_stack->numargs;
1179 int iparams;
1180 struct symbol *sym;
1181
1182 if (nparams > 0)
1183 {
ef5ccd6c 1184 struct block_iterator iter;
cf7f2e2d 1185
5796c8dc
SS
1186 TYPE_NFIELDS (ftype) = nparams;
1187 TYPE_FIELDS (ftype) = (struct field *)
1188 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
1189
1190 iparams = 0;
1191 ALL_BLOCK_SYMBOLS (b, iter, sym)
1192 {
1193 if (iparams == nparams)
1194 break;
1195
1196 if (SYMBOL_IS_ARGUMENT (sym))
1197 {
1198 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
1199 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
1200 iparams++;
1201 }
1202 }
1203 }
1204 }
1205 }
1206 else if (sh->sc == scText && top_stack->blocktype == stBlock)
1207 {
c50c785c 1208 /* End of (code) block. The value of the symbol is the
5796c8dc 1209 displacement from the procedure`s start address of the
c50c785c 1210 end of this block. */
5796c8dc
SS
1211 BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
1212 }
1213 else if (sh->sc == scText && top_stack->blocktype == stNil)
1214 {
1215 /* End of outermost block. Pop parse stack and ignore. The
1216 following stEnd of stProc will take care of the block. */
1217 ;
1218 }
1219 else if (sh->sc == scText && top_stack->blocktype == stFile)
1220 {
1221 /* End of file. Pop parse stack and ignore. Higher
1222 level code deals with this. */
1223 ;
1224 }
1225 else
1226 complaint (&symfile_complaints,
1227 _("stEnd with storage class %d not handled"), sh->sc);
1228
c50c785c 1229 pop_parse_stack (); /* Restore previous lexical context. */
5796c8dc
SS
1230 break;
1231
1232 case stMember: /* member of struct or union */
1233 f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
1234 FIELD_NAME (*f) = name;
1235 SET_FIELD_BITPOS (*f, sh->value);
1236 bitsize = 0;
c50c785c
JM
1237 FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index,
1238 &bitsize, bigend, name);
5796c8dc
SS
1239 FIELD_BITSIZE (*f) = bitsize;
1240 break;
1241
1242 case stIndirect: /* forward declaration on Irix5 */
1243 /* Forward declarations from Irix5 cc are handled by cross_ref,
1244 skip them. */
1245 break;
1246
1247 case stTypedef: /* type definition */
1248 found_ecoff_debugging_info = 1;
1249
1250 /* Typedefs for forward declarations and opaque structs from alpha cc
1251 are handled by cross_ref, skip them. */
1252 if (sh->iss == 0)
1253 break;
1254
1255 /* Parse the type or use the pending type. */
1256 pend = is_pending_symbol (cur_fdr, ext_sh);
1257 if (pend == (struct mdebug_pending *) NULL)
1258 {
1259 t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name);
1260 add_pending (cur_fdr, ext_sh, t);
1261 }
1262 else
1263 t = pend->t;
1264
c50c785c
JM
1265 /* Mips cc puts out a typedef with the name of the struct for forward
1266 declarations. These should not go into the symbol table and
5796c8dc
SS
1267 TYPE_NAME should not be set for them.
1268 They can't be distinguished from an intentional typedef to
1269 the same name however:
1270 x.h:
1271 struct x { int ix; int jx; };
1272 struct xx;
1273 x.c:
1274 typedef struct x x;
1275 struct xx {int ixx; int jxx; };
1276 generates a cross referencing stTypedef for x and xx.
1277 The user visible effect of this is that the type of a pointer
1278 to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1279 The problem is fixed with alpha cc and Irix5 cc. */
1280
1281 /* However if the typedef cross references to an opaque aggregate, it
1282 is safe to omit it from the symbol table. */
1283
1284 if (has_opaque_xref (cur_fdr, sh))
1285 break;
1286 s = new_symbol (name);
1287 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
1288 SYMBOL_CLASS (s) = LOC_TYPEDEF;
1289 SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
1290 SYMBOL_TYPE (s) = t;
1291 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1292
1293 /* Incomplete definitions of structs should not get a name. */
1294 if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
1295 && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0
1296 || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT
1297 && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION)))
1298 {
1299 if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR
1300 || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC)
1301 {
1302 /* If we are giving a name to a type such as "pointer to
1303 foo" or "function returning foo", we better not set
1304 the TYPE_NAME. If the program contains "typedef char
1305 *caddr_t;", we don't want all variables of type char
1306 * to print as caddr_t. This is not just a
1307 consequence of GDB's type management; CC and GCC (at
1308 least through version 2.4) both output variables of
1309 either type char * or caddr_t with the type
1310 refering to the stTypedef symbol for caddr_t. If a future
1311 compiler cleans this up it GDB is not ready for it
1312 yet, but if it becomes ready we somehow need to
1313 disable this check (without breaking the PCC/GCC2.4
1314 case).
1315
1316 Sigh.
1317
1318 Fortunately, this check seems not to be necessary
1319 for anything except pointers or functions. */
1320 }
1321 else
1322 TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s);
1323 }
1324 break;
1325
1326 case stFile: /* file name */
1327 push_parse_stack ();
1328 top_stack->blocktype = sh->st;
1329 break;
1330
1331 /* I`ve never seen these for C */
1332 case stRegReloc:
1333 break; /* register relocation */
1334 case stForward:
1335 break; /* forwarding address */
1336 case stConstant:
1337 break; /* constant */
1338 default:
1339 complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
1340 break;
1341 }
1342
1343 return count;
1344}
1345
1346/* Basic types. */
1347
1348static const struct objfile_data *basic_type_data;
1349
1350static struct type *
1351basic_type (int bt, struct objfile *objfile)
1352{
1353 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1354 struct type **map_bt = objfile_data (objfile, basic_type_data);
1355 struct type *tp;
1356
1357 if (bt >= btMax)
1358 return NULL;
1359
1360 if (!map_bt)
1361 {
1362 map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack,
1363 btMax, struct type *);
1364 set_objfile_data (objfile, basic_type_data, map_bt);
1365 }
1366
1367 if (map_bt[bt])
1368 return map_bt[bt];
1369
1370 switch (bt)
1371 {
1372 case btNil:
1373 tp = objfile_type (objfile)->builtin_void;
1374 break;
1375
1376 case btAdr:
1377 tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED,
1378 "adr_32", objfile);
1379 TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
1380 break;
1381
1382 case btChar:
1383 tp = init_type (TYPE_CODE_INT, 1, 0,
1384 "char", objfile);
1385 break;
1386
1387 case btUChar:
1388 tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
1389 "unsigned char", objfile);
1390 break;
1391
1392 case btShort:
1393 tp = init_type (TYPE_CODE_INT, 2, 0,
1394 "short", objfile);
1395 break;
1396
1397 case btUShort:
1398 tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
1399 "unsigned short", objfile);
1400 break;
1401
1402 case btInt:
1403 tp = init_type (TYPE_CODE_INT, 4, 0,
1404 "int", objfile);
1405 break;
1406
1407 case btUInt:
1408 tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1409 "unsigned int", objfile);
1410 break;
1411
1412 case btLong:
1413 tp = init_type (TYPE_CODE_INT, 4, 0,
1414 "long", objfile);
1415 break;
1416
1417 case btULong:
1418 tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1419 "unsigned long", objfile);
1420 break;
1421
1422 case btFloat:
1423 tp = init_type (TYPE_CODE_FLT,
1424 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1425 "float", objfile);
1426 break;
1427
1428 case btDouble:
1429 tp = init_type (TYPE_CODE_FLT,
1430 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1431 "double", objfile);
1432 break;
1433
1434 case btComplex:
1435 tp = init_type (TYPE_CODE_COMPLEX,
1436 2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1437 "complex", objfile);
1438 TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile);
1439 break;
1440
1441 case btDComplex:
1442 tp = init_type (TYPE_CODE_COMPLEX,
1443 2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1444 "double complex", objfile);
1445 TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile);
1446 break;
1447
1448 case btFixedDec:
1449 /* We use TYPE_CODE_INT to print these as integers. Does this do any
1450 good? Would we be better off with TYPE_CODE_ERROR? Should
1451 TYPE_CODE_ERROR print things in hex if it knows the size? */
1452 tp = init_type (TYPE_CODE_INT,
1453 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1454 "fixed decimal", objfile);
1455 break;
1456
1457 case btFloatDec:
1458 tp = init_type (TYPE_CODE_ERROR,
1459 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1460 "floating decimal", objfile);
1461 break;
1462
1463 case btString:
1464 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
1465 FIXME. */
1466 tp = init_type (TYPE_CODE_STRING, 1, 0,
1467 "string", objfile);
1468 break;
1469
1470 case btVoid:
1471 tp = objfile_type (objfile)->builtin_void;
1472 break;
1473
1474 case btLong64:
1475 tp = init_type (TYPE_CODE_INT, 8, 0,
1476 "long", objfile);
1477 break;
1478
1479 case btULong64:
1480 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1481 "unsigned long", objfile);
1482 break;
1483
1484 case btLongLong64:
1485 tp = init_type (TYPE_CODE_INT, 8, 0,
1486 "long long", objfile);
1487 break;
1488
1489 case btULongLong64:
1490 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1491 "unsigned long long", objfile);
1492 break;
1493
1494 case btAdr64:
1495 tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED,
1496 "adr_64", objfile);
1497 TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
1498 break;
1499
1500 case btInt64:
1501 tp = init_type (TYPE_CODE_INT, 8, 0,
1502 "int", objfile);
1503 break;
1504
1505 case btUInt64:
1506 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1507 "unsigned int", objfile);
1508 break;
1509
1510 default:
1511 tp = NULL;
1512 break;
1513 }
1514
1515 map_bt[bt] = tp;
1516 return tp;
1517}
1518
1519/* Parse the type information provided in the raw AX entries for
c50c785c 1520 the symbol SH. Return the bitfield size in BS, in case.
5796c8dc
SS
1521 We must byte-swap the AX entries before we use them; BIGEND says whether
1522 they are big-endian or little-endian (from fh->fBigendian). */
1523
1524static struct type *
1525parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
1526 int bigend, char *sym_name)
1527{
1528 TIR t[1];
1529 struct type *tp = 0;
1530 enum type_code type_code = TYPE_CODE_UNDEF;
1531
c50c785c 1532 /* Handle undefined types, they have indexNil. */
5796c8dc 1533 if (aux_index == indexNil)
a45ae5f8 1534 return basic_type (btInt, mdebugread_objfile);
5796c8dc
SS
1535
1536 /* Handle corrupt aux indices. */
1537 if (aux_index >= (debug_info->fdr + fd)->caux)
1538 {
1539 index_complaint (sym_name);
a45ae5f8 1540 return basic_type (btInt, mdebugread_objfile);
5796c8dc
SS
1541 }
1542 ax += aux_index;
1543
1544 /* Use aux as a type information record, map its basic type. */
1545 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
a45ae5f8 1546 tp = basic_type (t->bt, mdebugread_objfile);
5796c8dc
SS
1547 if (tp == NULL)
1548 {
c50c785c 1549 /* Cannot use builtin types -- build our own. */
5796c8dc
SS
1550 switch (t->bt)
1551 {
1552 case btStruct:
1553 type_code = TYPE_CODE_STRUCT;
1554 break;
1555 case btUnion:
1556 type_code = TYPE_CODE_UNION;
1557 break;
1558 case btEnum:
1559 type_code = TYPE_CODE_ENUM;
1560 break;
1561 case btRange:
1562 type_code = TYPE_CODE_RANGE;
1563 break;
1564 case btSet:
1565 type_code = TYPE_CODE_SET;
1566 break;
1567 case btIndirect:
c50c785c 1568 /* alpha cc -migrate uses this for typedefs. The true type will
5796c8dc
SS
1569 be obtained by crossreferencing below. */
1570 type_code = TYPE_CODE_ERROR;
1571 break;
1572 case btTypedef:
c50c785c 1573 /* alpha cc uses this for typedefs. The true type will be
5796c8dc
SS
1574 obtained by crossreferencing below. */
1575 type_code = TYPE_CODE_ERROR;
1576 break;
1577 default:
1578 basic_type_complaint (t->bt, sym_name);
a45ae5f8 1579 return basic_type (btInt, mdebugread_objfile);
5796c8dc
SS
1580 }
1581 }
1582
c50c785c 1583 /* Move on to next aux. */
5796c8dc
SS
1584 ax++;
1585
1586 if (t->fBitfield)
1587 {
1588 int width = AUX_GET_WIDTH (bigend, ax);
cf7f2e2d 1589
5796c8dc
SS
1590 /* Inhibit core dumps if TIR is corrupted. */
1591 if (bs == (int *) NULL)
1592 {
1593 /* Alpha cc -migrate encodes char and unsigned char types
1594 as short and unsigned short types with a field width of 8.
1595 Enum types also have a field width which we ignore for now. */
1596 if (t->bt == btShort && width == 8)
a45ae5f8 1597 tp = basic_type (btChar, mdebugread_objfile);
5796c8dc 1598 else if (t->bt == btUShort && width == 8)
a45ae5f8 1599 tp = basic_type (btUChar, mdebugread_objfile);
5796c8dc
SS
1600 else if (t->bt == btEnum)
1601 ;
1602 else
c50c785c
JM
1603 complaint (&symfile_complaints,
1604 _("can't handle TIR fBitfield for %s"),
5796c8dc
SS
1605 sym_name);
1606 }
1607 else
1608 *bs = width;
1609 ax++;
1610 }
1611
1612 /* A btIndirect entry cross references to an aux entry containing
1613 the type. */
1614 if (t->bt == btIndirect)
1615 {
1616 RNDXR rn[1];
1617 int rf;
1618 FDR *xref_fh;
1619 int xref_fd;
1620
1621 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
1622 ax++;
1623 if (rn->rfd == 0xfff)
1624 {
1625 rf = AUX_GET_ISYM (bigend, ax);
1626 ax++;
1627 }
1628 else
1629 rf = rn->rfd;
1630
1631 if (rf == -1)
1632 {
1633 complaint (&symfile_complaints,
1634 _("unable to cross ref btIndirect for %s"), sym_name);
a45ae5f8 1635 return basic_type (btInt, mdebugread_objfile);
5796c8dc
SS
1636 }
1637 xref_fh = get_rfd (fd, rf);
1638 xref_fd = xref_fh - debug_info->fdr;
1639 tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase,
1640 rn->index, (int *) NULL, xref_fh->fBigendian, sym_name);
1641 }
1642
1643 /* All these types really point to some (common) MIPS type
1644 definition, and only the type-qualifiers fully identify
c50c785c 1645 them. We'll make the same effort at sharing. */
5796c8dc
SS
1646 if (t->bt == btStruct ||
1647 t->bt == btUnion ||
1648 t->bt == btEnum ||
1649
1650 /* btSet (I think) implies that the name is a tag name, not a typedef
1651 name. This apparently is a MIPS extension for C sets. */
1652 t->bt == btSet)
1653 {
1654 char *name;
1655
1656 /* Try to cross reference this type, build new type on failure. */
1657 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1658 if (tp == (struct type *) NULL)
a45ae5f8 1659 tp = init_type (type_code, 0, 0, (char *) NULL, mdebugread_objfile);
5796c8dc
SS
1660
1661 /* DEC c89 produces cross references to qualified aggregate types,
1662 dereference them. */
1663 while (TYPE_CODE (tp) == TYPE_CODE_PTR
1664 || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
1665 tp = TYPE_TARGET_TYPE (tp);
1666
1667 /* Make sure that TYPE_CODE(tp) has an expected type code.
1668 Any type may be returned from cross_ref if file indirect entries
1669 are corrupted. */
1670 if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
1671 && TYPE_CODE (tp) != TYPE_CODE_UNION
1672 && TYPE_CODE (tp) != TYPE_CODE_ENUM)
1673 {
1674 unexpected_type_code_complaint (sym_name);
1675 }
1676 else
1677 {
5796c8dc
SS
1678 /* Usually, TYPE_CODE(tp) is already type_code. The main
1679 exception is if we guessed wrong re struct/union/enum.
1680 But for struct vs. union a wrong guess is harmless, so
1681 don't complain(). */
1682 if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
1683 && type_code != TYPE_CODE_ENUM)
1684 || (TYPE_CODE (tp) != TYPE_CODE_ENUM
1685 && type_code == TYPE_CODE_ENUM))
1686 {
1687 bad_tag_guess_complaint (sym_name);
1688 }
1689
1690 if (TYPE_CODE (tp) != type_code)
1691 {
1692 TYPE_CODE (tp) = type_code;
1693 }
1694
1695 /* Do not set the tag name if it is a compiler generated tag name
1696 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
1697 if (name[0] == '.' || name[0] == '\0')
1698 TYPE_TAG_NAME (tp) = NULL;
1699 else if (TYPE_TAG_NAME (tp) == NULL
1700 || strcmp (TYPE_TAG_NAME (tp), name) != 0)
c50c785c 1701 TYPE_TAG_NAME (tp)
ef5ccd6c
JM
1702 = obstack_copy0 (&mdebugread_objfile->objfile_obstack,
1703 name, strlen (name));
5796c8dc
SS
1704 }
1705 }
1706
1707 /* All these types really point to some (common) MIPS type
1708 definition, and only the type-qualifiers fully identify
1709 them. We'll make the same effort at sharing.
1710 FIXME: We are not doing any guessing on range types. */
1711 if (t->bt == btRange)
1712 {
1713 char *name;
1714
1715 /* Try to cross reference this type, build new type on failure. */
1716 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1717 if (tp == (struct type *) NULL)
a45ae5f8 1718 tp = init_type (type_code, 0, 0, (char *) NULL, mdebugread_objfile);
5796c8dc
SS
1719
1720 /* Make sure that TYPE_CODE(tp) has an expected type code.
1721 Any type may be returned from cross_ref if file indirect entries
1722 are corrupted. */
1723 if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
1724 {
1725 unexpected_type_code_complaint (sym_name);
1726 }
1727 else
1728 {
1729 /* Usually, TYPE_CODE(tp) is already type_code. The main
c50c785c 1730 exception is if we guessed wrong re struct/union/enum. */
5796c8dc
SS
1731 if (TYPE_CODE (tp) != type_code)
1732 {
1733 bad_tag_guess_complaint (sym_name);
1734 TYPE_CODE (tp) = type_code;
1735 }
1736 if (TYPE_NAME (tp) == NULL
1737 || strcmp (TYPE_NAME (tp), name) != 0)
ef5ccd6c
JM
1738 TYPE_NAME (tp)
1739 = obstack_copy0 (&mdebugread_objfile->objfile_obstack,
1740 name, strlen (name));
5796c8dc
SS
1741 }
1742 }
1743 if (t->bt == btTypedef)
1744 {
1745 char *name;
1746
1747 /* Try to cross reference this type, it should succeed. */
1748 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1749 if (tp == (struct type *) NULL)
1750 {
1751 complaint (&symfile_complaints,
1752 _("unable to cross ref btTypedef for %s"), sym_name);
a45ae5f8 1753 tp = basic_type (btInt, mdebugread_objfile);
5796c8dc
SS
1754 }
1755 }
1756
c50c785c 1757 /* Deal with range types. */
5796c8dc
SS
1758 if (t->bt == btRange)
1759 {
cf7f2e2d
JM
1760 TYPE_NFIELDS (tp) = 0;
1761 TYPE_RANGE_DATA (tp) = ((struct range_bounds *)
1762 TYPE_ZALLOC (tp, sizeof (struct range_bounds)));
5796c8dc
SS
1763 TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
1764 ax++;
5796c8dc
SS
1765 TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
1766 ax++;
1767 }
1768
c50c785c
JM
1769 /* Parse all the type qualifiers now. If there are more
1770 than 6 the game will continue in the next aux. */
5796c8dc
SS
1771
1772 while (1)
1773 {
1774#define PARSE_TQ(tq) \
1775 if (t->tq != tqNil) \
1776 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1777 else \
1778 break;
1779
1780 PARSE_TQ (tq0);
1781 PARSE_TQ (tq1);
1782 PARSE_TQ (tq2);
1783 PARSE_TQ (tq3);
1784 PARSE_TQ (tq4);
1785 PARSE_TQ (tq5);
1786#undef PARSE_TQ
1787
1788 /* mips cc 2.x and gcc never put out continued aux entries. */
1789 if (!t->continued)
1790 break;
1791
1792 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1793 ax++;
1794 }
1795
1796 /* Complain for illegal continuations due to corrupt aux entries. */
1797 if (t->continued)
c50c785c
JM
1798 complaint (&symfile_complaints,
1799 _("illegal TIR continued for %s"), sym_name);
5796c8dc
SS
1800
1801 return tp;
1802}
1803
1804/* Make up a complex type from a basic one. Type is passed by
c50c785c 1805 reference in TPP and side-effected as necessary. The type
5796c8dc
SS
1806 qualifier TQ says how to handle the aux symbols at AX for
1807 the symbol SX we are currently analyzing. BIGEND says whether
1808 aux symbols are big-endian or little-endian.
c50c785c 1809 Returns the number of aux symbols we parsed. */
5796c8dc
SS
1810
1811static int
1812upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
1813 char *sym_name)
1814{
1815 int off;
1816 struct type *t;
1817
c50c785c 1818 /* Used in array processing. */
5796c8dc
SS
1819 int rf, id;
1820 FDR *fh;
1821 struct type *range;
1822 struct type *indx;
1823 int lower, upper;
1824 RNDXR rndx;
1825
1826 switch (tq)
1827 {
1828 case tqPtr:
1829 t = lookup_pointer_type (*tpp);
1830 *tpp = t;
1831 return 0;
1832
1833 case tqProc:
1834 t = lookup_function_type (*tpp);
1835 *tpp = t;
1836 return 0;
1837
1838 case tqArray:
1839 off = 0;
1840
c50c785c 1841 /* Determine and record the domain type (type of index). */
5796c8dc
SS
1842 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx);
1843 id = rndx.index;
1844 rf = rndx.rfd;
1845 if (rf == 0xfff)
1846 {
1847 ax++;
1848 rf = AUX_GET_ISYM (bigend, ax);
1849 off++;
1850 }
1851 fh = get_rfd (fd, rf);
1852
1853 indx = parse_type (fh - debug_info->fdr,
1854 debug_info->external_aux + fh->iauxBase,
1855 id, (int *) NULL, bigend, sym_name);
1856
1857 /* The bounds type should be an integer type, but might be anything
1858 else due to corrupt aux entries. */
1859 if (TYPE_CODE (indx) != TYPE_CODE_INT)
1860 {
1861 complaint (&symfile_complaints,
c50c785c
JM
1862 _("illegal array index type for %s, assuming int"),
1863 sym_name);
a45ae5f8 1864 indx = objfile_type (mdebugread_objfile)->builtin_int;
5796c8dc
SS
1865 }
1866
1867 /* Get the bounds, and create the array type. */
1868 ax++;
1869 lower = AUX_GET_DNLOW (bigend, ax);
1870 ax++;
1871 upper = AUX_GET_DNHIGH (bigend, ax);
1872 ax++;
1873 rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */
1874
1875 range = create_range_type ((struct type *) NULL, indx,
1876 lower, upper);
1877
1878 t = create_array_type ((struct type *) NULL, *tpp, range);
1879
1880 /* We used to fill in the supplied array element bitsize
1881 here if the TYPE_LENGTH of the target type was zero.
1882 This happens for a `pointer to an array of anonymous structs',
1883 but in this case the array element bitsize is also zero,
1884 so nothing is gained.
1885 And we used to check the TYPE_LENGTH of the target type against
1886 the supplied array element bitsize.
1887 gcc causes a mismatch for `pointer to array of object',
1888 since the sdb directives it uses do not have a way of
1889 specifying the bitsize, but it does no harm (the
1890 TYPE_LENGTH should be correct) and we should be able to
1891 ignore the erroneous bitsize from the auxiliary entry safely.
1892 dbx seems to ignore it too. */
1893
1894 /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */
1895 if (TYPE_LENGTH (*tpp) == 0)
1896 TYPE_TARGET_STUB (t) = 1;
1897
1898 *tpp = t;
1899 return 4 + off;
1900
1901 case tqVol:
1902 /* Volatile -- currently ignored */
1903 return 0;
1904
1905 case tqConst:
1906 /* Const -- currently ignored */
1907 return 0;
1908
1909 default:
1910 complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
1911 return 0;
1912 }
1913}
1914
1915
1916/* Parse a procedure descriptor record PR. Note that the procedure is
1917 parsed _after_ the local symbols, now we just insert the extra
1918 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1919 already been placed in the procedure's main block. Note also that
1920 images that have been partially stripped (ld -x) have been deprived
1921 of local symbols, and we have to cope with them here. FIRST_OFF is
1922 the offset of the first procedure for this FDR; we adjust the
1923 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
1924 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1925 in question, or NULL to use top_stack->cur_block. */
1926
1927static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *);
1928
1929static void
1930parse_procedure (PDR *pr, struct symtab *search_symtab,
1931 struct partial_symtab *pst)
1932{
1933 struct symbol *s, *i;
1934 struct block *b;
1935 char *sh_name;
1936
c50c785c 1937 /* Simple rule to find files linked "-x". */
5796c8dc
SS
1938 if (cur_fdr->rss == -1)
1939 {
1940 if (pr->isym == -1)
1941 {
c50c785c 1942 /* Static procedure at address pr->adr. Sigh. */
5796c8dc
SS
1943 /* FIXME-32x64. assuming pr->adr fits in long. */
1944 complaint (&symfile_complaints,
1945 _("can't handle PDR for static proc at 0x%lx"),
1946 (unsigned long) pr->adr);
1947 return;
1948 }
1949 else
1950 {
1951 /* external */
1952 EXTR she;
1953
1954 (*debug_swap->swap_ext_in) (cur_bfd,
1955 ((char *) debug_info->external_ext
1956 + (pr->isym
1957 * debug_swap->external_ext_size)),
1958 &she);
1959 sh_name = debug_info->ssext + she.asym.iss;
1960 }
1961 }
1962 else
1963 {
1964 /* Full symbols */
1965 SYMR sh;
1966
1967 (*debug_swap->swap_sym_in) (cur_bfd,
1968 ((char *) debug_info->external_sym
1969 + ((cur_fdr->isymBase + pr->isym)
1970 * debug_swap->external_sym_size)),
1971 &sh);
1972 sh_name = debug_info->ss + cur_fdr->issBase + sh.iss;
1973 }
1974
1975 if (search_symtab != NULL)
1976 {
1977#if 0
1978 /* This loses both in the case mentioned (want a static, find a global),
1979 but also if we are looking up a non-mangled name which happens to
1980 match the name of a mangled function. */
1981 /* We have to save the cur_fdr across the call to lookup_symbol.
1982 If the pdr is for a static function and if a global function with
1983 the same name exists, lookup_symbol will eventually read in the symtab
1984 for the global function and clobber cur_fdr. */
1985 FDR *save_cur_fdr = cur_fdr;
cf7f2e2d 1986
5796c8dc
SS
1987 s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
1988 cur_fdr = save_cur_fdr;
1989#else
1990 s = mylookup_symbol
1991 (sh_name,
1992 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
1993 VAR_DOMAIN,
1994 LOC_BLOCK);
1995#endif
1996 }
1997 else
1998 s = mylookup_symbol (sh_name, top_stack->cur_block,
1999 VAR_DOMAIN, LOC_BLOCK);
2000
2001 if (s != 0)
2002 {
2003 b = SYMBOL_BLOCK_VALUE (s);
2004 }
2005 else
2006 {
2007 complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
2008#if 1
2009 return;
2010#else
2011/* FIXME -- delete. We can't do symbol allocation now; it's all done. */
2012 s = new_symbol (sh_name);
2013 SYMBOL_DOMAIN (s) = VAR_DOMAIN;
2014 SYMBOL_CLASS (s) = LOC_BLOCK;
c50c785c 2015 /* Donno its type, hope int is ok. */
5796c8dc
SS
2016 SYMBOL_TYPE (s)
2017 = lookup_function_type (objfile_type (pst->objfile)->builtin_int);
2018 add_symbol (s, top_stack->cur_st, top_stack->cur_block);
c50c785c 2019 /* Won't have symbols for this one. */
5796c8dc
SS
2020 b = new_block (2);
2021 SYMBOL_BLOCK_VALUE (s) = b;
2022 BLOCK_FUNCTION (b) = s;
2023 BLOCK_START (b) = pr->adr;
2024 /* BOUND used to be the end of procedure's text, but the
2025 argument is no longer passed in. */
2026 BLOCK_END (b) = bound;
2027 BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
2028 add_block (b, top_stack->cur_st);
2029#endif
2030 }
2031
2032 i = mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST);
2033
2034 if (i)
2035 {
2036 struct mdebug_extra_func_info *e;
2037
2038 e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i);
2039 e->pdr = *pr;
2040
2041 /* GDB expects the absolute function start address for the
2042 procedure descriptor in e->pdr.adr.
2043 As the address in the procedure descriptor is usually relative,
2044 we would have to relocate e->pdr.adr with cur_fdr->adr and
2045 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
2046 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2047 in shared libraries on some systems, and on other systems
2048 e->pdr.adr is sometimes offset by a bogus value.
2049 To work around these problems, we replace e->pdr.adr with
2050 the start address of the function. */
2051 e->pdr.adr = BLOCK_START (b);
2052 }
2053
2054 /* It would be reasonable that functions that have been compiled
2055 without debugging info have a btNil type for their return value,
2056 and functions that are void and are compiled with debugging info
2057 have btVoid.
2058 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2059 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2060 case right.
2061 The glevel field in cur_fdr could be used to determine the presence
2062 of debugging info, but GCC doesn't always pass the -g switch settings
2063 to the assembler and GAS doesn't set the glevel field from the -g switch
2064 settings.
2065 To work around these problems, the return value type of a TYPE_CODE_VOID
2066 function is adjusted accordingly if no debugging info was found in the
2067 compilation unit. */
2068
2069 if (processing_gcc_compilation == 0
2070 && found_ecoff_debugging_info == 0
2071 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
ef5ccd6c 2072 SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->nodebug_text_symbol;
5796c8dc
SS
2073}
2074
c50c785c 2075/* Parse the external symbol ES. Just call parse_symbol() after
5796c8dc
SS
2076 making sure we know where the aux are for it.
2077 BIGEND says whether aux entries are big-endian or little-endian.
2078
c50c785c 2079 This routine clobbers top_stack->cur_block and ->cur_st. */
5796c8dc
SS
2080
2081static void parse_external (EXTR *, int, struct section_offsets *,
2082 struct objfile *);
2083
2084static void
2085parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
2086 struct objfile *objfile)
2087{
2088 union aux_ext *ax;
2089
2090 if (es->ifd != ifdNil)
2091 {
2092 cur_fd = es->ifd;
2093 cur_fdr = debug_info->fdr + cur_fd;
2094 ax = debug_info->external_aux + cur_fdr->iauxBase;
2095 }
2096 else
2097 {
2098 cur_fdr = debug_info->fdr;
2099 ax = 0;
2100 }
2101
2102 /* Reading .o files */
2103 if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil)
2104 {
2105 char *what;
2106 switch (es->asym.st)
2107 {
2108 case stNil:
2109 /* These are generated for static symbols in .o files,
2110 ignore them. */
2111 return;
2112 case stStaticProc:
2113 case stProc:
2114 what = "procedure";
2115 n_undef_procs++;
2116 break;
2117 case stGlobal:
2118 what = "variable";
2119 n_undef_vars++;
2120 break;
2121 case stLabel:
2122 what = "label";
2123 n_undef_labels++;
2124 break;
2125 default:
2126 what = "symbol";
2127 break;
2128 }
2129 n_undef_symbols++;
c50c785c 2130 /* FIXME: Turn this into a complaint? */
5796c8dc
SS
2131 if (info_verbose)
2132 printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
2133 what, debug_info->ssext + es->asym.iss,
2134 fdr_name (cur_fdr));
2135 return;
2136 }
2137
2138 switch (es->asym.st)
2139 {
2140 case stProc:
2141 case stStaticProc:
2142 /* There is no need to parse the external procedure symbols.
2143 If they are from objects compiled without -g, their index will
2144 be indexNil, and the symbol definition from the minimal symbol
2145 is preferrable (yielding a function returning int instead of int).
2146 If the index points to a local procedure symbol, the local
2147 symbol already provides the correct type.
2148 Note that the index of the external procedure symbol points
2149 to the local procedure symbol in the local symbol table, and
2150 _not_ to the auxiliary symbol info. */
2151 break;
2152 case stGlobal:
2153 case stLabel:
2154 /* Global common symbols are resolved by the runtime loader,
2155 ignore them. */
2156 if (SC_IS_COMMON (es->asym.sc))
2157 break;
2158
2159 /* Note that the case of a symbol with indexNil must be handled
2160 anyways by parse_symbol(). */
c50c785c
JM
2161 parse_symbol (&es->asym, ax, (char *) NULL,
2162 bigend, section_offsets, objfile);
5796c8dc
SS
2163 break;
2164 default:
2165 break;
2166 }
2167}
2168
2169/* Parse the line number info for file descriptor FH into
2170 GDB's linetable LT. MIPS' encoding requires a little bit
2171 of magic to get things out. Note also that MIPS' line
2172 numbers can go back and forth, apparently we can live
c50c785c 2173 with that and do not need to reorder our linetables. */
5796c8dc
SS
2174
2175static void parse_lines (FDR *, PDR *, struct linetable *, int,
2176 struct partial_symtab *, CORE_ADDR);
2177
2178static void
2179parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
2180 struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr)
2181{
2182 unsigned char *base;
2183 int j, k;
2184 int delta, count, lineno = 0;
2185
2186 if (fh->cbLine == 0)
2187 return;
2188
c50c785c 2189 /* Scan by procedure descriptors. */
5796c8dc
SS
2190 k = 0;
2191 for (j = 0; j < fh->cpd; j++, pr++)
2192 {
2193 CORE_ADDR l;
2194 CORE_ADDR adr;
2195 unsigned char *halt;
2196
c50c785c 2197 /* No code for this one. */
5796c8dc
SS
2198 if (pr->iline == ilineNil ||
2199 pr->lnLow == -1 || pr->lnHigh == -1)
2200 continue;
2201
2202 /* Determine start and end address of compressed line bytes for
2203 this procedure. */
2204 base = debug_info->line + fh->cbLineOffset;
2205 if (j != (fh->cpd - 1))
2206 halt = base + pr[1].cbLineOffset;
2207 else
2208 halt = base + fh->cbLine;
2209 base += pr->cbLineOffset;
2210
2211 adr = pst->textlow + pr->adr - lowest_pdr_addr;
2212
2213 l = adr >> 2; /* in words */
2214 for (lineno = pr->lnLow; base < halt;)
2215 {
2216 count = *base & 0x0f;
2217 delta = *base++ >> 4;
2218 if (delta >= 8)
2219 delta -= 16;
2220 if (delta == -8)
2221 {
2222 delta = (base[0] << 8) | base[1];
2223 if (delta >= 0x8000)
2224 delta -= 0x10000;
2225 base += 2;
2226 }
2227 lineno += delta; /* first delta is 0 */
2228
c50c785c 2229 /* Complain if the line table overflows. Could happen
5796c8dc
SS
2230 with corrupt binaries. */
2231 if (lt->nitems >= maxlines)
2232 {
2233 complaint (&symfile_complaints,
2234 _("guessed size of linetable for %s incorrectly"),
2235 fdr_name (fh));
2236 break;
2237 }
2238 k = add_line (lt, lineno, l, k);
2239 l += count + 1;
2240 }
2241 }
2242}
2243\f
2244static void
2245function_outside_compilation_unit_complaint (const char *arg1)
2246{
2247 complaint (&symfile_complaints,
c50c785c
JM
2248 _("function `%s' appears to be defined "
2249 "outside of all compilation units"),
5796c8dc
SS
2250 arg1);
2251}
2252
2253/* Use the STORAGE_CLASS to compute which section the given symbol
2254 belongs to, and then records this new minimal symbol. */
2255
2256static void
2257record_minimal_symbol (const char *name, const CORE_ADDR address,
2258 enum minimal_symbol_type ms_type, int storage_class,
2259 struct objfile *objfile)
2260{
2261 int section;
2262 asection *bfd_section;
2263
2264 switch (storage_class)
2265 {
2266 case scText:
2267 section = SECT_OFF_TEXT (objfile);
2268 bfd_section = bfd_get_section_by_name (cur_bfd, ".text");
2269 break;
2270 case scData:
2271 section = SECT_OFF_DATA (objfile);
2272 bfd_section = bfd_get_section_by_name (cur_bfd, ".data");
2273 break;
2274 case scBss:
2275 section = SECT_OFF_BSS (objfile);
2276 bfd_section = bfd_get_section_by_name (cur_bfd, ".bss");
2277 break;
2278 case scSData:
2279 section = get_section_index (objfile, ".sdata");
2280 bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata");
2281 break;
2282 case scSBss:
2283 section = get_section_index (objfile, ".sbss");
2284 bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss");
2285 break;
2286 case scRData:
2287 section = get_section_index (objfile, ".rdata");
2288 bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata");
2289 break;
2290 case scInit:
2291 section = get_section_index (objfile, ".init");
2292 bfd_section = bfd_get_section_by_name (cur_bfd, ".init");
2293 break;
2294 case scXData:
2295 section = get_section_index (objfile, ".xdata");
2296 bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata");
2297 break;
2298 case scPData:
2299 section = get_section_index (objfile, ".pdata");
2300 bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata");
2301 break;
2302 case scFini:
2303 section = get_section_index (objfile, ".fini");
2304 bfd_section = bfd_get_section_by_name (cur_bfd, ".fini");
2305 break;
2306 case scRConst:
2307 section = get_section_index (objfile, ".rconst");
2308 bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst");
2309 break;
2310#ifdef scTlsData
2311 case scTlsData:
2312 section = get_section_index (objfile, ".tlsdata");
2313 bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata");
2314 break;
2315#endif
2316#ifdef scTlsBss
2317 case scTlsBss:
2318 section = get_section_index (objfile, ".tlsbss");
2319 bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss");
2320 break;
2321#endif
2322 default:
2323 /* This kind of symbol is not associated to a section. */
2324 section = -1;
2325 bfd_section = NULL;
2326 }
2327
2328 prim_record_minimal_symbol_and_info (name, address, ms_type,
2329 section, bfd_section, objfile);
2330}
2331
2332/* Master parsing procedure for first-pass reading of file symbols
2333 into a partial_symtab. */
2334
2335static void
2336parse_partial_symbols (struct objfile *objfile)
2337{
2338 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2339 const bfd_size_type external_sym_size = debug_swap->external_sym_size;
2340 const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
2341 const bfd_size_type external_ext_size = debug_swap->external_ext_size;
2342 void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in;
2343 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
2344 void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in;
2345 int f_idx, s_idx;
2346 HDRR *hdr = &debug_info->symbolic_header;
2347 /* Running pointers */
2348 FDR *fh;
2349 char *ext_out;
2350 char *ext_out_end;
2351 EXTR *ext_block;
2352 EXTR *ext_in;
2353 EXTR *ext_in_end;
2354 SYMR sh;
2355 struct partial_symtab *pst;
2356 int textlow_not_set = 1;
2357 int past_first_source_file = 0;
2358
c50c785c 2359 /* List of current psymtab's include files. */
ef5ccd6c 2360 const char **psymtab_include_list;
5796c8dc
SS
2361 int includes_allocated;
2362 int includes_used;
2363 EXTR *extern_tab;
2364 struct pst_map *fdr_to_pst;
c50c785c 2365 /* Index within current psymtab dependency list. */
5796c8dc
SS
2366 struct partial_symtab **dependency_list;
2367 int dependencies_used, dependencies_allocated;
2368 struct cleanup *old_chain;
2369 char *name;
2370 enum language prev_language;
2371 asection *text_sect;
2372 int relocatable = 0;
2373
2374 /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2375 the shared libraries are prelinked at a high memory address.
2376 We have to adjust the start address of the object file for this case,
2377 by setting it to the start address of the first procedure in the file.
2378 But we should do no adjustments if we are debugging a .o file, where
2379 the text section (and fh->adr) really starts at zero. */
2380 text_sect = bfd_get_section_by_name (cur_bfd, ".text");
2381 if (text_sect != NULL
2382 && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
2383 relocatable = 1;
2384
2385 extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack,
2386 sizeof (EXTR) * hdr->iextMax);
2387
2388 includes_allocated = 30;
2389 includes_used = 0;
ef5ccd6c
JM
2390 psymtab_include_list = (const char **) alloca (includes_allocated *
2391 sizeof (const char *));
5796c8dc
SS
2392 next_symbol_text_func = mdebug_next_symbol_text;
2393
2394 dependencies_allocated = 30;
2395 dependencies_used = 0;
2396 dependency_list =
2397 (struct partial_symtab **) alloca (dependencies_allocated *
2398 sizeof (struct partial_symtab *));
2399
ef5ccd6c 2400 set_last_source_file (NULL);
5796c8dc
SS
2401
2402 /*
2403 * Big plan:
2404 *
2405 * Only parse the Local and External symbols, and the Relative FDR.
2406 * Fixup enough of the loader symtab to be able to use it.
2407 * Allocate space only for the file's portions we need to
c50c785c 2408 * look at. (XXX)
5796c8dc
SS
2409 */
2410
2411 max_gdbinfo = 0;
2412 max_glevel = MIN_GLEVEL;
2413
2414 /* Allocate the map FDR -> PST.
2415 Minor hack: -O3 images might claim some global data belongs
c50c785c
JM
2416 to FDR -1. We`ll go along with that. */
2417 fdr_to_pst = (struct pst_map *)
2418 xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
5796c8dc
SS
2419 old_chain = make_cleanup (xfree, fdr_to_pst);
2420 fdr_to_pst++;
2421 {
2422 struct partial_symtab *pst = new_psymtab ("", objfile);
cf7f2e2d 2423
5796c8dc
SS
2424 fdr_to_pst[-1].pst = pst;
2425 FDR_IDX (pst) = -1;
2426 }
2427
2428 /* Allocate the global pending list. */
2429 pending_list =
2430 ((struct mdebug_pending **)
2431 obstack_alloc (&objfile->objfile_obstack,
2432 hdr->ifdMax * sizeof (struct mdebug_pending *)));
2433 memset (pending_list, 0,
2434 hdr->ifdMax * sizeof (struct mdebug_pending *));
2435
2436 /* Pass 0 over external syms: swap them in. */
2437 ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
2438 make_cleanup (xfree, ext_block);
2439
2440 ext_out = (char *) debug_info->external_ext;
2441 ext_out_end = ext_out + hdr->iextMax * external_ext_size;
2442 ext_in = ext_block;
2443 for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
2444 (*swap_ext_in) (cur_bfd, ext_out, ext_in);
2445
c50c785c 2446 /* Pass 1 over external syms: Presize and partition the list. */
5796c8dc
SS
2447 ext_in = ext_block;
2448 ext_in_end = ext_in + hdr->iextMax;
2449 for (; ext_in < ext_in_end; ext_in++)
2450 {
2451 /* See calls to complain below. */
2452 if (ext_in->ifd >= -1
2453 && ext_in->ifd < hdr->ifdMax
2454 && ext_in->asym.iss >= 0
2455 && ext_in->asym.iss < hdr->issExtMax)
2456 fdr_to_pst[ext_in->ifd].n_globals++;
2457 }
2458
c50c785c 2459 /* Pass 1.5 over files: partition out global symbol space. */
5796c8dc
SS
2460 s_idx = 0;
2461 for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++)
2462 {
2463 fdr_to_pst[f_idx].globals_offset = s_idx;
2464 s_idx += fdr_to_pst[f_idx].n_globals;
2465 fdr_to_pst[f_idx].n_globals = 0;
2466 }
2467
2468 /* ECOFF in ELF:
2469
2470 For ECOFF in ELF, we skip the creation of the minimal symbols.
2471 The ECOFF symbols should be a subset of the Elf symbols, and the
2472 section information of the elf symbols will be more accurate.
2473 FIXME! What about Irix 5's native linker?
2474
2475 By default, Elf sections which don't exist in ECOFF
2476 get put in ECOFF's absolute section by the gnu linker.
2477 Since absolute sections don't get relocated, we
2478 end up calculating an address different from that of
2479 the symbol's minimal symbol (created earlier from the
c50c785c 2480 Elf symtab).
5796c8dc
SS
2481
2482 To fix this, either :
2483 1) don't create the duplicate symbol
2484 (assumes ECOFF symtab is a subset of the ELF symtab;
2485 assumes no side-effects result from ignoring ECOFF symbol)
2486 2) create it, only if lookup for existing symbol in ELF's minimal
2487 symbols fails
2488 (inefficient;
2489 assumes no side-effects result from ignoring ECOFF symbol)
2490 3) create it, but lookup ELF's minimal symbol and use it's section
2491 during relocation, then modify "uniqify" phase to merge and
2492 eliminate the duplicate symbol
2493 (highly inefficient)
2494
2495 I've implemented #1 here...
2496 Skip the creation of the minimal symbols based on the ECOFF
c50c785c 2497 symbol table. */
5796c8dc 2498
c50c785c 2499 /* Pass 2 over external syms: fill in external symbols. */
5796c8dc
SS
2500 ext_in = ext_block;
2501 ext_in_end = ext_in + hdr->iextMax;
2502 for (; ext_in < ext_in_end; ext_in++)
2503 {
2504 enum minimal_symbol_type ms_type = mst_text;
2505 CORE_ADDR svalue = ext_in->asym.value;
2506
2507 /* The Irix 5 native tools seem to sometimes generate bogus
2508 external symbols. */
2509 if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
2510 {
2511 complaint (&symfile_complaints,
c50c785c
JM
2512 _("bad ifd for external symbol: %d (max %ld)"),
2513 ext_in->ifd, hdr->ifdMax);
5796c8dc
SS
2514 continue;
2515 }
2516 if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
2517 {
2518 complaint (&symfile_complaints,
2519 _("bad iss for external symbol: %ld (max %ld)"),
2520 ext_in->asym.iss, hdr->issExtMax);
2521 continue;
2522 }
2523
2524 extern_tab[fdr_to_pst[ext_in->ifd].globals_offset
2525 + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in;
2526
2527
2528 if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil)
2529 continue;
2530
2531
c50c785c 2532 /* Pass 3 over files, over local syms: fill in static symbols. */
5796c8dc
SS
2533 name = debug_info->ssext + ext_in->asym.iss;
2534
c50c785c 2535 /* Process ECOFF Symbol Types and Storage Classes. */
5796c8dc
SS
2536 switch (ext_in->asym.st)
2537 {
2538 case stProc:
2539 /* Beginnning of Procedure */
c50c785c
JM
2540 svalue += ANOFFSET (objfile->section_offsets,
2541 SECT_OFF_TEXT (objfile));
5796c8dc
SS
2542 break;
2543 case stStaticProc:
2544 /* Load time only static procs */
2545 ms_type = mst_file_text;
c50c785c
JM
2546 svalue += ANOFFSET (objfile->section_offsets,
2547 SECT_OFF_TEXT (objfile));
5796c8dc
SS
2548 break;
2549 case stGlobal:
2550 /* External symbol */
2551 if (SC_IS_COMMON (ext_in->asym.sc))
2552 {
2553 /* The value of a common symbol is its size, not its address.
2554 Ignore it. */
2555 continue;
2556 }
2557 else if (SC_IS_DATA (ext_in->asym.sc))
2558 {
2559 ms_type = mst_data;
c50c785c
JM
2560 svalue += ANOFFSET (objfile->section_offsets,
2561 SECT_OFF_DATA (objfile));
5796c8dc
SS
2562 }
2563 else if (SC_IS_BSS (ext_in->asym.sc))
2564 {
2565 ms_type = mst_bss;
c50c785c
JM
2566 svalue += ANOFFSET (objfile->section_offsets,
2567 SECT_OFF_BSS (objfile));
5796c8dc
SS
2568 }
2569 else if (SC_IS_SBSS (ext_in->asym.sc))
2570 {
2571 ms_type = mst_bss;
2572 svalue += ANOFFSET (objfile->section_offsets,
2573 get_section_index (objfile, ".sbss"));
2574 }
2575 else
2576 ms_type = mst_abs;
2577 break;
2578 case stLabel:
2579 /* Label */
2580
2581 /* On certain platforms, some extra label symbols can be
c50c785c 2582 generated by the linker. One possible usage for this kind
5796c8dc 2583 of symbols is to represent the address of the begining of a
c50c785c 2584 given section. For instance, on Tru64 5.1, the address of
5796c8dc
SS
2585 the _ftext label is the start address of the .text section.
2586
2587 The storage class of these symbols is usually directly
c50c785c 2588 related to the section to which the symbol refers. For
5796c8dc
SS
2589 instance, on Tru64 5.1, the storage class for the _fdata
2590 label is scData, refering to the .data section.
2591
2592 It is actually possible that the section associated to the
c50c785c 2593 storage class of the label does not exist. On True64 5.1
5796c8dc
SS
2594 for instance, the libm.so shared library does not contain
2595 any .data section, although it contains a _fpdata label
c50c785c 2596 which storage class is scData... Since these symbols are
5796c8dc 2597 usually useless for the debugger user anyway, we just
c50c785c 2598 discard these symbols. */
5796c8dc
SS
2599
2600 if (SC_IS_TEXT (ext_in->asym.sc))
2601 {
2602 if (objfile->sect_index_text == -1)
2603 continue;
2604
2605 ms_type = mst_file_text;
c50c785c
JM
2606 svalue += ANOFFSET (objfile->section_offsets,
2607 SECT_OFF_TEXT (objfile));
5796c8dc
SS
2608 }
2609 else if (SC_IS_DATA (ext_in->asym.sc))
2610 {
2611 if (objfile->sect_index_data == -1)
2612 continue;
2613
2614 ms_type = mst_file_data;
c50c785c
JM
2615 svalue += ANOFFSET (objfile->section_offsets,
2616 SECT_OFF_DATA (objfile));
5796c8dc
SS
2617 }
2618 else if (SC_IS_BSS (ext_in->asym.sc))
2619 {
2620 if (objfile->sect_index_bss == -1)
2621 continue;
2622
2623 ms_type = mst_file_bss;
c50c785c
JM
2624 svalue += ANOFFSET (objfile->section_offsets,
2625 SECT_OFF_BSS (objfile));
5796c8dc
SS
2626 }
2627 else if (SC_IS_SBSS (ext_in->asym.sc))
2628 {
2629 const int sbss_sect_index = get_section_index (objfile, ".sbss");
2630
2631 if (sbss_sect_index == -1)
2632 continue;
2633
2634 ms_type = mst_file_bss;
2635 svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index);
2636 }
2637 else
2638 ms_type = mst_abs;
2639 break;
2640 case stLocal:
2641 case stNil:
2642 /* The alpha has the section start addresses in stLocal symbols
c50c785c 2643 whose name starts with a `.'. Skip those but complain for all
5796c8dc
SS
2644 other stLocal symbols.
2645 Irix6 puts the section start addresses in stNil symbols, skip
c50c785c 2646 those too. */
5796c8dc
SS
2647 if (name[0] == '.')
2648 continue;
2649 /* Fall through. */
2650 default:
2651 ms_type = mst_unknown;
2652 unknown_ext_complaint (name);
2653 }
2654 if (!ECOFF_IN_ELF (cur_bfd))
2655 record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc,
2656 objfile);
2657 }
2658
c50c785c 2659 /* Pass 3 over files, over local syms: fill in static symbols. */
5796c8dc
SS
2660 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
2661 {
2662 struct partial_symtab *save_pst;
2663 EXTR *ext_ptr;
2664 CORE_ADDR textlow;
2665
2666 cur_fdr = fh = debug_info->fdr + f_idx;
2667
2668 if (fh->csym == 0)
2669 {
2670 fdr_to_pst[f_idx].pst = NULL;
2671 continue;
2672 }
2673
2674 /* Determine the start address for this object file from the
2675 file header and relocate it, except for Irix 5.2 zero fh->adr. */
2676 if (fh->cpd)
2677 {
2678 textlow = fh->adr;
2679 if (relocatable || textlow != 0)
c50c785c
JM
2680 textlow += ANOFFSET (objfile->section_offsets,
2681 SECT_OFF_TEXT (objfile));
5796c8dc
SS
2682 }
2683 else
2684 textlow = 0;
2685 pst = start_psymtab_common (objfile, objfile->section_offsets,
2686 fdr_name (fh),
2687 textlow,
2688 objfile->global_psymbols.next,
2689 objfile->static_psymbols.next);
cf7f2e2d
JM
2690 pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
2691 sizeof (struct symloc));
5796c8dc
SS
2692 memset (pst->read_symtab_private, 0, sizeof (struct symloc));
2693
2694 save_pst = pst;
2695 FDR_IDX (pst) = f_idx;
2696 CUR_BFD (pst) = cur_bfd;
2697 DEBUG_SWAP (pst) = debug_swap;
2698 DEBUG_INFO (pst) = debug_info;
2699 PENDING_LIST (pst) = pending_list;
2700
c50c785c 2701 /* The way to turn this into a symtab is to call... */
ef5ccd6c 2702 pst->read_symtab = mdebug_read_symtab;
5796c8dc
SS
2703
2704 /* Set up language for the pst.
2705 The language from the FDR is used if it is unambigious (e.g. cfront
2706 with native cc and g++ will set the language to C).
2707 Otherwise we have to deduce the language from the filename.
2708 Native ecoff has every header file in a separate FDR, so
2709 deduce_language_from_filename will return language_unknown for
2710 a header file, which is not what we want.
2711 But the FDRs for the header files are after the FDR for the source
2712 file, so we can assign the language of the source file to the
c50c785c 2713 following header files. Then we save the language in the private
5796c8dc
SS
2714 pst data so that we can reuse it when building symtabs. */
2715 prev_language = psymtab_language;
2716
2717 switch (fh->lang)
2718 {
2719 case langCplusplusV2:
2720 psymtab_language = language_cplus;
2721 break;
2722 default:
2723 psymtab_language = deduce_language_from_filename (fdr_name (fh));
2724 break;
2725 }
2726 if (psymtab_language == language_unknown)
2727 psymtab_language = prev_language;
2728 PST_PRIVATE (pst)->pst_language = psymtab_language;
2729
2730 pst->texthigh = pst->textlow;
2731
2732 /* For stabs-in-ecoff files, the second symbol must be @stab.
2733 This symbol is emitted by mips-tfile to signal that the
2734 current object file uses encapsulated stabs instead of mips
2735 ecoff for local symbols. (It is the second symbol because
2736 the first symbol is the stFile used to signal the start of a
c50c785c 2737 file). */
5796c8dc
SS
2738 processing_gcc_compilation = 0;
2739 if (fh->csym >= 2)
2740 {
2741 (*swap_sym_in) (cur_bfd,
2742 ((char *) debug_info->external_sym
2743 + (fh->isymBase + 1) * external_sym_size),
2744 &sh);
2745 if (strcmp (debug_info->ss + fh->issBase + sh.iss,
2746 stabs_symbol) == 0)
2747 processing_gcc_compilation = 2;
2748 }
2749
2750 if (processing_gcc_compilation != 0)
2751 {
2752 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
2753 {
2754 int type_code;
ef5ccd6c 2755 const char *namestring;
5796c8dc
SS
2756
2757 (*swap_sym_in) (cur_bfd,
2758 (((char *) debug_info->external_sym)
2759 + (fh->isymBase + cur_sdx) * external_sym_size),
2760 &sh);
2761 type_code = ECOFF_UNMARK_STAB (sh.index);
2762 if (!ECOFF_IS_STAB (&sh))
2763 {
2764 if (sh.st == stProc || sh.st == stStaticProc)
2765 {
2766 CORE_ADDR procaddr;
2767 long isym;
2768
c50c785c
JM
2769 sh.value += ANOFFSET (objfile->section_offsets,
2770 SECT_OFF_TEXT (objfile));
5796c8dc
SS
2771 if (sh.st == stStaticProc)
2772 {
2773 namestring = debug_info->ss + fh->issBase + sh.iss;
2774 record_minimal_symbol (namestring, sh.value,
2775 mst_file_text, sh.sc,
2776 objfile);
2777 }
2778 procaddr = sh.value;
2779
2780 isym = AUX_GET_ISYM (fh->fBigendian,
2781 (debug_info->external_aux
2782 + fh->iauxBase
2783 + sh.index));
2784 (*swap_sym_in) (cur_bfd,
2785 ((char *) debug_info->external_sym
2786 + ((fh->isymBase + isym - 1)
2787 * external_sym_size)),
2788 &sh);
2789 if (sh.st == stEnd)
2790 {
2791 CORE_ADDR high = procaddr + sh.value;
2792
2793 /* Kludge for Irix 5.2 zero fh->adr. */
2794 if (!relocatable
2795 && (pst->textlow == 0 || procaddr < pst->textlow))
2796 pst->textlow = procaddr;
2797 if (high > pst->texthigh)
2798 pst->texthigh = high;
2799 }
2800 }
2801 else if (sh.st == stStatic)
2802 {
2803 switch (sh.sc)
2804 {
2805 case scUndefined:
2806 case scSUndefined:
2807 case scNil:
2808 case scAbs:
2809 break;
2810
2811 case scData:
2812 case scSData:
2813 case scRData:
2814 case scPData:
2815 case scXData:
2816 namestring = debug_info->ss + fh->issBase + sh.iss;
c50c785c
JM
2817 sh.value += ANOFFSET (objfile->section_offsets,
2818 SECT_OFF_DATA (objfile));
5796c8dc
SS
2819 record_minimal_symbol (namestring, sh.value,
2820 mst_file_data, sh.sc,
2821 objfile);
2822 break;
2823
2824 default:
2825 /* FIXME! Shouldn't this use cases for bss,
c50c785c 2826 then have the default be abs? */
5796c8dc 2827 namestring = debug_info->ss + fh->issBase + sh.iss;
c50c785c
JM
2828 sh.value += ANOFFSET (objfile->section_offsets,
2829 SECT_OFF_BSS (objfile));
5796c8dc
SS
2830 record_minimal_symbol (namestring, sh.value,
2831 mst_file_bss, sh.sc,
2832 objfile);
2833 break;
2834 }
2835 }
2836 continue;
2837 }
c50c785c 2838 /* Handle stabs continuation. */
5796c8dc
SS
2839 {
2840 char *stabstring = debug_info->ss + fh->issBase + sh.iss;
2841 int len = strlen (stabstring);
cf7f2e2d 2842
5796c8dc
SS
2843 while (stabstring[len - 1] == '\\')
2844 {
2845 SYMR sh2;
2846 char *stabstring1 = stabstring;
2847 char *stabstring2;
2848 int len2;
2849
c50c785c 2850 /* Ignore continuation char from 1st string. */
5796c8dc
SS
2851 len--;
2852
c50c785c 2853 /* Read next stabstring. */
5796c8dc
SS
2854 cur_sdx++;
2855 (*swap_sym_in) (cur_bfd,
2856 (((char *) debug_info->external_sym)
2857 + (fh->isymBase + cur_sdx)
2858 * external_sym_size),
2859 &sh2);
2860 stabstring2 = debug_info->ss + fh->issBase + sh2.iss;
2861 len2 = strlen (stabstring2);
2862
c50c785c 2863 /* Concatinate stabstring2 with stabstring1. */
5796c8dc
SS
2864 if (stabstring
2865 && stabstring != debug_info->ss + fh->issBase + sh.iss)
2866 stabstring = xrealloc (stabstring, len + len2 + 1);
2867 else
2868 {
2869 stabstring = xmalloc (len + len2 + 1);
2870 strcpy (stabstring, stabstring1);
2871 }
2872 strcpy (stabstring + len, stabstring2);
2873 len += len2;
2874 }
2875
2876 switch (type_code)
2877 {
2878 char *p;
cf7f2e2d 2879
c50c785c 2880 /* Standard, external, non-debugger, symbols. */
5796c8dc
SS
2881
2882 case N_TEXT | N_EXT:
2883 case N_NBTEXT | N_EXT:
c50c785c
JM
2884 sh.value += ANOFFSET (objfile->section_offsets,
2885 SECT_OFF_TEXT (objfile));
5796c8dc
SS
2886 goto record_it;
2887
2888 case N_DATA | N_EXT:
2889 case N_NBDATA | N_EXT:
c50c785c
JM
2890 sh.value += ANOFFSET (objfile->section_offsets,
2891 SECT_OFF_DATA (objfile));
5796c8dc
SS
2892 goto record_it;
2893
2894 case N_BSS:
2895 case N_BSS | N_EXT:
2896 case N_NBBSS | N_EXT:
c50c785c
JM
2897 case N_SETV | N_EXT: /* FIXME, is this in BSS? */
2898 sh.value += ANOFFSET (objfile->section_offsets,
2899 SECT_OFF_BSS (objfile));
5796c8dc
SS
2900 goto record_it;
2901
2902 case N_ABS | N_EXT:
2903 record_it:
c50c785c 2904 continue;
5796c8dc 2905
c50c785c 2906 /* Standard, local, non-debugger, symbols. */
5796c8dc
SS
2907
2908 case N_NBTEXT:
2909
c50c785c
JM
2910 /* We need to be able to deal with both N_FN or
2911 N_TEXT, because we have no way of knowing
2912 whether the sys-supplied ld or GNU ld was used
2913 to make the executable. Sequents throw in
2914 another wrinkle -- they renumbered N_FN. */
5796c8dc
SS
2915
2916 case N_FN:
2917 case N_FN_SEQ:
2918 case N_TEXT:
2919 continue;
2920
2921 case N_DATA:
c50c785c
JM
2922 sh.value += ANOFFSET (objfile->section_offsets,
2923 SECT_OFF_DATA (objfile));
5796c8dc
SS
2924 goto record_it;
2925
2926 case N_UNDF | N_EXT:
c50c785c 2927 continue; /* Just undefined, not COMMON. */
5796c8dc
SS
2928
2929 case N_UNDF:
2930 continue;
2931
2932 /* Lots of symbol types we can just ignore. */
2933
2934 case N_ABS:
2935 case N_NBDATA:
2936 case N_NBBSS:
2937 continue;
2938
c50c785c 2939 /* Keep going . . . */
5796c8dc
SS
2940
2941 /*
2942 * Special symbol types for GNU
2943 */
2944 case N_INDR:
2945 case N_INDR | N_EXT:
2946 case N_SETA:
2947 case N_SETA | N_EXT:
2948 case N_SETT:
2949 case N_SETT | N_EXT:
2950 case N_SETD:
2951 case N_SETD | N_EXT:
2952 case N_SETB:
2953 case N_SETB | N_EXT:
2954 case N_SETV:
2955 continue;
2956
2957 /*
2958 * Debugger symbols
2959 */
2960
2961 case N_SO:
2962 {
2963 CORE_ADDR valu;
2964 static int prev_so_symnum = -10;
2965 static int first_so_symnum;
c50c785c 2966 const char *p;
5796c8dc
SS
2967 int prev_textlow_not_set;
2968
c50c785c
JM
2969 valu = sh.value + ANOFFSET (objfile->section_offsets,
2970 SECT_OFF_TEXT (objfile));
5796c8dc
SS
2971
2972 prev_textlow_not_set = textlow_not_set;
2973
c50c785c
JM
2974 /* A zero value is probably an indication for the
2975 SunPRO 3.0 compiler. end_psymtab explicitly tests
2976 for zero, so don't relocate it. */
5796c8dc
SS
2977
2978 if (sh.value == 0
2979 && gdbarch_sofun_address_maybe_missing (gdbarch))
2980 {
2981 textlow_not_set = 1;
2982 valu = 0;
2983 }
2984 else
2985 textlow_not_set = 0;
2986
2987 past_first_source_file = 1;
2988
2989 if (prev_so_symnum != symnum - 1)
c50c785c 2990 { /* Here if prev stab wasn't N_SO. */
5796c8dc
SS
2991 first_so_symnum = symnum;
2992
2993 if (pst)
2994 {
2995 pst = (struct partial_symtab *) 0;
2996 includes_used = 0;
2997 dependencies_used = 0;
2998 }
2999 }
3000
3001 prev_so_symnum = symnum;
3002
c50c785c
JM
3003 /* End the current partial symtab and start a
3004 new one. */
5796c8dc
SS
3005
3006 /* SET_NAMESTRING ();*/
3007 namestring = stabstring;
3008
c50c785c
JM
3009 /* Null name means end of .o file. Don't start a new
3010 one. */
5796c8dc
SS
3011 if (*namestring == '\000')
3012 continue;
3013
c50c785c
JM
3014 /* Some compilers (including gcc) emit a pair of
3015 initial N_SOs. The first one is a directory name;
3016 the second the file name. If pst exists, is
3017 empty, and has a filename ending in '/', we assume
3018 the previous N_SO was a directory name. */
3019 p = lbasename (namestring);
3020 if (p != namestring && *p == '\000')
3021 continue; /* Simply ignore directory
3022 name SOs. */
3023
3024 /* Some other compilers (C++ ones in particular) emit
3025 useless SOs for non-existant .c files. We ignore
3026 all subsequent SOs that immediately follow the
3027 first. */
5796c8dc
SS
3028
3029 if (!pst)
3030 pst = save_pst;
3031 continue;
3032 }
3033
3034 case N_BINCL:
3035 continue;
3036
3037 case N_SOL:
3038 {
3039 enum language tmp_language;
cf7f2e2d 3040
c50c785c 3041 /* Mark down an include file in the current psymtab. */
5796c8dc 3042
c50c785c 3043 /* SET_NAMESTRING (); */
5796c8dc
SS
3044 namestring = stabstring;
3045
c50c785c
JM
3046 tmp_language
3047 = deduce_language_from_filename (namestring);
5796c8dc 3048
c50c785c
JM
3049 /* Only change the psymtab's language if we've
3050 learned something useful (eg. tmp_language is not
3051 language_unknown). In addition, to match what
3052 start_subfile does, never change from C++ to
3053 C. */
5796c8dc
SS
3054 if (tmp_language != language_unknown
3055 && (tmp_language != language_c
3056 || psymtab_language != language_cplus))
3057 psymtab_language = tmp_language;
3058
c50c785c
JM
3059 /* In C++, one may expect the same filename to come
3060 round many times, when code is coming alternately
3061 from the main file and from inline functions in
3062 other files. So I check to see if this is a file
3063 we've seen before -- either the main source file,
3064 or a previously included file.
3065
3066 This seems to be a lot of time to be spending on
3067 N_SOL, but things like "break c-exp.y:435" need to
3068 work (I suppose the psymtab_include_list could be
3069 hashed or put in a binary tree, if profiling shows
3070 this is a major hog). */
3071 if (pst && filename_cmp (namestring, pst->filename) == 0)
5796c8dc 3072 continue;
cf7f2e2d 3073
5796c8dc
SS
3074 {
3075 int i;
cf7f2e2d 3076
5796c8dc 3077 for (i = 0; i < includes_used; i++)
c50c785c
JM
3078 if (filename_cmp (namestring,
3079 psymtab_include_list[i]) == 0)
5796c8dc
SS
3080 {
3081 i = -1;
3082 break;
3083 }
3084 if (i == -1)
3085 continue;
3086 }
3087
3088 psymtab_include_list[includes_used++] = namestring;
3089 if (includes_used >= includes_allocated)
3090 {
ef5ccd6c 3091 const char **orig = psymtab_include_list;
5796c8dc 3092
ef5ccd6c 3093 psymtab_include_list = (const char **)
5796c8dc 3094 alloca ((includes_allocated *= 2) *
ef5ccd6c 3095 sizeof (const char *));
5796c8dc 3096 memcpy (psymtab_include_list, orig,
ef5ccd6c 3097 includes_used * sizeof (const char *));
5796c8dc
SS
3098 }
3099 continue;
3100 }
c50c785c
JM
3101 case N_LSYM: /* Typedef or automatic variable. */
3102 case N_STSYM: /* Data seg var -- static */
3103 case N_LCSYM: /* BSS " */
3104 case N_ROSYM: /* Read-only data seg var -- static. */
3105 case N_NBSTS: /* Gould nobase. */
3106 case N_NBLCS: /* symbols. */
5796c8dc 3107 case N_FUN:
c50c785c
JM
3108 case N_GSYM: /* Global (extern) variable; can be
3109 data or bss (sigh FIXME). */
5796c8dc
SS
3110
3111 /* Following may probably be ignored; I'll leave them here
3112 for now (until I do Pascal and Modula 2 extensions). */
3113
c50c785c
JM
3114 case N_PC: /* I may or may not need this; I
3115 suspect not. */
3116 case N_M2C: /* I suspect that I can ignore this
3117 here. */
3118 case N_SCOPE: /* Same. */
5796c8dc 3119
c50c785c 3120 /* SET_NAMESTRING (); */
5796c8dc
SS
3121 namestring = stabstring;
3122 p = (char *) strchr (namestring, ':');
3123 if (!p)
c50c785c 3124 continue; /* Not a debugging symbol. */
5796c8dc
SS
3125
3126
3127
3128 /* Main processing section for debugging symbols which
c50c785c
JM
3129 the initial read through the symbol tables needs to
3130 worry about. If we reach this point, the symbol
3131 which we are considering is definitely one we are
3132 interested in. p must also contain the (valid)
3133 index into the namestring which indicates the
3134 debugging type symbol. */
5796c8dc
SS
3135
3136 switch (p[1])
3137 {
3138 case 'S':
c50c785c
JM
3139 sh.value += ANOFFSET (objfile->section_offsets,
3140 SECT_OFF_DATA (objfile));
5796c8dc
SS
3141
3142 if (gdbarch_static_transform_name_p (gdbarch))
3143 namestring = gdbarch_static_transform_name
3144 (gdbarch, namestring);
3145
cf7f2e2d 3146 add_psymbol_to_list (namestring, p - namestring, 1,
5796c8dc
SS
3147 VAR_DOMAIN, LOC_STATIC,
3148 &objfile->static_psymbols,
3149 0, sh.value,
3150 psymtab_language, objfile);
3151 continue;
3152 case 'G':
c50c785c
JM
3153 sh.value += ANOFFSET (objfile->section_offsets,
3154 SECT_OFF_DATA (objfile));
3155 /* The addresses in these entries are reported
3156 to be wrong. See the code that reads 'G's
3157 for symtabs. */
cf7f2e2d 3158 add_psymbol_to_list (namestring, p - namestring, 1,
5796c8dc
SS
3159 VAR_DOMAIN, LOC_STATIC,
3160 &objfile->global_psymbols,
3161 0, sh.value,
3162 psymtab_language, objfile);
3163 continue;
3164
3165 case 'T':
3166 /* When a 'T' entry is defining an anonymous enum, it
3167 may have a name which is the empty string, or a
3168 single space. Since they're not really defining a
3169 symbol, those shouldn't go in the partial symbol
3170 table. We do pick up the elements of such enums at
3171 'check_enum:', below. */
3172 if (p >= namestring + 2
3173 || (p == namestring + 1
3174 && namestring[0] != ' '))
3175 {
cf7f2e2d 3176 add_psymbol_to_list (namestring, p - namestring, 1,
5796c8dc
SS
3177 STRUCT_DOMAIN, LOC_TYPEDEF,
3178 &objfile->static_psymbols,
3179 sh.value, 0,
3180 psymtab_language, objfile);
3181 if (p[2] == 't')
3182 {
3183 /* Also a typedef with the same name. */
c50c785c
JM
3184 add_psymbol_to_list (namestring,
3185 p - namestring, 1,
5796c8dc
SS
3186 VAR_DOMAIN, LOC_TYPEDEF,
3187 &objfile->static_psymbols,
3188 sh.value, 0,
c50c785c
JM
3189 psymtab_language,
3190 objfile);
5796c8dc
SS
3191 p += 1;
3192 }
3193 }
3194 goto check_enum;
3195 case 't':
c50c785c
JM
3196 if (p != namestring) /* a name is there, not
3197 just :T... */
5796c8dc 3198 {
cf7f2e2d 3199 add_psymbol_to_list (namestring, p - namestring, 1,
5796c8dc
SS
3200 VAR_DOMAIN, LOC_TYPEDEF,
3201 &objfile->static_psymbols,
3202 sh.value, 0,
3203 psymtab_language, objfile);
3204 }
3205 check_enum:
c50c785c
JM
3206 /* If this is an enumerated type, we need to add
3207 all the enum constants to the partial symbol
3208 table. This does not cover enums without names,
3209 e.g. "enum {a, b} c;" in C, but fortunately
3210 those are rare. There is no way for GDB to find
3211 those from the enum type without spending too
3212 much time on it. Thus to solve this problem,
3213 the compiler needs to put out the enum in a
3214 nameless type. GCC2 does this. */
5796c8dc
SS
3215
3216 /* We are looking for something of the form
3217 <name> ":" ("t" | "T") [<number> "="] "e"
3218 {<constant> ":" <value> ","} ";". */
3219
3220 /* Skip over the colon and the 't' or 'T'. */
3221 p += 2;
c50c785c
JM
3222 /* This type may be given a number. Also, numbers
3223 can come in pairs like (0,26). Skip over it. */
5796c8dc
SS
3224 while ((*p >= '0' && *p <= '9')
3225 || *p == '(' || *p == ',' || *p == ')'
3226 || *p == '=')
3227 p++;
3228
3229 if (*p++ == 'e')
3230 {
c50c785c
JM
3231 /* The aix4 compiler emits extra crud before
3232 the members. */
5796c8dc
SS
3233 if (*p == '-')
3234 {
3235 /* Skip over the type (?). */
3236 while (*p != ':')
3237 p++;
3238
3239 /* Skip over the colon. */
3240 p++;
3241 }
3242
3243 /* We have found an enumerated type. */
3244 /* According to comments in read_enum_type
3245 a comma could end it instead of a semicolon.
3246 I don't know where that happens.
3247 Accept either. */
3248 while (*p && *p != ';' && *p != ',')
3249 {
3250 char *q;
3251
c50c785c
JM
3252 /* Check for and handle cretinous dbx
3253 symbol name continuation! */
5796c8dc
SS
3254 if (*p == '\\' || (*p == '?' && p[1] == '\0'))
3255 p = next_symbol_text (objfile);
3256
3257 /* Point to the character after the name
3258 of the enum constant. */
3259 for (q = p; *q && *q != ':'; q++)
3260 ;
3261 /* Note that the value doesn't matter for
c50c785c
JM
3262 enum constants in psymtabs, just in
3263 symtabs. */
cf7f2e2d 3264 add_psymbol_to_list (p, q - p, 1,
5796c8dc 3265 VAR_DOMAIN, LOC_CONST,
c50c785c
JM
3266 &objfile->static_psymbols,
3267 0, 0, psymtab_language,
3268 objfile);
5796c8dc
SS
3269 /* Point past the name. */
3270 p = q;
3271 /* Skip over the value. */
3272 while (*p && *p != ',')
3273 p++;
3274 /* Advance past the comma. */
3275 if (*p)
3276 p++;
3277 }
3278 }
3279 continue;
3280 case 'c':
3281 /* Constant, e.g. from "const" in Pascal. */
cf7f2e2d 3282 add_psymbol_to_list (namestring, p - namestring, 1,
5796c8dc 3283 VAR_DOMAIN, LOC_CONST,
c50c785c
JM
3284 &objfile->static_psymbols,
3285 sh.value, 0, psymtab_language,
3286 objfile);
5796c8dc
SS
3287 continue;
3288
3289 case 'f':
3290 if (! pst)
3291 {
3292 int name_len = p - namestring;
3293 char *name = xmalloc (name_len + 1);
cf7f2e2d 3294
5796c8dc
SS
3295 memcpy (name, namestring, name_len);
3296 name[name_len] = '\0';
3297 function_outside_compilation_unit_complaint (name);
3298 xfree (name);
3299 }
c50c785c
JM
3300 sh.value += ANOFFSET (objfile->section_offsets,
3301 SECT_OFF_TEXT (objfile));
cf7f2e2d 3302 add_psymbol_to_list (namestring, p - namestring, 1,
5796c8dc
SS
3303 VAR_DOMAIN, LOC_BLOCK,
3304 &objfile->static_psymbols,
3305 0, sh.value,
3306 psymtab_language, objfile);
3307 continue;
3308
3309 /* Global functions were ignored here, but now they
c50c785c
JM
3310 are put into the global psymtab like one would
3311 expect. They're also in the minimal symbol
3312 table. */
5796c8dc
SS
3313 case 'F':
3314 if (! pst)
3315 {
3316 int name_len = p - namestring;
3317 char *name = xmalloc (name_len + 1);
cf7f2e2d 3318
5796c8dc
SS
3319 memcpy (name, namestring, name_len);
3320 name[name_len] = '\0';
3321 function_outside_compilation_unit_complaint (name);
3322 xfree (name);
3323 }
c50c785c
JM
3324 sh.value += ANOFFSET (objfile->section_offsets,
3325 SECT_OFF_TEXT (objfile));
cf7f2e2d 3326 add_psymbol_to_list (namestring, p - namestring, 1,
5796c8dc
SS
3327 VAR_DOMAIN, LOC_BLOCK,
3328 &objfile->global_psymbols,
3329 0, sh.value,
3330 psymtab_language, objfile);
3331 continue;
3332
c50c785c
JM
3333 /* Two things show up here (hopefully); static
3334 symbols of local scope (static used inside
3335 braces) or extensions of structure symbols. We
3336 can ignore both. */
5796c8dc
SS
3337 case 'V':
3338 case '(':
3339 case '0':
3340 case '1':
3341 case '2':
3342 case '3':
3343 case '4':
3344 case '5':
3345 case '6':
3346 case '7':
3347 case '8':
3348 case '9':
3349 case '-':
c50c785c
JM
3350 case '#': /* For symbol identification (used
3351 in live ranges). */
5796c8dc
SS
3352 continue;
3353
3354 case ':':
c50c785c
JM
3355 /* It is a C++ nested symbol. We don't need to
3356 record it (I don't think); if we try to look up
3357 foo::bar::baz, then symbols for the symtab
3358 containing foo should get read in, I think. */
5796c8dc
SS
3359 /* Someone says sun cc puts out symbols like
3360 /foo/baz/maclib::/usr/local/bin/maclib,
3361 which would get here with a symbol type of ':'. */
3362 continue;
3363
3364 default:
c50c785c
JM
3365 /* Unexpected symbol descriptor. The second and
3366 subsequent stabs of a continued stab can show up
3367 here. The question is whether they ever can
3368 mimic a normal stab--it would be nice if not,
3369 since we certainly don't want to spend the time
3370 searching to the end of every string looking for
5796c8dc
SS
3371 a backslash. */
3372
3373 complaint (&symfile_complaints,
3374 _("unknown symbol descriptor `%c'"), p[1]);
3375
3376 /* Ignore it; perhaps it is an extension that we don't
3377 know about. */
3378 continue;
3379 }
3380
3381 case N_EXCL:
3382 continue;
3383
3384 case N_ENDM:
3385 /* Solaris 2 end of module, finish current partial
3386 symbol table. END_PSYMTAB will set
3387 pst->texthigh to the proper value, which is
3388 necessary if a module compiled without
3389 debugging info follows this module. */
3390 if (pst
3391 && gdbarch_sofun_address_maybe_missing (gdbarch))
3392 {
3393 pst = (struct partial_symtab *) 0;
3394 includes_used = 0;
3395 dependencies_used = 0;
3396 }
3397 continue;
3398
3399 case N_RBRAC:
3400 if (sh.value > save_pst->texthigh)
3401 save_pst->texthigh = sh.value;
3402 continue;
3403 case N_EINCL:
3404 case N_DSLINE:
3405 case N_BSLINE:
c50c785c
JM
3406 case N_SSYM: /* Claim: Structure or union
3407 element. Hopefully, I can
3408 ignore this. */
3409 case N_ENTRY: /* Alternate entry point; can
3410 ignore. */
3411 case N_MAIN: /* Can definitely ignore this. */
3412 case N_CATCH: /* These are GNU C++ extensions. */
3413 case N_EHDECL: /* that can safely be ignored here. */
5796c8dc
SS
3414 case N_LENG:
3415 case N_BCOMM:
3416 case N_ECOMM:
3417 case N_ECOML:
3418 case N_FNAME:
3419 case N_SLINE:
3420 case N_RSYM:
3421 case N_PSYM:
3422 case N_LBRAC:
3423 case N_NSYMS: /* Ultrix 4.0: symbol count */
3424 case N_DEFD: /* GNU Modula-2 */
c50c785c
JM
3425 case N_ALIAS: /* SunPro F77: alias name, ignore
3426 for now. */
5796c8dc 3427
c50c785c 3428 case N_OBJ: /* Useless types from Solaris. */
5796c8dc 3429 case N_OPT:
c50c785c
JM
3430 /* These symbols aren't interesting; don't worry about
3431 them. */
5796c8dc
SS
3432
3433 continue;
3434
3435 default:
c50c785c
JM
3436 /* If we haven't found it yet, ignore it. It's
3437 probably some new type we don't know about yet. */
3438 complaint (&symfile_complaints,
3439 _("unknown symbol type %s"),
3440 hex_string (type_code)); /* CUR_SYMBOL_TYPE */
5796c8dc
SS
3441 continue;
3442 }
3443 if (stabstring
3444 && stabstring != debug_info->ss + fh->issBase + sh.iss)
3445 xfree (stabstring);
3446 }
3447 /* end - Handle continuation */
3448 }
3449 }
3450 else
3451 {
3452 for (cur_sdx = 0; cur_sdx < fh->csym;)
3453 {
3454 char *name;
3455 enum address_class class;
3456
3457 (*swap_sym_in) (cur_bfd,
3458 ((char *) debug_info->external_sym
3459 + ((fh->isymBase + cur_sdx)
3460 * external_sym_size)),
3461 &sh);
3462
3463 if (ECOFF_IS_STAB (&sh))
3464 {
3465 cur_sdx++;
3466 continue;
3467 }
3468
3469 /* Non absolute static symbols go into the minimal table. */
3470 if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil
3471 || (sh.index == indexNil
3472 && (sh.st != stStatic || sh.sc == scAbs)))
3473 {
c50c785c 3474 /* FIXME, premature? */
5796c8dc
SS
3475 cur_sdx++;
3476 continue;
3477 }
3478
3479 name = debug_info->ss + fh->issBase + sh.iss;
3480
3481 switch (sh.sc)
3482 {
3483 case scText:
3484 case scRConst:
3485 /* The value of a stEnd symbol is the displacement from the
3486 corresponding start symbol value, do not relocate it. */
3487 if (sh.st != stEnd)
c50c785c
JM
3488 sh.value += ANOFFSET (objfile->section_offsets,
3489 SECT_OFF_TEXT (objfile));
5796c8dc
SS
3490 break;
3491 case scData:
3492 case scSData:
3493 case scRData:
3494 case scPData:
3495 case scXData:
c50c785c
JM
3496 sh.value += ANOFFSET (objfile->section_offsets,
3497 SECT_OFF_DATA (objfile));
5796c8dc
SS
3498 break;
3499 case scBss:
3500 case scSBss:
c50c785c
JM
3501 sh.value += ANOFFSET (objfile->section_offsets,
3502 SECT_OFF_BSS (objfile));
5796c8dc
SS
3503 break;
3504 }
3505
3506 switch (sh.st)
3507 {
3508 CORE_ADDR high;
3509 CORE_ADDR procaddr;
3510 int new_sdx;
3511
3512 case stStaticProc:
3513 prim_record_minimal_symbol_and_info (name, sh.value,
3514 mst_file_text,
c50c785c
JM
3515 SECT_OFF_TEXT (objfile),
3516 NULL, objfile);
5796c8dc
SS
3517
3518 /* FALLTHROUGH */
3519
3520 case stProc:
3521 /* Ignore all parameter symbol records. */
3522 if (sh.index >= hdr->iauxMax)
3523 {
3524 /* Should not happen, but does when cross-compiling
3525 with the MIPS compiler. FIXME -- pull later. */
3526 index_complaint (name);
c50c785c