2011-03-05 Michael Snyder <msnyder@vmware.com>
[external/binutils.git] / gdb / mdebugread.c
1 /* Read a symbol table in ECOFF format (Third-Eye).
2
3    Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4    1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010,
5    2011 Free Software Foundation, Inc.
6
7    Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
8    CMU.  Major work by Per Bothner, John Gilmore and Ian Lance Taylor
9    at Cygnus Support.
10
11    This file is part of GDB.
12
13    This program is free software; you can redistribute it and/or modify
14    it under the terms of the GNU General Public License as published by
15    the Free Software Foundation; either version 3 of the License, or
16    (at your option) any later version.
17
18    This program is distributed in the hope that it will be useful,
19    but WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21    GNU General Public License for more details.
22
23    You should have received a copy of the GNU General Public License
24    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
25
26 /* This module provides the function mdebug_build_psymtabs.  It reads
27    ECOFF debugging information into partial symbol tables.  The
28    debugging information is read from two structures.  A struct
29    ecoff_debug_swap includes the sizes of each ECOFF structure and
30    swapping routines; these are fixed for a particular target.  A
31    struct ecoff_debug_info points to the debugging information for a
32    particular object file.
33
34    ECOFF symbol tables are mostly written in the byte order of the
35    target machine.  However, one section of the table (the auxiliary
36    symbol information) is written in the host byte order.  There is a
37    bit in the other symbol info which describes which host byte order
38    was used.  ECOFF thereby takes the trophy from Intel `b.out' for
39    the most brain-dead adaptation of a file format to byte order.
40
41    This module can read all four of the known byte-order combinations,
42    on any type of host.  */
43
44 #include "defs.h"
45 #include "symtab.h"
46 #include "gdbtypes.h"
47 #include "gdbcore.h"
48 #include "objfiles.h"
49 #include "gdb_obstack.h"
50 #include "buildsym.h"
51 #include "stabsread.h"
52 #include "complaints.h"
53 #include "demangle.h"
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"
60 #include "psympriv.h"
61
62 #include "bfd.h"
63
64 #include "coff/ecoff.h"         /* COFF-like aspects of ecoff files.  */
65
66 #include "libaout.h"            /* Private BFD a.out information.  */
67 #include "aout/aout64.h"
68 #include "aout/stab_gnu.h"      /* STABS information.  */
69
70 #include "expression.h"
71
72 extern void _initialize_mdebugread (void);
73
74 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
75    We use this define in order to know whether we should override a 
76    symbol's ECOFF section with its ELF section.  This is necessary in 
77    case the symbol's ELF section could not be represented in ECOFF.  */
78 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
79                            && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
80 \f
81
82 /* We put a pointer to this structure in the read_symtab_private field
83    of the psymtab.  */
84
85 struct symloc
86   {
87     /* Index of the FDR that this psymtab represents.  */
88     int fdr_idx;
89     /* The BFD that the psymtab was created from.  */
90     bfd *cur_bfd;
91     const struct ecoff_debug_swap *debug_swap;
92     struct ecoff_debug_info *debug_info;
93     struct mdebug_pending **pending_list;
94     /* Pointer to external symbols for this file.  */
95     EXTR *extern_tab;
96     /* Size of extern_tab.  */
97     int extern_count;
98     enum language pst_language;
99   };
100
101 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
102 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
103 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
104 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
105 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
106 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
107
108 #define SC_IS_TEXT(sc) ((sc) == scText \
109                    || (sc) == scRConst \
110                    || (sc) == scInit \
111                    || (sc) == scFini)
112 #define SC_IS_DATA(sc) ((sc) == scData \
113                    || (sc) == scSData \
114                    || (sc) == scRData \
115                    || (sc) == scPData \
116                    || (sc) == scXData)
117 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
118 #define SC_IS_BSS(sc) ((sc) == scBss)
119 #define SC_IS_SBSS(sc) ((sc) == scSBss)
120 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
121 \f
122 /* Various complaints about symbol reading that don't abort the process.  */
123 static void
124 index_complaint (const char *arg1)
125 {
126   complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
127 }
128
129 static void
130 unknown_ext_complaint (const char *arg1)
131 {
132   complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
133 }
134
135 static void
136 basic_type_complaint (int arg1, const char *arg2)
137 {
138   complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
139              arg1, arg2);
140 }
141
142 static void
143 bad_tag_guess_complaint (const char *arg1)
144 {
145   complaint (&symfile_complaints,
146              _("guessed tag type of %s incorrectly"), arg1);
147 }
148
149 static void
150 bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
151 {
152   complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
153              arg1, arg2, arg3);
154 }
155
156 static void
157 unexpected_type_code_complaint (const char *arg1)
158 {
159   complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
160 }
161
162 /* Macros and extra defs.  */
163
164 /* Puns: hard to find whether -g was used and how.  */
165
166 #define MIN_GLEVEL GLEVEL_0
167 #define compare_glevel(a,b)                                     \
168         (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) :                 \
169          ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
170 \f
171 /* Things that really are local to this module.  */
172
173 /* Remember what we deduced to be the source language of this psymtab.  */
174
175 static enum language psymtab_language = language_unknown;
176
177 /* Current BFD.  */
178
179 static bfd *cur_bfd;
180
181 /* How to parse debugging information for CUR_BFD.  */
182
183 static const struct ecoff_debug_swap *debug_swap;
184
185 /* Pointers to debugging information for CUR_BFD.  */
186
187 static struct ecoff_debug_info *debug_info;
188
189 /* Pointer to current file decriptor record, and its index.  */
190
191 static FDR *cur_fdr;
192 static int cur_fd;
193
194 /* Index of current symbol.  */
195
196 static int cur_sdx;
197
198 /* Note how much "debuggable" this image is.  We would like
199    to see at least one FDR with full symbols.  */
200
201 static int max_gdbinfo;
202 static int max_glevel;
203
204 /* When examining .o files, report on undefined symbols.  */
205
206 static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
207
208 /* Pseudo symbol to use when putting stabs into the symbol table.  */
209
210 static char stabs_symbol[] = STABS_SYMBOL;
211
212 /* Nonzero if we have seen ecoff debugging info for a file.  */
213
214 static int found_ecoff_debugging_info;
215
216 /* Forward declarations.  */
217
218 static int upgrade_type (int, struct type **, int, union aux_ext *,
219                          int, char *);
220
221 static void parse_partial_symbols (struct objfile *);
222
223 static int has_opaque_xref (FDR *, SYMR *);
224
225 static int cross_ref (int, union aux_ext *, struct type **, enum type_code,
226                       char **, int, char *);
227
228 static struct symbol *new_symbol (char *);
229
230 static struct type *new_type (char *);
231
232 enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };
233
234 static struct block *new_block (enum block_type);
235
236 static struct symtab *new_symtab (const char *, int, struct objfile *);
237
238 static struct linetable *new_linetable (int);
239
240 static struct blockvector *new_bvect (int);
241
242 static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
243                                 int, char *);
244
245 static struct symbol *mylookup_symbol (char *, struct block *, domain_enum,
246                                        enum address_class);
247
248 static void sort_blocks (struct symtab *);
249
250 static struct partial_symtab *new_psymtab (char *, struct objfile *);
251
252 static void psymtab_to_symtab_1 (struct partial_symtab *, const char *);
253
254 static void add_block (struct block *, struct symtab *);
255
256 static void add_symbol (struct symbol *, struct symtab *, struct block *);
257
258 static int add_line (struct linetable *, int, CORE_ADDR, int);
259
260 static struct linetable *shrink_linetable (struct linetable *);
261
262 static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
263                                         CORE_ADDR);
264
265 static char *mdebug_next_symbol_text (struct objfile *);
266 \f
267 /* Exported procedure: Builds a symtab from the PST partial one.
268    Restores the environment in effect when PST was created, delegates
269    most of the work to an ancillary procedure, and sorts
270    and reorders the symtab list at the end.  */
271
272 static void
273 mdebug_psymtab_to_symtab (struct partial_symtab *pst)
274 {
275   if (!pst)
276     return;
277
278   if (info_verbose)
279     {
280       printf_filtered (_("Reading in symbols for %s..."), pst->filename);
281       gdb_flush (gdb_stdout);
282     }
283
284   next_symbol_text_func = mdebug_next_symbol_text;
285
286   psymtab_to_symtab_1 (pst, pst->filename);
287
288   /* Match with global symbols.  This only needs to be done once,
289      after all of the symtabs and dependencies have been read in.  */
290   scan_file_globals (pst->objfile);
291
292   if (info_verbose)
293     printf_filtered (_("done.\n"));
294 }
295 \f
296 /* File-level interface functions.  */
297
298 /* Find a file descriptor given its index RF relative to a file CF.  */
299
300 static FDR *
301 get_rfd (int cf, int rf)
302 {
303   FDR *fdrs;
304   FDR *f;
305   RFDT rfd;
306
307   fdrs = debug_info->fdr;
308   f = fdrs + cf;
309   /* Object files do not have the RFD table, all refs are absolute.  */
310   if (f->rfdBase == 0)
311     return fdrs + rf;
312   (*debug_swap->swap_rfd_in) (cur_bfd,
313                               ((char *) debug_info->external_rfd
314                                + ((f->rfdBase + rf)
315                                   * debug_swap->external_rfd_size)),
316                               &rfd);
317   return fdrs + rfd;
318 }
319
320 /* Return a safer print NAME for a file descriptor.  */
321
322 static char *
323 fdr_name (FDR *f)
324 {
325   if (f->rss == -1)
326     return "<stripped file>";
327   if (f->rss == 0)
328     return "<NFY>";
329   return debug_info->ss + f->issBase + f->rss;
330 }
331
332
333 /* Read in and parse the symtab of the file OBJFILE.  Symbols from
334    different sections are relocated via the SECTION_OFFSETS.  */
335
336 void
337 mdebug_build_psymtabs (struct objfile *objfile,
338                        const struct ecoff_debug_swap *swap,
339                        struct ecoff_debug_info *info)
340 {
341   cur_bfd = objfile->obfd;
342   debug_swap = swap;
343   debug_info = info;
344
345   stabsread_new_init ();
346   buildsym_new_init ();
347   free_header_files ();
348   init_header_files ();
349         
350   /* Make sure all the FDR information is swapped in.  */
351   if (info->fdr == (FDR *) NULL)
352     {
353       char *fdr_src;
354       char *fdr_end;
355       FDR *fdr_ptr;
356
357       info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack,
358                                          (info->symbolic_header.ifdMax
359                                           * sizeof (FDR)));
360       fdr_src = info->external_fdr;
361       fdr_end = (fdr_src
362                  + info->symbolic_header.ifdMax * swap->external_fdr_size);
363       fdr_ptr = info->fdr;
364       for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++)
365         (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);
366     }
367
368   parse_partial_symbols (objfile);
369
370 #if 0
371   /* Check to make sure file was compiled with -g.  If not, warn the
372      user of this limitation.  */
373   if (compare_glevel (max_glevel, GLEVEL_2) < 0)
374     {
375       if (max_gdbinfo == 0)
376         printf_unfiltered (_("\n%s not compiled with -g, "
377                              "debugging support is limited.\n"),
378                            objfile->name);
379       printf_unfiltered (_("You should compile with -g2 or "
380                            "-g3 for best debugging support.\n"));
381       gdb_flush (gdb_stdout);
382     }
383 #endif
384 }
385 \f
386 /* Local utilities */
387
388 /* Map of FDR indexes to partial symtabs.  */
389
390 struct pst_map
391 {
392   struct partial_symtab *pst;   /* the psymtab proper */
393   long n_globals;               /* exported globals (external symbols) */
394   long globals_offset;          /* cumulative */
395 };
396
397
398 /* Utility stack, used to nest procedures and blocks properly.
399    It is a doubly linked list, to avoid too many alloc/free.
400    Since we might need it quite a few times it is NOT deallocated
401    after use.  */
402
403 static struct parse_stack
404   {
405     struct parse_stack *next, *prev;
406     struct symtab *cur_st;      /* Current symtab.  */
407     struct block *cur_block;    /* Block in it.  */
408
409     /* What are we parsing.  stFile, or stBlock are for files and
410        blocks.  stProc or stStaticProc means we have seen the start of a
411        procedure, but not the start of the block within in.  When we see
412        the start of that block, we change it to stNil, without pushing a
413        new block, i.e. stNil means both a procedure and a block.  */
414
415     int blocktype;
416
417     struct type *cur_type;      /* Type we parse fields for.  */
418     int cur_field;              /* Field number in cur_type.  */
419     CORE_ADDR procadr;          /* Start addres of this procedure.  */
420     int numargs;                /* Its argument count.  */
421   }
422
423  *top_stack;                    /* Top stack ptr */
424
425
426 /* Enter a new lexical context.  */
427
428 static void
429 push_parse_stack (void)
430 {
431   struct parse_stack *new;
432
433   /* Reuse frames if possible.  */
434   if (top_stack && top_stack->prev)
435     new = top_stack->prev;
436   else
437     new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
438   /* Initialize new frame with previous content.  */
439   if (top_stack)
440     {
441       struct parse_stack *prev = new->prev;
442
443       *new = *top_stack;
444       top_stack->prev = new;
445       new->prev = prev;
446       new->next = top_stack;
447     }
448   top_stack = new;
449 }
450
451 /* Exit a lexical context.  */
452
453 static void
454 pop_parse_stack (void)
455 {
456   if (!top_stack)
457     return;
458   if (top_stack->next)
459     top_stack = top_stack->next;
460 }
461
462
463 /* Cross-references might be to things we haven't looked at
464    yet, e.g. type references.  To avoid too many type
465    duplications we keep a quick fixup table, an array
466    of lists of references indexed by file descriptor.  */
467
468 struct mdebug_pending
469 {
470   struct mdebug_pending *next;  /* link */
471   char *s;                      /* the unswapped symbol */
472   struct type *t;               /* its partial type descriptor */
473 };
474
475
476 /* The pending information is kept for an entire object file, and used
477    to be in the deprecated_sym_private field.  I took it out when I
478    split mdebugread from mipsread, because this might not be the only
479    type of symbols read from an object file.  Instead, we allocate the
480    pending information table when we create the partial symbols, and
481    we store a pointer to the single table in each psymtab.  */
482
483 static struct mdebug_pending **pending_list;
484
485 /* Check whether we already saw symbol SH in file FH.  */
486
487 static struct mdebug_pending *
488 is_pending_symbol (FDR *fh, char *sh)
489 {
490   int f_idx = fh - debug_info->fdr;
491   struct mdebug_pending *p;
492
493   /* Linear search is ok, list is typically no more than 10 deep.  */
494   for (p = pending_list[f_idx]; p; p = p->next)
495     if (p->s == sh)
496       break;
497   return p;
498 }
499
500 /* Add a new symbol SH of type T.  */
501
502 static void
503 add_pending (FDR *fh, char *sh, struct type *t)
504 {
505   int f_idx = fh - debug_info->fdr;
506   struct mdebug_pending *p = is_pending_symbol (fh, sh);
507
508   /* Make sure we do not make duplicates.  */
509   if (!p)
510     {
511       p = ((struct mdebug_pending *)
512            obstack_alloc (&current_objfile->objfile_obstack,
513                           sizeof (struct mdebug_pending)));
514       p->s = sh;
515       p->t = t;
516       p->next = pending_list[f_idx];
517       pending_list[f_idx] = p;
518     }
519 }
520 \f
521
522 /* Parsing Routines proper.  */
523
524 /* Parse a single symbol.  Mostly just make up a GDB symbol for it.
525    For blocks, procedures and types we open a new lexical context.
526    This is basically just a big switch on the symbol's type.  Argument
527    AX is the base pointer of aux symbols for this file (fh->iauxBase).
528    EXT_SH points to the unswapped symbol, which is needed for struct,
529    union, etc., types; it is NULL for an EXTR.  BIGEND says whether
530    aux symbols are big-endian or little-endian.  Return count of
531    SYMR's handled (normally one).  */
532
533 static int
534 mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
535 {
536   return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
537 }
538
539 static const struct symbol_register_ops mdebug_register_funcs = {
540   mdebug_reg_to_regnum
541 };
542
543 static int
544 parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
545               struct section_offsets *section_offsets, struct objfile *objfile)
546 {
547   struct gdbarch *gdbarch = get_objfile_arch (objfile);
548   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
549   void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
550   char *name;
551   struct symbol *s;
552   struct block *b;
553   struct mdebug_pending *pend;
554   struct type *t;
555   struct field *f;
556   int count = 1;
557   enum address_class class;
558   TIR tir;
559   long svalue = sh->value;
560   int bitsize;
561
562   if (ext_sh == (char *) NULL)
563     name = debug_info->ssext + sh->iss;
564   else
565     name = debug_info->ss + cur_fdr->issBase + sh->iss;
566
567   switch (sh->sc)
568     {
569     case scText:
570     case scRConst:
571       /* Do not relocate relative values.
572          The value of a stEnd symbol is the displacement from the
573          corresponding start symbol value.
574          The value of a stBlock symbol is the displacement from the
575          procedure address.  */
576       if (sh->st != stEnd && sh->st != stBlock)
577         sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
578       break;
579     case scData:
580     case scSData:
581     case scRData:
582     case scPData:
583     case scXData:
584       sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
585       break;
586     case scBss:
587     case scSBss:
588       sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
589       break;
590     }
591
592   switch (sh->st)
593     {
594     case stNil:
595       break;
596
597     case stGlobal:              /* External symbol, goes into global block.  */
598       class = LOC_STATIC;
599       b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
600                              GLOBAL_BLOCK);
601       s = new_symbol (name);
602       SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
603       goto data;
604
605     case stStatic:              /* Static data, goes into current block.  */
606       class = LOC_STATIC;
607       b = top_stack->cur_block;
608       s = new_symbol (name);
609       if (SC_IS_COMMON (sh->sc))
610         {
611           /* It is a FORTRAN common block.  At least for SGI Fortran the
612              address is not in the symbol; we need to fix it later in
613              scan_file_globals.  */
614           int bucket = hashname (SYMBOL_LINKAGE_NAME (s));
615           SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
616           global_sym_chain[bucket] = s;
617         }
618       else
619         SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
620       goto data;
621
622     case stLocal:               /* Local variable, goes into current block.  */
623       b = top_stack->cur_block;
624       s = new_symbol (name);
625       SYMBOL_VALUE (s) = svalue;
626       if (sh->sc == scRegister)
627         {
628           class = LOC_REGISTER;
629           SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
630         }
631       else
632         class = LOC_LOCAL;
633
634     data:                       /* Common code for symbols describing data.  */
635       SYMBOL_DOMAIN (s) = VAR_DOMAIN;
636       SYMBOL_CLASS (s) = class;
637       add_symbol (s, top_stack->cur_st, b);
638
639       /* Type could be missing if file is compiled without debugging info.  */
640       if (SC_IS_UNDEF (sh->sc)
641           || sh->sc == scNil || sh->index == indexNil)
642         SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol;
643       else
644         SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
645       /* Value of a data symbol is its memory address.  */
646       break;
647
648     case stParam:               /* Arg to procedure, goes into current
649                                    block.  */
650       max_gdbinfo++;
651       found_ecoff_debugging_info = 1;
652       top_stack->numargs++;
653
654       /* Special GNU C++ name.  */
655       if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0)
656         name = "this";          /* FIXME, not alloc'd in obstack.  */
657       s = new_symbol (name);
658
659       SYMBOL_DOMAIN (s) = VAR_DOMAIN;
660       SYMBOL_IS_ARGUMENT (s) = 1;
661       switch (sh->sc)
662         {
663         case scRegister:
664           /* Pass by value in register.  */
665           SYMBOL_CLASS (s) = LOC_REGISTER;
666           SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
667           break;
668         case scVar:
669           /* Pass by reference on stack.  */
670           SYMBOL_CLASS (s) = LOC_REF_ARG;
671           break;
672         case scVarRegister:
673           /* Pass by reference in register.  */
674           SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
675           SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
676           break;
677         default:
678           /* Pass by value on stack.  */
679           SYMBOL_CLASS (s) = LOC_ARG;
680           break;
681         }
682       SYMBOL_VALUE (s) = svalue;
683       SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
684       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
685       break;
686
687     case stLabel:               /* label, goes into current block.  */
688       s = new_symbol (name);
689       SYMBOL_DOMAIN (s) = VAR_DOMAIN;   /* So that it can be used */
690       SYMBOL_CLASS (s) = LOC_LABEL;     /* but not misused.  */
691       SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
692       SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
693       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
694       break;
695
696     case stProc:        /* Procedure, usually goes into global block.  */
697     case stStaticProc:  /* Static procedure, goes into current block.  */
698       /* For stProc symbol records, we need to check the storage class
699          as well, as only (stProc, scText) entries represent "real"
700          procedures - See the Compaq document titled "Object File /
701          Symbol Table Format Specification" for more information.
702          If the storage class is not scText, we discard the whole block
703          of symbol records for this stProc.  */
704       if (sh->st == stProc && sh->sc != scText)
705         {
706           char *ext_tsym = ext_sh;
707           int keep_counting = 1;
708           SYMR tsym;
709
710           while (keep_counting)
711             {
712               ext_tsym += external_sym_size;
713               (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
714               count++;
715               switch (tsym.st)
716                 {
717                   case stParam:
718                     break;
719                   case stEnd:
720                     keep_counting = 0;
721                     break;
722                   default:
723                     complaint (&symfile_complaints,
724                                _("unknown symbol type 0x%x"), sh->st);
725                     break;
726                 }
727             }
728           break;
729         }
730       s = new_symbol (name);
731       SYMBOL_DOMAIN (s) = VAR_DOMAIN;
732       SYMBOL_CLASS (s) = LOC_BLOCK;
733       /* Type of the return value.  */
734       if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
735         t = objfile_type (objfile)->builtin_int;
736       else
737         {
738           t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
739           if (strcmp (name, "malloc") == 0
740               && TYPE_CODE (t) == TYPE_CODE_VOID)
741             {
742               /* I don't know why, but, at least under Alpha GNU/Linux,
743                  when linking against a malloc without debugging
744                  symbols, its read as a function returning void---this
745                  is bad because it means we cannot call functions with
746                  string arguments interactively; i.e., "call
747                  printf("howdy\n")" would fail with the error message
748                  "program has no memory available".  To avoid this, we
749                  patch up the type and make it void*
750                  instead. (davidm@azstarnet.com).  */
751               t = make_pointer_type (t, NULL);
752             }
753         }
754       b = top_stack->cur_block;
755       if (sh->st == stProc)
756         {
757           struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
758
759           /* The next test should normally be true, but provides a
760              hook for nested functions (which we don't want to make
761              global).  */
762           if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
763             b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
764           /* Irix 5 sometimes has duplicate names for the same
765              function.  We want to add such names up at the global
766              level, not as a nested function.  */
767           else if (sh->value == top_stack->procadr)
768             b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
769         }
770       add_symbol (s, top_stack->cur_st, b);
771
772       /* Make a type for the procedure itself.  */
773       SYMBOL_TYPE (s) = lookup_function_type (t);
774
775       /* All functions in C++ have prototypes.  For C we don't have enough
776          information in the debug info.  */
777       if (SYMBOL_LANGUAGE (s) == language_cplus)
778         TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
779
780       /* Create and enter a new lexical context.  */
781       b = new_block (FUNCTION_BLOCK);
782       SYMBOL_BLOCK_VALUE (s) = b;
783       BLOCK_FUNCTION (b) = s;
784       BLOCK_START (b) = BLOCK_END (b) = sh->value;
785       BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
786       add_block (b, top_stack->cur_st);
787
788       /* Not if we only have partial info.  */
789       if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
790         break;
791
792       push_parse_stack ();
793       top_stack->cur_block = b;
794       top_stack->blocktype = sh->st;
795       top_stack->cur_type = SYMBOL_TYPE (s);
796       top_stack->cur_field = -1;
797       top_stack->procadr = sh->value;
798       top_stack->numargs = 0;
799       break;
800
801       /* Beginning of code for structure, union, and enum definitions.
802          They all share a common set of local variables, defined here.  */
803       {
804         enum type_code type_code;
805         char *ext_tsym;
806         int nfields;
807         long max_value;
808         struct field *f;
809
810     case stStruct:              /* Start a block defining a struct type.  */
811         type_code = TYPE_CODE_STRUCT;
812         goto structured_common;
813
814     case stUnion:               /* Start a block defining a union type.  */
815         type_code = TYPE_CODE_UNION;
816         goto structured_common;
817
818     case stEnum:                /* Start a block defining an enum type.  */
819         type_code = TYPE_CODE_ENUM;
820         goto structured_common;
821
822     case stBlock:               /* Either a lexical block, or some type.  */
823         if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc))
824           goto case_stBlock_code;       /* Lexical block */
825
826         type_code = TYPE_CODE_UNDEF;    /* We have a type.  */
827
828         /* Common code for handling struct, union, enum, and/or as-yet-
829            unknown-type blocks of info about structured data.  `type_code'
830            has been set to the proper TYPE_CODE, if we know it.  */
831       structured_common:
832         found_ecoff_debugging_info = 1;
833         push_parse_stack ();
834         top_stack->blocktype = stBlock;
835
836         /* First count the number of fields and the highest value.  */
837         nfields = 0;
838         max_value = 0;
839         for (ext_tsym = ext_sh + external_sym_size;
840              ;
841              ext_tsym += external_sym_size)
842           {
843             SYMR tsym;
844
845             (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
846
847             switch (tsym.st)
848               {
849               case stEnd:
850                 /* C++ encodes class types as structures where there the
851                    methods are encoded as stProc.  The scope of stProc
852                    symbols also ends with stEnd, thus creating a risk of
853                    taking the wrong stEnd symbol record as the end of
854                    the current struct, which would cause GDB to undercount
855                    the real number of fields in this struct.  To make sure
856                    we really reached the right stEnd symbol record, we
857                    check the associated name, and match it against the
858                    struct name.  Since method names are mangled while
859                    the class name is not, there is no risk of having a
860                    method whose name is identical to the class name
861                    (in particular constructor method names are different
862                    from the class name).  There is therefore no risk that
863                    this check stops the count on the StEnd of a method.
864                    
865                    Also, assume that we're really at the end when tsym.iss
866                    is 0 (issNull).  */
867                 if (tsym.iss == issNull
868                     || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss,
869                                name) == 0)
870                   goto end_of_fields;
871                 break;
872
873               case stMember:
874                 if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
875                   {
876                     /* If the type of the member is Nil (or Void),
877                        without qualifiers, assume the tag is an
878                        enumeration.
879                        Alpha cc -migrate enums are recognized by a zero
880                        index and a zero symbol value.
881                        DU 4.0 cc enums are recognized by a member type of
882                        btEnum without qualifiers and a zero symbol value.  */
883                     if (tsym.index == indexNil
884                         || (tsym.index == 0 && sh->value == 0))
885                       type_code = TYPE_CODE_ENUM;
886                     else
887                       {
888                         (*debug_swap->swap_tir_in) (bigend,
889                                                     &ax[tsym.index].a_ti,
890                                                     &tir);
891                         if ((tir.bt == btNil || tir.bt == btVoid
892                              || (tir.bt == btEnum && sh->value == 0))
893                             && tir.tq0 == tqNil)
894                           type_code = TYPE_CODE_ENUM;
895                       }
896                   }
897                 nfields++;
898                 if (tsym.value > max_value)
899                   max_value = tsym.value;
900                 break;
901
902               case stBlock:
903               case stUnion:
904               case stEnum:
905               case stStruct:
906                 {
907 #if 0
908                   /* This is a no-op; is it trying to tell us something
909                      we should be checking?  */
910                   if (tsym.sc == scVariant);    /*UNIMPLEMENTED */
911 #endif
912                   if (tsym.index != 0)
913                     {
914                       /* This is something like a struct within a
915                          struct.  Skip over the fields of the inner
916                          struct.  The -1 is because the for loop will
917                          increment ext_tsym.  */
918                       ext_tsym = ((char *) debug_info->external_sym
919                                   + ((cur_fdr->isymBase + tsym.index - 1)
920                                      * external_sym_size));
921                     }
922                 }
923                 break;
924
925               case stTypedef:
926                 /* mips cc puts out a typedef for struct x if it is not yet
927                    defined when it encounters
928                    struct y { struct x *xp; };
929                    Just ignore it.  */
930                 break;
931
932               case stIndirect:
933                 /* Irix5 cc puts out a stIndirect for struct x if it is not
934                    yet defined when it encounters
935                    struct y { struct x *xp; };
936                    Just ignore it.  */
937                 break;
938
939               default:
940                 complaint (&symfile_complaints,
941                            _("declaration block contains "
942                              "unhandled symbol type %d"),
943                            tsym.st);
944               }
945           }
946       end_of_fields:
947
948         /* In an stBlock, there is no way to distinguish structs,
949            unions, and enums at this point.  This is a bug in the
950            original design (that has been fixed with the recent
951            addition of the stStruct, stUnion, and stEnum symbol
952            types.)  The way you can tell is if/when you see a variable
953            or field of that type.  In that case the variable's type
954            (in the AUX table) says if the type is struct, union, or
955            enum, and points back to the stBlock here.  So you can
956            patch the tag kind up later - but only if there actually is
957            a variable or field of that type.
958
959            So until we know for sure, we will guess at this point.
960            The heuristic is:
961            If the first member has index==indexNil or a void type,
962            assume we have an enumeration.
963            Otherwise, if there is more than one member, and all
964            the members have offset 0, assume we have a union.
965            Otherwise, assume we have a struct.
966
967            The heuristic could guess wrong in the case of of an
968            enumeration with no members or a union with one (or zero)
969            members, or when all except the last field of a struct have
970            width zero.  These are uncommon and/or illegal situations,
971            and in any case guessing wrong probably doesn't matter
972            much.
973
974            But if we later do find out we were wrong, we fixup the tag
975            kind.  Members of an enumeration must be handled
976            differently from struct/union fields, and that is harder to
977            patch up, but luckily we shouldn't need to.  (If there are
978            any enumeration members, we can tell for sure it's an enum
979            here.)  */
980
981         if (type_code == TYPE_CODE_UNDEF)
982           {
983             if (nfields > 1 && max_value == 0)
984               type_code = TYPE_CODE_UNION;
985             else
986               type_code = TYPE_CODE_STRUCT;
987           }
988
989         /* Create a new type or use the pending type.  */
990         pend = is_pending_symbol (cur_fdr, ext_sh);
991         if (pend == (struct mdebug_pending *) NULL)
992           {
993             t = new_type (NULL);
994             add_pending (cur_fdr, ext_sh, t);
995           }
996         else
997           t = pend->t;
998
999         /* Do not set the tag name if it is a compiler generated tag name
1000            (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
1001            Alpha cc puts out an sh->iss of zero for those.  */
1002         if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
1003           TYPE_TAG_NAME (t) = NULL;
1004         else
1005           TYPE_TAG_NAME (t) = obconcat (&current_objfile->objfile_obstack,
1006                                         name, (char *) NULL);
1007
1008         TYPE_CODE (t) = type_code;
1009         TYPE_LENGTH (t) = sh->value;
1010         TYPE_NFIELDS (t) = nfields;
1011         TYPE_FIELDS (t) = f = ((struct field *)
1012                                TYPE_ALLOC (t,
1013                                            nfields * sizeof (struct field)));
1014
1015         if (type_code == TYPE_CODE_ENUM)
1016           {
1017             int unsigned_enum = 1;
1018
1019             /* This is a non-empty enum.  */
1020
1021             /* DEC c89 has the number of enumerators in the sh.value field,
1022                not the type length, so we have to compensate for that
1023                incompatibility quirk.
1024                This might do the wrong thing for an enum with one or two
1025                enumerators and gcc -gcoff -fshort-enums, but these cases
1026                are hopefully rare enough.
1027                Alpha cc -migrate has a sh.value field of zero, we adjust
1028                that too.  */
1029             if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
1030                 || TYPE_LENGTH (t) == 0)
1031               TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
1032             for (ext_tsym = ext_sh + external_sym_size;
1033                  ;
1034                  ext_tsym += external_sym_size)
1035               {
1036                 SYMR tsym;
1037                 struct symbol *enum_sym;
1038
1039                 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
1040
1041                 if (tsym.st != stMember)
1042                   break;
1043
1044                 SET_FIELD_BITPOS (*f, tsym.value);
1045                 FIELD_TYPE (*f) = t;
1046                 FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
1047                 FIELD_BITSIZE (*f) = 0;
1048
1049                 enum_sym = ((struct symbol *)
1050                             obstack_alloc (&current_objfile->objfile_obstack,
1051                                            sizeof (struct symbol)));
1052                 memset (enum_sym, 0, sizeof (struct symbol));
1053                 SYMBOL_SET_LINKAGE_NAME
1054                   (enum_sym, obsavestring (f->name, strlen (f->name),
1055                                            &current_objfile->objfile_obstack));
1056                 SYMBOL_CLASS (enum_sym) = LOC_CONST;
1057                 SYMBOL_TYPE (enum_sym) = t;
1058                 SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
1059                 SYMBOL_VALUE (enum_sym) = tsym.value;
1060                 if (SYMBOL_VALUE (enum_sym) < 0)
1061                   unsigned_enum = 0;
1062                 add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block);
1063
1064                 /* Skip the stMembers that we've handled.  */
1065                 count++;
1066                 f++;
1067               }
1068             if (unsigned_enum)
1069               TYPE_UNSIGNED (t) = 1;
1070           }
1071         /* Make this the current type.  */
1072         top_stack->cur_type = t;
1073         top_stack->cur_field = 0;
1074
1075         /* Do not create a symbol for alpha cc unnamed structs.  */
1076         if (sh->iss == 0)
1077           break;
1078
1079         /* gcc puts out an empty struct for an opaque struct definitions,
1080            do not create a symbol for it either.  */
1081         if (TYPE_NFIELDS (t) == 0)
1082           {
1083             TYPE_STUB (t) = 1;
1084             break;
1085           }
1086
1087         s = new_symbol (name);
1088         SYMBOL_DOMAIN (s) = STRUCT_DOMAIN;
1089         SYMBOL_CLASS (s) = LOC_TYPEDEF;
1090         SYMBOL_VALUE (s) = 0;
1091         SYMBOL_TYPE (s) = t;
1092         add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1093         break;
1094
1095         /* End of local variables shared by struct, union, enum, and
1096            block (as yet unknown struct/union/enum) processing.  */
1097       }
1098
1099     case_stBlock_code:
1100       found_ecoff_debugging_info = 1;
1101       /* Beginnning of (code) block.  Value of symbol
1102          is the displacement from procedure start.  */
1103       push_parse_stack ();
1104
1105       /* Do not start a new block if this is the outermost block of a
1106          procedure.  This allows the LOC_BLOCK symbol to point to the
1107          block with the local variables, so funcname::var works.  */
1108       if (top_stack->blocktype == stProc
1109           || top_stack->blocktype == stStaticProc)
1110         {
1111           top_stack->blocktype = stNil;
1112           break;
1113         }
1114
1115       top_stack->blocktype = stBlock;
1116       b = new_block (NON_FUNCTION_BLOCK);
1117       BLOCK_START (b) = sh->value + top_stack->procadr;
1118       BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1119       top_stack->cur_block = b;
1120       add_block (b, top_stack->cur_st);
1121       break;
1122
1123     case stEnd:         /* end (of anything) */
1124       if (sh->sc == scInfo || SC_IS_COMMON (sh->sc))
1125         {
1126           /* Finished with type */
1127           top_stack->cur_type = 0;
1128         }
1129       else if (sh->sc == scText &&
1130                (top_stack->blocktype == stProc ||
1131                 top_stack->blocktype == stStaticProc))
1132         {
1133           /* Finished with procedure */
1134           struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
1135           struct mdebug_extra_func_info *e;
1136           struct block *b = top_stack->cur_block;
1137           struct type *ftype = top_stack->cur_type;
1138           int i;
1139
1140           BLOCK_END (top_stack->cur_block) += sh->value;        /* size */
1141
1142           /* Make up special symbol to contain procedure specific info.  */
1143           s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
1144           SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
1145           SYMBOL_CLASS (s) = LOC_CONST;
1146           SYMBOL_TYPE (s) = objfile_type (current_objfile)->builtin_void;
1147           e = ((struct mdebug_extra_func_info *)
1148                obstack_alloc (&current_objfile->objfile_obstack,
1149                               sizeof (struct mdebug_extra_func_info)));
1150           memset (e, 0, sizeof (struct mdebug_extra_func_info));
1151           SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
1152           e->numargs = top_stack->numargs;
1153           e->pdr.framereg = -1;
1154           add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1155
1156           /* f77 emits proc-level with address bounds==[0,0],
1157              So look for such child blocks, and patch them.  */
1158           for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
1159             {
1160               struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
1161
1162               if (BLOCK_SUPERBLOCK (b_bad) == b
1163                   && BLOCK_START (b_bad) == top_stack->procadr
1164                   && BLOCK_END (b_bad) == top_stack->procadr)
1165                 {
1166                   BLOCK_START (b_bad) = BLOCK_START (b);
1167                   BLOCK_END (b_bad) = BLOCK_END (b);
1168                 }
1169             }
1170
1171           if (TYPE_NFIELDS (ftype) <= 0)
1172             {
1173               /* No parameter type information is recorded with the function's
1174                  type.  Set that from the type of the parameter symbols.  */
1175               int nparams = top_stack->numargs;
1176               int iparams;
1177               struct symbol *sym;
1178
1179               if (nparams > 0)
1180                 {
1181                   struct dict_iterator iter;
1182
1183                   TYPE_NFIELDS (ftype) = nparams;
1184                   TYPE_FIELDS (ftype) = (struct field *)
1185                     TYPE_ALLOC (ftype, nparams * sizeof (struct field));
1186
1187                   iparams = 0;
1188                   ALL_BLOCK_SYMBOLS (b, iter, sym)
1189                     {
1190                       if (iparams == nparams)
1191                         break;
1192
1193                       if (SYMBOL_IS_ARGUMENT (sym))
1194                         {
1195                           TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
1196                           TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
1197                           iparams++;
1198                         }
1199                     }
1200                 }
1201             }
1202         }
1203       else if (sh->sc == scText && top_stack->blocktype == stBlock)
1204         {
1205           /* End of (code) block.  The value of the symbol is the
1206              displacement from the procedure`s start address of the
1207              end of this block.  */
1208           BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
1209         }
1210       else if (sh->sc == scText && top_stack->blocktype == stNil)
1211         {
1212           /* End of outermost block.  Pop parse stack and ignore.  The
1213              following stEnd of stProc will take care of the block.  */
1214           ;
1215         }
1216       else if (sh->sc == scText && top_stack->blocktype == stFile)
1217         {
1218           /* End of file.  Pop parse stack and ignore.  Higher
1219              level code deals with this.  */
1220           ;
1221         }
1222       else
1223         complaint (&symfile_complaints,
1224                    _("stEnd with storage class %d not handled"), sh->sc);
1225
1226       pop_parse_stack ();       /* Restore previous lexical context.  */
1227       break;
1228
1229     case stMember:              /* member of struct or union */
1230       f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
1231       FIELD_NAME (*f) = name;
1232       SET_FIELD_BITPOS (*f, sh->value);
1233       bitsize = 0;
1234       FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index,
1235                                     &bitsize, bigend, name);
1236       FIELD_BITSIZE (*f) = bitsize;
1237       break;
1238
1239     case stIndirect:            /* forward declaration on Irix5 */
1240       /* Forward declarations from Irix5 cc are handled by cross_ref,
1241          skip them.  */
1242       break;
1243
1244     case stTypedef:             /* type definition */
1245       found_ecoff_debugging_info = 1;
1246
1247       /* Typedefs for forward declarations and opaque structs from alpha cc
1248          are handled by cross_ref, skip them.  */
1249       if (sh->iss == 0)
1250         break;
1251
1252       /* Parse the type or use the pending type.  */
1253       pend = is_pending_symbol (cur_fdr, ext_sh);
1254       if (pend == (struct mdebug_pending *) NULL)
1255         {
1256           t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name);
1257           add_pending (cur_fdr, ext_sh, t);
1258         }
1259       else
1260         t = pend->t;
1261
1262       /* Mips cc puts out a typedef with the name of the struct for forward
1263          declarations.  These should not go into the symbol table and
1264          TYPE_NAME should not be set for them.
1265          They can't be distinguished from an intentional typedef to
1266          the same name however:
1267          x.h:
1268          struct x { int ix; int jx; };
1269          struct xx;
1270          x.c:
1271          typedef struct x x;
1272          struct xx {int ixx; int jxx; };
1273          generates a cross referencing stTypedef for x and xx.
1274          The user visible effect of this is that the type of a pointer
1275          to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1276          The problem is fixed with alpha cc and Irix5 cc.  */
1277
1278       /* However if the typedef cross references to an opaque aggregate, it
1279          is safe to omit it from the symbol table.  */
1280
1281       if (has_opaque_xref (cur_fdr, sh))
1282         break;
1283       s = new_symbol (name);
1284       SYMBOL_DOMAIN (s) = VAR_DOMAIN;
1285       SYMBOL_CLASS (s) = LOC_TYPEDEF;
1286       SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
1287       SYMBOL_TYPE (s) = t;
1288       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1289
1290       /* Incomplete definitions of structs should not get a name.  */
1291       if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
1292           && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0
1293               || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT
1294                   && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION)))
1295         {
1296           if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR
1297               || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC)
1298             {
1299               /* If we are giving a name to a type such as "pointer to
1300                  foo" or "function returning foo", we better not set
1301                  the TYPE_NAME.  If the program contains "typedef char
1302                  *caddr_t;", we don't want all variables of type char
1303                  * to print as caddr_t.  This is not just a
1304                  consequence of GDB's type management; CC and GCC (at
1305                  least through version 2.4) both output variables of
1306                  either type char * or caddr_t with the type
1307                  refering to the stTypedef symbol for caddr_t.  If a future
1308                  compiler cleans this up it GDB is not ready for it
1309                  yet, but if it becomes ready we somehow need to
1310                  disable this check (without breaking the PCC/GCC2.4
1311                  case).
1312
1313                  Sigh.
1314
1315                  Fortunately, this check seems not to be necessary
1316                  for anything except pointers or functions.  */
1317             }
1318           else
1319             TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s);
1320         }
1321       break;
1322
1323     case stFile:                /* file name */
1324       push_parse_stack ();
1325       top_stack->blocktype = sh->st;
1326       break;
1327
1328       /* I`ve never seen these for C */
1329     case stRegReloc:
1330       break;                    /* register relocation */
1331     case stForward:
1332       break;                    /* forwarding address */
1333     case stConstant:
1334       break;                    /* constant */
1335     default:
1336       complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
1337       break;
1338     }
1339
1340   return count;
1341 }
1342
1343 /* Basic types.  */
1344
1345 static const struct objfile_data *basic_type_data;
1346
1347 static struct type *
1348 basic_type (int bt, struct objfile *objfile)
1349 {
1350   struct gdbarch *gdbarch = get_objfile_arch (objfile);
1351   struct type **map_bt = objfile_data (objfile, basic_type_data);
1352   struct type *tp;
1353
1354   if (bt >= btMax)
1355     return NULL;
1356
1357   if (!map_bt)
1358     {
1359       map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack,
1360                                btMax, struct type *);
1361       set_objfile_data (objfile, basic_type_data, map_bt);
1362     }
1363
1364   if (map_bt[bt])
1365     return map_bt[bt];
1366
1367   switch (bt)
1368     {
1369     case btNil:
1370       tp = objfile_type (objfile)->builtin_void;
1371       break;
1372
1373     case btAdr:
1374       tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED,
1375                       "adr_32", objfile);
1376       TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
1377       break;
1378
1379     case btChar:
1380       tp = init_type (TYPE_CODE_INT, 1, 0,
1381                       "char", objfile);
1382       break;
1383
1384     case btUChar:
1385       tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
1386                       "unsigned char", objfile);
1387       break;
1388
1389     case btShort:
1390       tp = init_type (TYPE_CODE_INT, 2, 0,
1391                       "short", objfile);
1392       break;
1393
1394     case btUShort:
1395       tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
1396                       "unsigned short", objfile);
1397       break;
1398
1399     case btInt:
1400       tp = init_type (TYPE_CODE_INT, 4, 0,
1401                       "int", objfile);
1402       break;
1403
1404    case btUInt:
1405       tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1406                       "unsigned int", objfile);
1407       break;
1408
1409     case btLong:
1410       tp = init_type (TYPE_CODE_INT, 4, 0,
1411                       "long", objfile);
1412       break;
1413
1414     case btULong:
1415       tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1416                       "unsigned long", objfile);
1417       break;
1418
1419     case btFloat:
1420       tp = init_type (TYPE_CODE_FLT,
1421                       gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1422                       "float", objfile);
1423       break;
1424
1425     case btDouble:
1426       tp = init_type (TYPE_CODE_FLT,
1427                       gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1428                       "double", objfile);
1429       break;
1430
1431     case btComplex:
1432       tp = init_type (TYPE_CODE_COMPLEX,
1433                       2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1434                       "complex", objfile);
1435       TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile);
1436       break;
1437
1438     case btDComplex:
1439       tp = init_type (TYPE_CODE_COMPLEX,
1440                       2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1441                       "double complex", objfile);
1442       TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile);
1443       break;
1444
1445     case btFixedDec:
1446       /* We use TYPE_CODE_INT to print these as integers.  Does this do any
1447          good?  Would we be better off with TYPE_CODE_ERROR?  Should
1448          TYPE_CODE_ERROR print things in hex if it knows the size?  */
1449       tp = init_type (TYPE_CODE_INT,
1450                       gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1451                       "fixed decimal", objfile);
1452       break;
1453
1454     case btFloatDec:
1455       tp = init_type (TYPE_CODE_ERROR,
1456                       gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1457                       "floating decimal", objfile);
1458       break;
1459
1460     case btString:
1461       /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
1462          FIXME.  */
1463       tp = init_type (TYPE_CODE_STRING, 1, 0,
1464                       "string", objfile);
1465       break;
1466
1467     case btVoid:
1468       tp = objfile_type (objfile)->builtin_void;
1469       break;
1470
1471     case btLong64:
1472       tp = init_type (TYPE_CODE_INT, 8, 0,
1473                       "long", objfile);
1474       break;
1475
1476     case btULong64:
1477       tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1478                       "unsigned long", objfile);
1479       break;
1480
1481     case btLongLong64:
1482       tp = init_type (TYPE_CODE_INT, 8, 0,
1483                       "long long", objfile);
1484       break;
1485
1486     case btULongLong64:
1487       tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1488                       "unsigned long long", objfile);
1489       break;
1490
1491     case btAdr64:
1492       tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED,
1493                       "adr_64", objfile);
1494       TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
1495       break;
1496
1497     case btInt64:
1498       tp = init_type (TYPE_CODE_INT, 8, 0,
1499                       "int", objfile);
1500       break;
1501
1502     case btUInt64:
1503       tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1504                       "unsigned int", objfile);
1505       break;
1506
1507     default:
1508       tp = NULL;
1509       break;
1510     }
1511
1512   map_bt[bt] = tp;
1513   return tp;
1514 }
1515
1516 /* Parse the type information provided in the raw AX entries for
1517    the symbol SH.  Return the bitfield size in BS, in case.
1518    We must byte-swap the AX entries before we use them; BIGEND says whether
1519    they are big-endian or little-endian (from fh->fBigendian).  */
1520
1521 static struct type *
1522 parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
1523             int bigend, char *sym_name)
1524 {
1525   TIR t[1];
1526   struct type *tp = 0;
1527   enum type_code type_code = TYPE_CODE_UNDEF;
1528
1529   /* Handle undefined types, they have indexNil.  */
1530   if (aux_index == indexNil)
1531     return basic_type (btInt, current_objfile);
1532
1533   /* Handle corrupt aux indices.  */
1534   if (aux_index >= (debug_info->fdr + fd)->caux)
1535     {
1536       index_complaint (sym_name);
1537       return basic_type (btInt, current_objfile);
1538     }
1539   ax += aux_index;
1540
1541   /* Use aux as a type information record, map its basic type.  */
1542   (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1543   tp = basic_type (t->bt, current_objfile);
1544   if (tp == NULL)
1545     {
1546       /* Cannot use builtin types -- build our own.  */
1547       switch (t->bt)
1548         {
1549         case btStruct:
1550           type_code = TYPE_CODE_STRUCT;
1551           break;
1552         case btUnion:
1553           type_code = TYPE_CODE_UNION;
1554           break;
1555         case btEnum:
1556           type_code = TYPE_CODE_ENUM;
1557           break;
1558         case btRange:
1559           type_code = TYPE_CODE_RANGE;
1560           break;
1561         case btSet:
1562           type_code = TYPE_CODE_SET;
1563           break;
1564         case btIndirect:
1565           /* alpha cc -migrate uses this for typedefs.  The true type will
1566              be obtained by crossreferencing below.  */
1567           type_code = TYPE_CODE_ERROR;
1568           break;
1569         case btTypedef:
1570           /* alpha cc uses this for typedefs.  The true type will be
1571              obtained by crossreferencing below.  */
1572           type_code = TYPE_CODE_ERROR;
1573           break;
1574         default:
1575           basic_type_complaint (t->bt, sym_name);
1576           return basic_type (btInt, current_objfile);
1577         }
1578     }
1579
1580   /* Move on to next aux.  */
1581   ax++;
1582
1583   if (t->fBitfield)
1584     {
1585       int width = AUX_GET_WIDTH (bigend, ax);
1586
1587       /* Inhibit core dumps if TIR is corrupted.  */
1588       if (bs == (int *) NULL)
1589         {
1590           /* Alpha cc -migrate encodes char and unsigned char types
1591              as short and unsigned short types with a field width of 8.
1592              Enum types also have a field width which we ignore for now.  */
1593           if (t->bt == btShort && width == 8)
1594             tp = basic_type (btChar, current_objfile);
1595           else if (t->bt == btUShort && width == 8)
1596             tp = basic_type (btUChar, current_objfile);
1597           else if (t->bt == btEnum)
1598             ;
1599           else
1600             complaint (&symfile_complaints,
1601                        _("can't handle TIR fBitfield for %s"),
1602                        sym_name);
1603         }
1604       else
1605         *bs = width;
1606       ax++;
1607     }
1608
1609   /* A btIndirect entry cross references to an aux entry containing
1610      the type.  */
1611   if (t->bt == btIndirect)
1612     {
1613       RNDXR rn[1];
1614       int rf;
1615       FDR *xref_fh;
1616       int xref_fd;
1617
1618       (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
1619       ax++;
1620       if (rn->rfd == 0xfff)
1621         {
1622           rf = AUX_GET_ISYM (bigend, ax);
1623           ax++;
1624         }
1625       else
1626         rf = rn->rfd;
1627
1628       if (rf == -1)
1629         {
1630           complaint (&symfile_complaints,
1631                      _("unable to cross ref btIndirect for %s"), sym_name);
1632           return basic_type (btInt, current_objfile);
1633         }
1634       xref_fh = get_rfd (fd, rf);
1635       xref_fd = xref_fh - debug_info->fdr;
1636       tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase,
1637                     rn->index, (int *) NULL, xref_fh->fBigendian, sym_name);
1638     }
1639
1640   /* All these types really point to some (common) MIPS type
1641      definition, and only the type-qualifiers fully identify
1642      them.  We'll make the same effort at sharing.  */
1643   if (t->bt == btStruct ||
1644       t->bt == btUnion ||
1645       t->bt == btEnum ||
1646
1647   /* btSet (I think) implies that the name is a tag name, not a typedef
1648      name.  This apparently is a MIPS extension for C sets.  */
1649       t->bt == btSet)
1650     {
1651       char *name;
1652
1653       /* Try to cross reference this type, build new type on failure.  */
1654       ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1655       if (tp == (struct type *) NULL)
1656         tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1657
1658       /* DEC c89 produces cross references to qualified aggregate types,
1659          dereference them.  */
1660       while (TYPE_CODE (tp) == TYPE_CODE_PTR
1661              || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
1662         tp = TYPE_TARGET_TYPE (tp);
1663
1664       /* Make sure that TYPE_CODE(tp) has an expected type code.
1665          Any type may be returned from cross_ref if file indirect entries
1666          are corrupted.  */
1667       if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
1668           && TYPE_CODE (tp) != TYPE_CODE_UNION
1669           && TYPE_CODE (tp) != TYPE_CODE_ENUM)
1670         {
1671           unexpected_type_code_complaint (sym_name);
1672         }
1673       else
1674         {
1675           /* Usually, TYPE_CODE(tp) is already type_code.  The main
1676              exception is if we guessed wrong re struct/union/enum.
1677              But for struct vs. union a wrong guess is harmless, so
1678              don't complain().  */
1679           if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
1680                && type_code != TYPE_CODE_ENUM)
1681               || (TYPE_CODE (tp) != TYPE_CODE_ENUM
1682                   && type_code == TYPE_CODE_ENUM))
1683             {
1684               bad_tag_guess_complaint (sym_name);
1685             }
1686
1687           if (TYPE_CODE (tp) != type_code)
1688             {
1689               TYPE_CODE (tp) = type_code;
1690             }
1691
1692           /* Do not set the tag name if it is a compiler generated tag name
1693              (.Fxx or .xxfake or empty) for unnamed struct/union/enums.  */
1694           if (name[0] == '.' || name[0] == '\0')
1695             TYPE_TAG_NAME (tp) = NULL;
1696           else if (TYPE_TAG_NAME (tp) == NULL
1697                    || strcmp (TYPE_TAG_NAME (tp), name) != 0)
1698             TYPE_TAG_NAME (tp)
1699               = obsavestring (name, strlen (name),
1700                               &current_objfile->objfile_obstack);
1701         }
1702     }
1703
1704   /* All these types really point to some (common) MIPS type
1705      definition, and only the type-qualifiers fully identify
1706      them.  We'll make the same effort at sharing.
1707      FIXME: We are not doing any guessing on range types.  */
1708   if (t->bt == btRange)
1709     {
1710       char *name;
1711
1712       /* Try to cross reference this type, build new type on failure.  */
1713       ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1714       if (tp == (struct type *) NULL)
1715         tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1716
1717       /* Make sure that TYPE_CODE(tp) has an expected type code.
1718          Any type may be returned from cross_ref if file indirect entries
1719          are corrupted.  */
1720       if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
1721         {
1722           unexpected_type_code_complaint (sym_name);
1723         }
1724       else
1725         {
1726           /* Usually, TYPE_CODE(tp) is already type_code.  The main
1727              exception is if we guessed wrong re struct/union/enum.  */
1728           if (TYPE_CODE (tp) != type_code)
1729             {
1730               bad_tag_guess_complaint (sym_name);
1731               TYPE_CODE (tp) = type_code;
1732             }
1733           if (TYPE_NAME (tp) == NULL
1734               || strcmp (TYPE_NAME (tp), name) != 0)
1735             TYPE_NAME (tp) = obsavestring (name, strlen (name),
1736                                            &current_objfile->objfile_obstack);
1737         }
1738     }
1739   if (t->bt == btTypedef)
1740     {
1741       char *name;
1742
1743       /* Try to cross reference this type, it should succeed.  */
1744       ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1745       if (tp == (struct type *) NULL)
1746         {
1747           complaint (&symfile_complaints,
1748                      _("unable to cross ref btTypedef for %s"), sym_name);
1749           tp = basic_type (btInt, current_objfile);
1750         }
1751     }
1752
1753   /* Deal with range types.  */
1754   if (t->bt == btRange)
1755     {
1756       TYPE_NFIELDS (tp) = 0;
1757       TYPE_RANGE_DATA (tp) = ((struct range_bounds *)
1758                           TYPE_ZALLOC (tp, sizeof (struct range_bounds)));
1759       TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
1760       ax++;
1761       TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
1762       ax++;
1763     }
1764
1765   /* Parse all the type qualifiers now.  If there are more
1766      than 6 the game will continue in the next aux.  */
1767
1768   while (1)
1769     {
1770 #define PARSE_TQ(tq) \
1771       if (t->tq != tqNil) \
1772         ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1773       else \
1774         break;
1775
1776       PARSE_TQ (tq0);
1777       PARSE_TQ (tq1);
1778       PARSE_TQ (tq2);
1779       PARSE_TQ (tq3);
1780       PARSE_TQ (tq4);
1781       PARSE_TQ (tq5);
1782 #undef  PARSE_TQ
1783
1784       /* mips cc 2.x and gcc never put out continued aux entries.  */
1785       if (!t->continued)
1786         break;
1787
1788       (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1789       ax++;
1790     }
1791
1792   /* Complain for illegal continuations due to corrupt aux entries.  */
1793   if (t->continued)
1794     complaint (&symfile_complaints,
1795                _("illegal TIR continued for %s"), sym_name);
1796
1797   return tp;
1798 }
1799
1800 /* Make up a complex type from a basic one.  Type is passed by
1801    reference in TPP and side-effected as necessary.  The type
1802    qualifier TQ says how to handle the aux symbols at AX for
1803    the symbol SX we are currently analyzing.  BIGEND says whether
1804    aux symbols are big-endian or little-endian.
1805    Returns the number of aux symbols we parsed.  */
1806
1807 static int
1808 upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
1809               char *sym_name)
1810 {
1811   int off;
1812   struct type *t;
1813
1814   /* Used in array processing.  */
1815   int rf, id;
1816   FDR *fh;
1817   struct type *range;
1818   struct type *indx;
1819   int lower, upper;
1820   RNDXR rndx;
1821
1822   switch (tq)
1823     {
1824     case tqPtr:
1825       t = lookup_pointer_type (*tpp);
1826       *tpp = t;
1827       return 0;
1828
1829     case tqProc:
1830       t = lookup_function_type (*tpp);
1831       *tpp = t;
1832       return 0;
1833
1834     case tqArray:
1835       off = 0;
1836
1837       /* Determine and record the domain type (type of index).  */
1838       (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx);
1839       id = rndx.index;
1840       rf = rndx.rfd;
1841       if (rf == 0xfff)
1842         {
1843           ax++;
1844           rf = AUX_GET_ISYM (bigend, ax);
1845           off++;
1846         }
1847       fh = get_rfd (fd, rf);
1848
1849       indx = parse_type (fh - debug_info->fdr,
1850                          debug_info->external_aux + fh->iauxBase,
1851                          id, (int *) NULL, bigend, sym_name);
1852
1853       /* The bounds type should be an integer type, but might be anything
1854          else due to corrupt aux entries.  */
1855       if (TYPE_CODE (indx) != TYPE_CODE_INT)
1856         {
1857           complaint (&symfile_complaints,
1858                      _("illegal array index type for %s, assuming int"),
1859                      sym_name);
1860           indx = objfile_type (current_objfile)->builtin_int;
1861         }
1862
1863       /* Get the bounds, and create the array type.  */
1864       ax++;
1865       lower = AUX_GET_DNLOW (bigend, ax);
1866       ax++;
1867       upper = AUX_GET_DNHIGH (bigend, ax);
1868       ax++;
1869       rf = AUX_GET_WIDTH (bigend, ax);  /* bit size of array element */
1870
1871       range = create_range_type ((struct type *) NULL, indx,
1872                                  lower, upper);
1873
1874       t = create_array_type ((struct type *) NULL, *tpp, range);
1875
1876       /* We used to fill in the supplied array element bitsize
1877          here if the TYPE_LENGTH of the target type was zero.
1878          This happens for a `pointer to an array of anonymous structs',
1879          but in this case the array element bitsize is also zero,
1880          so nothing is gained.
1881          And we used to check the TYPE_LENGTH of the target type against
1882          the supplied array element bitsize.
1883          gcc causes a mismatch for `pointer to array of object',
1884          since the sdb directives it uses do not have a way of
1885          specifying the bitsize, but it does no harm (the
1886          TYPE_LENGTH should be correct) and we should be able to
1887          ignore the erroneous bitsize from the auxiliary entry safely.
1888          dbx seems to ignore it too.  */
1889
1890       /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem.  */
1891       if (TYPE_LENGTH (*tpp) == 0)
1892         TYPE_TARGET_STUB (t) = 1;
1893
1894       *tpp = t;
1895       return 4 + off;
1896
1897     case tqVol:
1898       /* Volatile -- currently ignored */
1899       return 0;
1900
1901     case tqConst:
1902       /* Const -- currently ignored */
1903       return 0;
1904
1905     default:
1906       complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
1907       return 0;
1908     }
1909 }
1910
1911
1912 /* Parse a procedure descriptor record PR.  Note that the procedure is
1913    parsed _after_ the local symbols, now we just insert the extra
1914    information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1915    already been placed in the procedure's main block.  Note also that
1916    images that have been partially stripped (ld -x) have been deprived
1917    of local symbols, and we have to cope with them here.  FIRST_OFF is
1918    the offset of the first procedure for this FDR; we adjust the
1919    address by this amount, but I don't know why.  SEARCH_SYMTAB is the symtab
1920    to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1921    in question, or NULL to use top_stack->cur_block.  */
1922
1923 static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *);
1924
1925 static void
1926 parse_procedure (PDR *pr, struct symtab *search_symtab,
1927                  struct partial_symtab *pst)
1928 {
1929   struct symbol *s, *i;
1930   struct block *b;
1931   char *sh_name;
1932
1933   /* Simple rule to find files linked "-x".  */
1934   if (cur_fdr->rss == -1)
1935     {
1936       if (pr->isym == -1)
1937         {
1938           /* Static procedure at address pr->adr.  Sigh.  */
1939           /* FIXME-32x64.  assuming pr->adr fits in long.  */
1940           complaint (&symfile_complaints,
1941                      _("can't handle PDR for static proc at 0x%lx"),
1942                      (unsigned long) pr->adr);
1943           return;
1944         }
1945       else
1946         {
1947           /* external */
1948           EXTR she;
1949
1950           (*debug_swap->swap_ext_in) (cur_bfd,
1951                                       ((char *) debug_info->external_ext
1952                                        + (pr->isym
1953                                           * debug_swap->external_ext_size)),
1954                                       &she);
1955           sh_name = debug_info->ssext + she.asym.iss;
1956         }
1957     }
1958   else
1959     {
1960       /* Full symbols */
1961       SYMR sh;
1962
1963       (*debug_swap->swap_sym_in) (cur_bfd,
1964                                   ((char *) debug_info->external_sym
1965                                    + ((cur_fdr->isymBase + pr->isym)
1966                                       * debug_swap->external_sym_size)),
1967                                   &sh);
1968       sh_name = debug_info->ss + cur_fdr->issBase + sh.iss;
1969     }
1970
1971   if (search_symtab != NULL)
1972     {
1973 #if 0
1974       /* This loses both in the case mentioned (want a static, find a global),
1975          but also if we are looking up a non-mangled name which happens to
1976          match the name of a mangled function.  */
1977       /* We have to save the cur_fdr across the call to lookup_symbol.
1978          If the pdr is for a static function and if a global function with
1979          the same name exists, lookup_symbol will eventually read in the symtab
1980          for the global function and clobber cur_fdr.  */
1981       FDR *save_cur_fdr = cur_fdr;
1982
1983       s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
1984       cur_fdr = save_cur_fdr;
1985 #else
1986       s = mylookup_symbol
1987         (sh_name,
1988          BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
1989          VAR_DOMAIN,
1990          LOC_BLOCK);
1991 #endif
1992     }
1993   else
1994     s = mylookup_symbol (sh_name, top_stack->cur_block,
1995                          VAR_DOMAIN, LOC_BLOCK);
1996
1997   if (s != 0)
1998     {
1999       b = SYMBOL_BLOCK_VALUE (s);
2000     }
2001   else
2002     {
2003       complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
2004 #if 1
2005       return;
2006 #else
2007 /* FIXME -- delete.  We can't do symbol allocation now; it's all done.  */
2008       s = new_symbol (sh_name);
2009       SYMBOL_DOMAIN (s) = VAR_DOMAIN;
2010       SYMBOL_CLASS (s) = LOC_BLOCK;
2011       /* Donno its type, hope int is ok.  */
2012       SYMBOL_TYPE (s)
2013         = lookup_function_type (objfile_type (pst->objfile)->builtin_int);
2014       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
2015       /* Won't have symbols for this one.  */
2016       b = new_block (2);
2017       SYMBOL_BLOCK_VALUE (s) = b;
2018       BLOCK_FUNCTION (b) = s;
2019       BLOCK_START (b) = pr->adr;
2020       /* BOUND used to be the end of procedure's text, but the
2021          argument is no longer passed in.  */
2022       BLOCK_END (b) = bound;
2023       BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
2024       add_block (b, top_stack->cur_st);
2025 #endif
2026     }
2027
2028   i = mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST);
2029
2030   if (i)
2031     {
2032       struct mdebug_extra_func_info *e;
2033       
2034       e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i);
2035       e->pdr = *pr;
2036
2037       /* GDB expects the absolute function start address for the
2038          procedure descriptor in e->pdr.adr.
2039          As the address in the procedure descriptor is usually relative,
2040          we would have to relocate e->pdr.adr with cur_fdr->adr and
2041          ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
2042          Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2043          in shared libraries on some systems, and on other systems
2044          e->pdr.adr is sometimes offset by a bogus value.
2045          To work around these problems, we replace e->pdr.adr with
2046          the start address of the function.  */
2047       e->pdr.adr = BLOCK_START (b);
2048     }
2049
2050   /* It would be reasonable that functions that have been compiled
2051      without debugging info have a btNil type for their return value,
2052      and functions that are void and are compiled with debugging info
2053      have btVoid.
2054      gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2055      to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2056      case right.
2057      The glevel field in cur_fdr could be used to determine the presence
2058      of debugging info, but GCC doesn't always pass the -g switch settings
2059      to the assembler and GAS doesn't set the glevel field from the -g switch
2060      settings.
2061      To work around these problems, the return value type of a TYPE_CODE_VOID
2062      function is adjusted accordingly if no debugging info was found in the
2063      compilation unit.  */
2064
2065   if (processing_gcc_compilation == 0
2066       && found_ecoff_debugging_info == 0
2067       && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
2068     SYMBOL_TYPE (s) = objfile_type (pst->objfile)->nodebug_text_symbol;
2069 }
2070
2071 /* Parse the external symbol ES.  Just call parse_symbol() after
2072    making sure we know where the aux are for it.
2073    BIGEND says whether aux entries are big-endian or little-endian.
2074
2075    This routine clobbers top_stack->cur_block and ->cur_st.  */
2076
2077 static void parse_external (EXTR *, int, struct section_offsets *,
2078                             struct objfile *);
2079
2080 static void
2081 parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
2082                 struct objfile *objfile)
2083 {
2084   union aux_ext *ax;
2085
2086   if (es->ifd != ifdNil)
2087     {
2088       cur_fd = es->ifd;
2089       cur_fdr = debug_info->fdr + cur_fd;
2090       ax = debug_info->external_aux + cur_fdr->iauxBase;
2091     }
2092   else
2093     {
2094       cur_fdr = debug_info->fdr;
2095       ax = 0;
2096     }
2097
2098   /* Reading .o files */
2099   if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil)
2100     {
2101       char *what;
2102       switch (es->asym.st)
2103         {
2104         case stNil:
2105           /* These are generated for static symbols in .o files,
2106              ignore them.  */
2107           return;
2108         case stStaticProc:
2109         case stProc:
2110           what = "procedure";
2111           n_undef_procs++;
2112           break;
2113         case stGlobal:
2114           what = "variable";
2115           n_undef_vars++;
2116           break;
2117         case stLabel:
2118           what = "label";
2119           n_undef_labels++;
2120           break;
2121         default:
2122           what = "symbol";
2123           break;
2124         }
2125       n_undef_symbols++;
2126       /* FIXME:  Turn this into a complaint?  */
2127       if (info_verbose)
2128         printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
2129                          what, debug_info->ssext + es->asym.iss,
2130                          fdr_name (cur_fdr));
2131       return;
2132     }
2133
2134   switch (es->asym.st)
2135     {
2136     case stProc:
2137     case stStaticProc:
2138       /* There is no need to parse the external procedure symbols.
2139          If they are from objects compiled without -g, their index will
2140          be indexNil, and the symbol definition from the minimal symbol
2141          is preferrable (yielding a function returning int instead of int).
2142          If the index points to a local procedure symbol, the local
2143          symbol already provides the correct type.
2144          Note that the index of the external procedure symbol points
2145          to the local procedure symbol in the local symbol table, and
2146          _not_ to the auxiliary symbol info.  */
2147       break;
2148     case stGlobal:
2149     case stLabel:
2150       /* Global common symbols are resolved by the runtime loader,
2151          ignore them.  */
2152       if (SC_IS_COMMON (es->asym.sc))
2153         break;
2154
2155       /* Note that the case of a symbol with indexNil must be handled
2156          anyways by parse_symbol().  */
2157       parse_symbol (&es->asym, ax, (char *) NULL,
2158                     bigend, section_offsets, objfile);
2159       break;
2160     default:
2161       break;
2162     }
2163 }
2164
2165 /* Parse the line number info for file descriptor FH into
2166    GDB's linetable LT.  MIPS' encoding requires a little bit
2167    of magic to get things out.  Note also that MIPS' line
2168    numbers can go back and forth, apparently we can live
2169    with that and do not need to reorder our linetables.  */
2170
2171 static void parse_lines (FDR *, PDR *, struct linetable *, int,
2172                          struct partial_symtab *, CORE_ADDR);
2173
2174 static void
2175 parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
2176              struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr)
2177 {
2178   unsigned char *base;
2179   int j, k;
2180   int delta, count, lineno = 0;
2181
2182   if (fh->cbLine == 0)
2183     return;
2184
2185   /* Scan by procedure descriptors.  */
2186   k = 0;
2187   for (j = 0; j < fh->cpd; j++, pr++)
2188     {
2189       CORE_ADDR l;
2190       CORE_ADDR adr;
2191       unsigned char *halt;
2192
2193       /* No code for this one.  */
2194       if (pr->iline == ilineNil ||
2195           pr->lnLow == -1 || pr->lnHigh == -1)
2196         continue;
2197
2198       /* Determine start and end address of compressed line bytes for
2199          this procedure.  */
2200       base = debug_info->line + fh->cbLineOffset;
2201       if (j != (fh->cpd - 1))
2202         halt = base + pr[1].cbLineOffset;
2203       else
2204         halt = base + fh->cbLine;
2205       base += pr->cbLineOffset;
2206
2207       adr = pst->textlow + pr->adr - lowest_pdr_addr;
2208
2209       l = adr >> 2;             /* in words */
2210       for (lineno = pr->lnLow; base < halt;)
2211         {
2212           count = *base & 0x0f;
2213           delta = *base++ >> 4;
2214           if (delta >= 8)
2215             delta -= 16;
2216           if (delta == -8)
2217             {
2218               delta = (base[0] << 8) | base[1];
2219               if (delta >= 0x8000)
2220                 delta -= 0x10000;
2221               base += 2;
2222             }
2223           lineno += delta;      /* first delta is 0 */
2224
2225           /* Complain if the line table overflows.  Could happen
2226              with corrupt binaries.  */
2227           if (lt->nitems >= maxlines)
2228             {
2229               complaint (&symfile_complaints,
2230                          _("guessed size of linetable for %s incorrectly"),
2231                          fdr_name (fh));
2232               break;
2233             }
2234           k = add_line (lt, lineno, l, k);
2235           l += count + 1;
2236         }
2237     }
2238 }
2239 \f
2240 static void
2241 function_outside_compilation_unit_complaint (const char *arg1)
2242 {
2243   complaint (&symfile_complaints,
2244              _("function `%s' appears to be defined "
2245                "outside of all compilation units"),
2246              arg1);
2247 }
2248
2249 /* Use the STORAGE_CLASS to compute which section the given symbol
2250    belongs to, and then records this new minimal symbol.  */
2251
2252 static void
2253 record_minimal_symbol (const char *name, const CORE_ADDR address,
2254                        enum minimal_symbol_type ms_type, int storage_class,
2255                        struct objfile *objfile)
2256 {
2257   int section;
2258   asection *bfd_section;
2259
2260   switch (storage_class)
2261     {
2262       case scText:
2263         section = SECT_OFF_TEXT (objfile);
2264         bfd_section = bfd_get_section_by_name (cur_bfd, ".text");
2265         break;
2266       case scData:
2267         section = SECT_OFF_DATA (objfile);
2268         bfd_section = bfd_get_section_by_name (cur_bfd, ".data");
2269         break;
2270       case scBss:
2271         section = SECT_OFF_BSS (objfile);
2272         bfd_section = bfd_get_section_by_name (cur_bfd, ".bss");
2273         break;
2274       case scSData:
2275         section = get_section_index (objfile, ".sdata");
2276         bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata");
2277         break;
2278       case scSBss:
2279         section = get_section_index (objfile, ".sbss");
2280         bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss");
2281         break;
2282       case scRData:
2283         section = get_section_index (objfile, ".rdata");
2284         bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata");
2285         break;
2286       case scInit:
2287         section = get_section_index (objfile, ".init");
2288         bfd_section = bfd_get_section_by_name (cur_bfd, ".init");
2289         break;
2290       case scXData:
2291         section = get_section_index (objfile, ".xdata");
2292         bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata");
2293         break;
2294       case scPData:
2295         section = get_section_index (objfile, ".pdata");
2296         bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata");
2297         break;
2298       case scFini:
2299         section = get_section_index (objfile, ".fini");
2300         bfd_section = bfd_get_section_by_name (cur_bfd, ".fini");
2301         break;
2302       case scRConst:
2303         section = get_section_index (objfile, ".rconst");
2304         bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst");
2305         break;
2306 #ifdef scTlsData
2307       case scTlsData:
2308         section = get_section_index (objfile, ".tlsdata");
2309         bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata");
2310         break;
2311 #endif
2312 #ifdef scTlsBss
2313       case scTlsBss:
2314         section = get_section_index (objfile, ".tlsbss");
2315         bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss");
2316         break;
2317 #endif
2318       default:
2319         /* This kind of symbol is not associated to a section.  */
2320         section = -1;
2321         bfd_section = NULL;
2322     }
2323
2324   prim_record_minimal_symbol_and_info (name, address, ms_type,
2325                                        section, bfd_section, objfile);
2326 }
2327
2328 /* Master parsing procedure for first-pass reading of file symbols
2329    into a partial_symtab.  */
2330
2331 static void
2332 parse_partial_symbols (struct objfile *objfile)
2333 {
2334   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2335   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
2336   const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
2337   const bfd_size_type external_ext_size = debug_swap->external_ext_size;
2338   void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in;
2339   void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
2340   void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in;
2341   int f_idx, s_idx;
2342   HDRR *hdr = &debug_info->symbolic_header;
2343   /* Running pointers */
2344   FDR *fh;
2345   char *ext_out;
2346   char *ext_out_end;
2347   EXTR *ext_block;
2348   EXTR *ext_in;
2349   EXTR *ext_in_end;
2350   SYMR sh;
2351   struct partial_symtab *pst;
2352   int textlow_not_set = 1;
2353   int past_first_source_file = 0;
2354
2355   /* List of current psymtab's include files.  */
2356   char **psymtab_include_list;
2357   int includes_allocated;
2358   int includes_used;
2359   EXTR *extern_tab;
2360   struct pst_map *fdr_to_pst;
2361   /* Index within current psymtab dependency list.  */
2362   struct partial_symtab **dependency_list;
2363   int dependencies_used, dependencies_allocated;
2364   struct cleanup *old_chain;
2365   char *name;
2366   enum language prev_language;
2367   asection *text_sect;
2368   int relocatable = 0;
2369
2370   /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2371      the shared libraries are prelinked at a high memory address.
2372      We have to adjust the start address of the object file for this case,
2373      by setting it to the start address of the first procedure in the file.
2374      But we should do no adjustments if we are debugging a .o file, where
2375      the text section (and fh->adr) really starts at zero.  */
2376   text_sect = bfd_get_section_by_name (cur_bfd, ".text");
2377   if (text_sect != NULL
2378       && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
2379     relocatable = 1;
2380
2381   extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack,
2382                                        sizeof (EXTR) * hdr->iextMax);
2383
2384   includes_allocated = 30;
2385   includes_used = 0;
2386   psymtab_include_list = (char **) alloca (includes_allocated *
2387                                            sizeof (char *));
2388   next_symbol_text_func = mdebug_next_symbol_text;
2389
2390   dependencies_allocated = 30;
2391   dependencies_used = 0;
2392   dependency_list =
2393     (struct partial_symtab **) alloca (dependencies_allocated *
2394                                        sizeof (struct partial_symtab *));
2395
2396   last_source_file = NULL;
2397
2398   /*
2399    * Big plan:
2400    *
2401    * Only parse the Local and External symbols, and the Relative FDR.
2402    * Fixup enough of the loader symtab to be able to use it.
2403    * Allocate space only for the file's portions we need to
2404    * look at.  (XXX)
2405    */
2406
2407   max_gdbinfo = 0;
2408   max_glevel = MIN_GLEVEL;
2409
2410   /* Allocate the map FDR -> PST.
2411      Minor hack: -O3 images might claim some global data belongs
2412      to FDR -1.  We`ll go along with that.  */
2413   fdr_to_pst = (struct pst_map *)
2414     xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
2415   old_chain = make_cleanup (xfree, fdr_to_pst);
2416   fdr_to_pst++;
2417   {
2418     struct partial_symtab *pst = new_psymtab ("", objfile);
2419
2420     fdr_to_pst[-1].pst = pst;
2421     FDR_IDX (pst) = -1;
2422   }
2423
2424   /* Allocate the global pending list.  */
2425   pending_list =
2426     ((struct mdebug_pending **)
2427      obstack_alloc (&objfile->objfile_obstack,
2428                     hdr->ifdMax * sizeof (struct mdebug_pending *)));
2429   memset (pending_list, 0,
2430           hdr->ifdMax * sizeof (struct mdebug_pending *));
2431
2432   /* Pass 0 over external syms: swap them in.  */
2433   ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
2434   make_cleanup (xfree, ext_block);
2435
2436   ext_out = (char *) debug_info->external_ext;
2437   ext_out_end = ext_out + hdr->iextMax * external_ext_size;
2438   ext_in = ext_block;
2439   for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
2440     (*swap_ext_in) (cur_bfd, ext_out, ext_in);
2441
2442   /* Pass 1 over external syms: Presize and partition the list.  */
2443   ext_in = ext_block;
2444   ext_in_end = ext_in + hdr->iextMax;
2445   for (; ext_in < ext_in_end; ext_in++)
2446     {
2447       /* See calls to complain below.  */
2448       if (ext_in->ifd >= -1
2449           && ext_in->ifd < hdr->ifdMax
2450           && ext_in->asym.iss >= 0
2451           && ext_in->asym.iss < hdr->issExtMax)
2452         fdr_to_pst[ext_in->ifd].n_globals++;
2453     }
2454
2455   /* Pass 1.5 over files:  partition out global symbol space.  */
2456   s_idx = 0;
2457   for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++)
2458     {
2459       fdr_to_pst[f_idx].globals_offset = s_idx;
2460       s_idx += fdr_to_pst[f_idx].n_globals;
2461       fdr_to_pst[f_idx].n_globals = 0;
2462     }
2463
2464   /* ECOFF in ELF:
2465
2466      For ECOFF in ELF, we skip the creation of the minimal symbols.
2467      The ECOFF symbols should be a subset of the Elf symbols, and the 
2468      section information of the elf symbols will be more accurate.
2469      FIXME!  What about Irix 5's native linker?
2470
2471      By default, Elf sections which don't exist in ECOFF 
2472      get put in ECOFF's absolute section by the gnu linker.
2473      Since absolute sections don't get relocated, we 
2474      end up calculating an address different from that of 
2475      the symbol's minimal symbol (created earlier from the
2476      Elf symtab).
2477
2478      To fix this, either :
2479      1) don't create the duplicate symbol
2480      (assumes ECOFF symtab is a subset of the ELF symtab;
2481      assumes no side-effects result from ignoring ECOFF symbol)
2482      2) create it, only if lookup for existing symbol in ELF's minimal 
2483      symbols fails
2484      (inefficient; 
2485      assumes no side-effects result from ignoring ECOFF symbol)
2486      3) create it, but lookup ELF's minimal symbol and use it's section
2487      during relocation, then modify "uniqify" phase to merge and 
2488      eliminate the duplicate symbol
2489      (highly inefficient)
2490
2491      I've implemented #1 here...
2492      Skip the creation of the minimal symbols based on the ECOFF 
2493      symbol table.  */
2494
2495   /* Pass 2 over external syms: fill in external symbols.  */
2496   ext_in = ext_block;
2497   ext_in_end = ext_in + hdr->iextMax;
2498   for (; ext_in < ext_in_end; ext_in++)
2499     {
2500       enum minimal_symbol_type ms_type = mst_text;
2501       CORE_ADDR svalue = ext_in->asym.value;
2502
2503       /* The Irix 5 native tools seem to sometimes generate bogus
2504          external symbols.  */
2505       if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
2506         {
2507           complaint (&symfile_complaints,
2508                      _("bad ifd for external symbol: %d (max %ld)"),
2509                      ext_in->ifd, hdr->ifdMax);
2510           continue;
2511         }
2512       if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
2513         {
2514           complaint (&symfile_complaints,
2515                      _("bad iss for external symbol: %ld (max %ld)"),
2516                      ext_in->asym.iss, hdr->issExtMax);
2517           continue;
2518         }
2519
2520       extern_tab[fdr_to_pst[ext_in->ifd].globals_offset
2521                  + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in;
2522
2523
2524       if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil)
2525         continue;
2526
2527
2528       /* Pass 3 over files, over local syms: fill in static symbols.  */
2529       name = debug_info->ssext + ext_in->asym.iss;
2530
2531       /* Process ECOFF Symbol Types and Storage Classes.  */
2532       switch (ext_in->asym.st)
2533         {
2534         case stProc:
2535           /* Beginnning of Procedure */
2536           svalue += ANOFFSET (objfile->section_offsets,
2537                               SECT_OFF_TEXT (objfile));
2538           break;
2539         case stStaticProc:
2540           /* Load time only static procs */
2541           ms_type = mst_file_text;
2542           svalue += ANOFFSET (objfile->section_offsets,
2543                               SECT_OFF_TEXT (objfile));
2544           break;
2545         case stGlobal:
2546           /* External symbol */
2547           if (SC_IS_COMMON (ext_in->asym.sc))
2548             {
2549               /* The value of a common symbol is its size, not its address.
2550                  Ignore it.  */
2551               continue;
2552             }
2553           else if (SC_IS_DATA (ext_in->asym.sc))
2554             {
2555               ms_type = mst_data;
2556               svalue += ANOFFSET (objfile->section_offsets,
2557                                   SECT_OFF_DATA (objfile));
2558             }
2559           else if (SC_IS_BSS (ext_in->asym.sc))
2560             {
2561               ms_type = mst_bss;
2562               svalue += ANOFFSET (objfile->section_offsets,
2563                                   SECT_OFF_BSS (objfile));
2564             }
2565           else if (SC_IS_SBSS (ext_in->asym.sc))
2566             {
2567               ms_type = mst_bss;
2568               svalue += ANOFFSET (objfile->section_offsets, 
2569                                   get_section_index (objfile, ".sbss"));
2570             }
2571           else
2572             ms_type = mst_abs;
2573           break;
2574         case stLabel:
2575           /* Label */
2576
2577           /* On certain platforms, some extra label symbols can be
2578              generated by the linker.  One possible usage for this kind
2579              of symbols is to represent the address of the begining of a
2580              given section.  For instance, on Tru64 5.1, the address of
2581              the _ftext label is the start address of the .text section.
2582
2583              The storage class of these symbols is usually directly
2584              related to the section to which the symbol refers.  For
2585              instance, on Tru64 5.1, the storage class for the _fdata
2586              label is scData, refering to the .data section.
2587
2588              It is actually possible that the section associated to the
2589              storage class of the label does not exist.  On True64 5.1
2590              for instance, the libm.so shared library does not contain
2591              any .data section, although it contains a _fpdata label
2592              which storage class is scData...  Since these symbols are
2593              usually useless for the debugger user anyway, we just
2594              discard these symbols.  */
2595           
2596           if (SC_IS_TEXT (ext_in->asym.sc))
2597             {
2598               if (objfile->sect_index_text == -1)
2599                 continue;
2600                 
2601               ms_type = mst_file_text;
2602               svalue += ANOFFSET (objfile->section_offsets,
2603                                   SECT_OFF_TEXT (objfile));
2604             }
2605           else if (SC_IS_DATA (ext_in->asym.sc))
2606             {
2607               if (objfile->sect_index_data == -1)
2608                 continue;
2609
2610               ms_type = mst_file_data;
2611               svalue += ANOFFSET (objfile->section_offsets,
2612                                   SECT_OFF_DATA (objfile));
2613             }
2614           else if (SC_IS_BSS (ext_in->asym.sc))
2615             {
2616               if (objfile->sect_index_bss == -1)
2617                 continue;
2618
2619               ms_type = mst_file_bss;
2620               svalue += ANOFFSET (objfile->section_offsets,
2621                                   SECT_OFF_BSS (objfile));
2622             }
2623           else if (SC_IS_SBSS (ext_in->asym.sc))
2624             {
2625               const int sbss_sect_index = get_section_index (objfile, ".sbss");
2626
2627               if (sbss_sect_index == -1)
2628                 continue;
2629
2630               ms_type = mst_file_bss;
2631               svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index);
2632             }
2633           else
2634             ms_type = mst_abs;
2635           break;
2636         case stLocal:
2637         case stNil:
2638           /* The alpha has the section start addresses in stLocal symbols
2639              whose name starts with a `.'.  Skip those but complain for all
2640              other stLocal symbols.
2641              Irix6 puts the section start addresses in stNil symbols, skip
2642              those too.  */
2643           if (name[0] == '.')
2644             continue;
2645           /* Fall through.  */
2646         default:
2647           ms_type = mst_unknown;
2648           unknown_ext_complaint (name);
2649         }
2650       if (!ECOFF_IN_ELF (cur_bfd))
2651         record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc,
2652                                objfile);
2653     }
2654
2655   /* Pass 3 over files, over local syms: fill in static symbols.  */
2656   for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
2657     {
2658       struct partial_symtab *save_pst;
2659       EXTR *ext_ptr;
2660       CORE_ADDR textlow;
2661
2662       cur_fdr = fh = debug_info->fdr + f_idx;
2663
2664       if (fh->csym == 0)
2665         {
2666           fdr_to_pst[f_idx].pst = NULL;
2667           continue;
2668         }
2669
2670       /* Determine the start address for this object file from the
2671          file header and relocate it, except for Irix 5.2 zero fh->adr.  */
2672       if (fh->cpd)
2673         {
2674           textlow = fh->adr;
2675           if (relocatable || textlow != 0)
2676             textlow += ANOFFSET (objfile->section_offsets,
2677                                  SECT_OFF_TEXT (objfile));
2678         }
2679       else
2680         textlow = 0;
2681       pst = start_psymtab_common (objfile, objfile->section_offsets,
2682                                   fdr_name (fh),
2683                                   textlow,
2684                                   objfile->global_psymbols.next,
2685                                   objfile->static_psymbols.next);
2686       pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
2687                                                 sizeof (struct symloc));
2688       memset (pst->read_symtab_private, 0, sizeof (struct symloc));
2689
2690       save_pst = pst;
2691       FDR_IDX (pst) = f_idx;
2692       CUR_BFD (pst) = cur_bfd;
2693       DEBUG_SWAP (pst) = debug_swap;
2694       DEBUG_INFO (pst) = debug_info;
2695       PENDING_LIST (pst) = pending_list;
2696
2697       /* The way to turn this into a symtab is to call...  */
2698       pst->read_symtab = mdebug_psymtab_to_symtab;
2699
2700       /* Set up language for the pst.
2701          The language from the FDR is used if it is unambigious (e.g. cfront
2702          with native cc and g++ will set the language to C).
2703          Otherwise we have to deduce the language from the filename.
2704          Native ecoff has every header file in a separate FDR, so
2705          deduce_language_from_filename will return language_unknown for
2706          a header file, which is not what we want.
2707          But the FDRs for the header files are after the FDR for the source
2708          file, so we can assign the language of the source file to the
2709          following header files.  Then we save the language in the private
2710          pst data so that we can reuse it when building symtabs.  */
2711       prev_language = psymtab_language;
2712
2713       switch (fh->lang)
2714         {
2715         case langCplusplusV2:
2716           psymtab_language = language_cplus;
2717           break;
2718         default:
2719           psymtab_language = deduce_language_from_filename (fdr_name (fh));
2720           break;
2721         }
2722       if (psymtab_language == language_unknown)
2723         psymtab_language = prev_language;
2724       PST_PRIVATE (pst)->pst_language = psymtab_language;
2725
2726       pst->texthigh = pst->textlow;
2727
2728       /* For stabs-in-ecoff files, the second symbol must be @stab.
2729          This symbol is emitted by mips-tfile to signal that the
2730          current object file uses encapsulated stabs instead of mips
2731          ecoff for local symbols.  (It is the second symbol because
2732          the first symbol is the stFile used to signal the start of a
2733          file).  */
2734       processing_gcc_compilation = 0;
2735       if (fh->csym >= 2)
2736         {
2737           (*swap_sym_in) (cur_bfd,
2738                           ((char *) debug_info->external_sym
2739                            + (fh->isymBase + 1) * external_sym_size),
2740                           &sh);
2741           if (strcmp (debug_info->ss + fh->issBase + sh.iss,
2742                       stabs_symbol) == 0)
2743             processing_gcc_compilation = 2;
2744         }
2745
2746       if (processing_gcc_compilation != 0)
2747         {
2748           for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
2749             {
2750               int type_code;
2751               char *namestring;
2752
2753               (*swap_sym_in) (cur_bfd,
2754                               (((char *) debug_info->external_sym)
2755                             + (fh->isymBase + cur_sdx) * external_sym_size),
2756                               &sh);
2757               type_code = ECOFF_UNMARK_STAB (sh.index);
2758               if (!ECOFF_IS_STAB (&sh))
2759                 {
2760                   if (sh.st == stProc || sh.st == stStaticProc)
2761                     {
2762                       CORE_ADDR procaddr;
2763                       long isym;
2764
2765                       sh.value += ANOFFSET (objfile->section_offsets,
2766                                             SECT_OFF_TEXT (objfile));
2767                       if (sh.st == stStaticProc)
2768                         {
2769                           namestring = debug_info->ss + fh->issBase + sh.iss;
2770                           record_minimal_symbol (namestring, sh.value,
2771                                                  mst_file_text, sh.sc,
2772                                                  objfile);
2773                         }
2774                       procaddr = sh.value;
2775
2776                       isym = AUX_GET_ISYM (fh->fBigendian,
2777                                            (debug_info->external_aux
2778                                             + fh->iauxBase
2779                                             + sh.index));
2780                       (*swap_sym_in) (cur_bfd,
2781                                       ((char *) debug_info->external_sym
2782                                        + ((fh->isymBase + isym - 1)
2783                                           * external_sym_size)),
2784                                       &sh);
2785                       if (sh.st == stEnd)
2786                         {
2787                           CORE_ADDR high = procaddr + sh.value;
2788
2789                           /* Kludge for Irix 5.2 zero fh->adr.  */
2790                           if (!relocatable
2791                           && (pst->textlow == 0 || procaddr < pst->textlow))
2792                             pst->textlow = procaddr;
2793                           if (high > pst->texthigh)
2794                             pst->texthigh = high;
2795                         }
2796                     }
2797                   else if (sh.st == stStatic)
2798                     {
2799                       switch (sh.sc)
2800                         {
2801                         case scUndefined:
2802                         case scSUndefined:
2803                         case scNil:
2804                         case scAbs:
2805                           break;
2806
2807                         case scData:
2808                         case scSData:
2809                         case scRData:
2810                         case scPData:
2811                         case scXData:
2812                           namestring = debug_info->ss + fh->issBase + sh.iss;
2813                           sh.value += ANOFFSET (objfile->section_offsets,
2814                                                 SECT_OFF_DATA (objfile));
2815                           record_minimal_symbol (namestring, sh.value,
2816                                                  mst_file_data, sh.sc,
2817                                                  objfile);
2818                           break;
2819
2820                         default:
2821                           /* FIXME!  Shouldn't this use cases for bss, 
2822                              then have the default be abs?  */
2823                           namestring = debug_info->ss + fh->issBase + sh.iss;
2824                           sh.value += ANOFFSET (objfile->section_offsets,
2825                                                 SECT_OFF_BSS (objfile));
2826                           record_minimal_symbol (namestring, sh.value,
2827                                                  mst_file_bss, sh.sc,
2828                                                  objfile);
2829                           break;
2830                         }
2831                     }
2832                   continue;
2833                 }
2834               /* Handle stabs continuation.  */
2835               {
2836                 char *stabstring = debug_info->ss + fh->issBase + sh.iss;
2837                 int len = strlen (stabstring);
2838
2839                 while (stabstring[len - 1] == '\\')
2840                   {
2841                     SYMR sh2;
2842                     char *stabstring1 = stabstring;
2843                     char *stabstring2;
2844                     int len2;
2845
2846                     /* Ignore continuation char from 1st string.  */
2847                     len--;
2848
2849                     /* Read next stabstring.  */
2850                     cur_sdx++;
2851                     (*swap_sym_in) (cur_bfd,
2852                                     (((char *) debug_info->external_sym)
2853                                      + (fh->isymBase + cur_sdx)
2854                                      * external_sym_size),
2855                                     &sh2);
2856                     stabstring2 = debug_info->ss + fh->issBase + sh2.iss;
2857                     len2 = strlen (stabstring2);
2858
2859                     /* Concatinate stabstring2 with stabstring1.  */
2860                     if (stabstring
2861                      && stabstring != debug_info->ss + fh->issBase + sh.iss)
2862                       stabstring = xrealloc (stabstring, len + len2 + 1);
2863                     else
2864                       {
2865                         stabstring = xmalloc (len + len2 + 1);
2866                         strcpy (stabstring, stabstring1);
2867                       }
2868                     strcpy (stabstring + len, stabstring2);
2869                     len += len2;
2870                   }
2871
2872                 switch (type_code)
2873                   {
2874                     char *p;
2875
2876                     /* Standard, external, non-debugger, symbols.  */
2877
2878                   case N_TEXT | N_EXT:
2879                   case N_NBTEXT | N_EXT:
2880                     sh.value += ANOFFSET (objfile->section_offsets,
2881                                           SECT_OFF_TEXT (objfile));
2882                     goto record_it;
2883
2884                   case N_DATA | N_EXT:
2885                   case N_NBDATA | N_EXT:
2886                     sh.value += ANOFFSET (objfile->section_offsets,
2887                                           SECT_OFF_DATA (objfile));
2888                     goto record_it;
2889
2890                   case N_BSS:
2891                   case N_BSS | N_EXT:
2892                   case N_NBBSS | N_EXT:
2893                   case N_SETV | N_EXT:          /* FIXME, is this in BSS?  */
2894                     sh.value += ANOFFSET (objfile->section_offsets,
2895                                           SECT_OFF_BSS (objfile));
2896                     goto record_it;
2897
2898                   case N_ABS | N_EXT:
2899                   record_it:
2900                     continue;
2901
2902                   /* Standard, local, non-debugger, symbols.  */
2903
2904                   case N_NBTEXT:
2905
2906                     /* We need to be able to deal with both N_FN or
2907                        N_TEXT, because we have no way of knowing
2908                        whether the sys-supplied ld or GNU ld was used
2909                        to make the executable.  Sequents throw in
2910                        another wrinkle -- they renumbered N_FN.  */
2911
2912                   case N_FN:
2913                   case N_FN_SEQ:
2914                   case N_TEXT:
2915                     continue;
2916
2917                   case N_DATA:
2918                     sh.value += ANOFFSET (objfile->section_offsets,
2919                                           SECT_OFF_DATA (objfile));
2920                     goto record_it;
2921
2922                   case N_UNDF | N_EXT:
2923                     continue;           /* Just undefined, not COMMON.  */
2924
2925                   case N_UNDF:
2926                     continue;
2927
2928                     /* Lots of symbol types we can just ignore.  */
2929
2930                   case N_ABS:
2931                   case N_NBDATA:
2932                   case N_NBBSS:
2933                     continue;
2934
2935                     /* Keep going . . .  */
2936
2937                     /*
2938                      * Special symbol types for GNU
2939                      */
2940                   case N_INDR:
2941                   case N_INDR | N_EXT:
2942                   case N_SETA:
2943                   case N_SETA | N_EXT:
2944                   case N_SETT:
2945                   case N_SETT | N_EXT:
2946                   case N_SETD:
2947                   case N_SETD | N_EXT:
2948                   case N_SETB:
2949                   case N_SETB | N_EXT:
2950                   case N_SETV:
2951                     continue;
2952
2953                     /*
2954                      * Debugger symbols
2955                      */
2956
2957                   case N_SO:
2958                     {
2959                       CORE_ADDR valu;
2960                       static int prev_so_symnum = -10;
2961                       static int first_so_symnum;
2962                       char *p;
2963                       int prev_textlow_not_set;
2964
2965                       valu = sh.value + ANOFFSET (objfile->section_offsets,
2966                                                   SECT_OFF_TEXT (objfile));
2967
2968                       prev_textlow_not_set = textlow_not_set;
2969
2970                       /* A zero value is probably an indication for the
2971                          SunPRO 3.0 compiler.  end_psymtab explicitly tests
2972                          for zero, so don't relocate it.  */
2973
2974                       if (sh.value == 0
2975                           && gdbarch_sofun_address_maybe_missing (gdbarch))
2976                         {
2977                           textlow_not_set = 1;
2978                           valu = 0;
2979                         }
2980                       else
2981                         textlow_not_set = 0;
2982
2983                       past_first_source_file = 1;
2984
2985                       if (prev_so_symnum != symnum - 1)
2986                         {               /* Here if prev stab wasn't N_SO.  */
2987                           first_so_symnum = symnum;
2988
2989                           if (pst)
2990                             {
2991                               pst = (struct partial_symtab *) 0;
2992                               includes_used = 0;
2993                               dependencies_used = 0;
2994                             }
2995                         }
2996
2997                       prev_so_symnum = symnum;
2998
2999                       /* End the current partial symtab and start a
3000                          new one.  */
3001
3002                       /* SET_NAMESTRING ();*/
3003                       namestring = stabstring;
3004
3005                       /* Null name means end of .o file.  Don't start a new
3006                          one.  */
3007                       if (*namestring == '\000')
3008                         continue;
3009
3010                       /* Some compilers (including gcc) emit a pair of
3011                          initial N_SOs.  The first one is a directory name;
3012                          the second the file name.  If pst exists, is
3013                          empty, and has a filename ending in '/', we assume
3014                          the previous N_SO was a directory name.  */
3015
3016                       p = strrchr (namestring, '/');
3017                       if (p && *(p + 1) == '\000')
3018                         continue;               /* Simply ignore directory
3019                                                    name SOs.  */
3020
3021                       /* Some other compilers (C++ ones in particular) emit
3022                          useless SOs for non-existant .c files.  We ignore
3023                          all subsequent SOs that immediately follow the
3024                          first.  */
3025
3026                       if (!pst)
3027                         pst = save_pst;
3028                       continue;
3029                     }
3030
3031                   case N_BINCL:
3032                     continue;
3033
3034                   case N_SOL:
3035                     {
3036                       enum language tmp_language;
3037
3038                       /* Mark down an include file in the current psymtab.  */
3039
3040                       /* SET_NAMESTRING (); */
3041                       namestring = stabstring;
3042
3043                       tmp_language
3044                         = deduce_language_from_filename (namestring);
3045
3046                       /* Only change the psymtab's language if we've
3047                          learned something useful (eg. tmp_language is not
3048                          language_unknown).  In addition, to match what
3049                          start_subfile does, never change from C++ to
3050                          C.  */
3051                       if (tmp_language != language_unknown
3052                           && (tmp_language != language_c
3053                               || psymtab_language != language_cplus))
3054                         psymtab_language = tmp_language;
3055
3056                       /* In C++, one may expect the same filename to come
3057                          round many times, when code is coming alternately
3058                          from the main file and from inline functions in
3059                          other files.  So I check to see if this is a file
3060                          we've seen before -- either the main source file,
3061                          or a previously included file.
3062
3063                          This seems to be a lot of time to be spending on
3064                          N_SOL, but things like "break c-exp.y:435" need to
3065                          work (I suppose the psymtab_include_list could be
3066                          hashed or put in a binary tree, if profiling shows
3067                          this is a major hog).  */
3068                       if (pst && strcmp (namestring, pst->filename) == 0)
3069                         continue;
3070
3071                       {
3072                         int i;
3073
3074                         for (i = 0; i < includes_used; i++)
3075                           if (strcmp (namestring,
3076                                       psymtab_include_list[i]) == 0)
3077                             {
3078                               i = -1;
3079                               break;
3080                             }
3081                         if (i == -1)
3082                           continue;
3083                       }
3084
3085                       psymtab_include_list[includes_used++] = namestring;
3086                       if (includes_used >= includes_allocated)
3087                         {
3088                           char **orig = psymtab_include_list;
3089
3090                           psymtab_include_list = (char **)
3091                             alloca ((includes_allocated *= 2) *
3092                                     sizeof (char *));
3093                           memcpy (psymtab_include_list, orig,
3094                                   includes_used * sizeof (char *));
3095                         }
3096                       continue;
3097                     }
3098                   case N_LSYM:      /* Typedef or automatic variable.  */
3099                   case N_STSYM:     /* Data seg var -- static  */
3100                   case N_LCSYM:     /* BSS      "  */
3101                   case N_ROSYM:     /* Read-only data seg var -- static.  */
3102                   case N_NBSTS:     /* Gould nobase.  */
3103                   case N_NBLCS:     /* symbols.  */
3104                   case N_FUN:
3105                   case N_GSYM:      /* Global (extern) variable; can be
3106                                        data or bss (sigh FIXME).  */
3107
3108                     /* Following may probably be ignored; I'll leave them here
3109                        for now (until I do Pascal and Modula 2 extensions).  */
3110
3111                   case N_PC:        /* I may or may not need this; I
3112                                        suspect not.  */
3113                   case N_M2C:       /* I suspect that I can ignore this
3114                                        here.  */
3115                   case N_SCOPE:     /* Same.  */
3116
3117                     /*    SET_NAMESTRING (); */
3118                     namestring = stabstring;
3119                     p = (char *) strchr (namestring, ':');
3120                     if (!p)
3121                       continue;     /* Not a debugging symbol.  */
3122
3123
3124
3125                     /* Main processing section for debugging symbols which
3126                        the initial read through the symbol tables needs to
3127                        worry about.  If we reach this point, the symbol
3128                        which we are considering is definitely one we are
3129                        interested in.  p must also contain the (valid)
3130                        index into the namestring which indicates the
3131                        debugging type symbol.  */
3132
3133                     switch (p[1])
3134                       {
3135                       case 'S':
3136                         sh.value += ANOFFSET (objfile->section_offsets,
3137                                               SECT_OFF_DATA (objfile));
3138
3139                         if (gdbarch_static_transform_name_p (gdbarch))
3140                           namestring = gdbarch_static_transform_name
3141                                          (gdbarch, namestring);
3142
3143                         add_psymbol_to_list (namestring, p - namestring, 1,
3144                                              VAR_DOMAIN, LOC_STATIC,
3145                                              &objfile->static_psymbols,
3146                                              0, sh.value,
3147                                              psymtab_language, objfile);
3148                         continue;
3149                       case 'G':
3150                         sh.value += ANOFFSET (objfile->section_offsets,
3151                                               SECT_OFF_DATA (objfile));
3152                         /* The addresses in these entries are reported
3153                            to be wrong.  See the code that reads 'G's
3154                            for symtabs.  */
3155                         add_psymbol_to_list (namestring, p - namestring, 1,
3156                                              VAR_DOMAIN, LOC_STATIC,
3157                                              &objfile->global_psymbols,
3158                                              0, sh.value,
3159                                              psymtab_language, objfile);
3160                         continue;
3161
3162                       case 'T':
3163                         /* When a 'T' entry is defining an anonymous enum, it
3164                            may have a name which is the empty string, or a
3165                            single space.  Since they're not really defining a
3166                            symbol, those shouldn't go in the partial symbol
3167                            table.  We do pick up the elements of such enums at
3168                            'check_enum:', below.  */
3169                         if (p >= namestring + 2
3170                             || (p == namestring + 1
3171                                 && namestring[0] != ' '))
3172                           {
3173                             add_psymbol_to_list (namestring, p - namestring, 1,
3174                                                  STRUCT_DOMAIN, LOC_TYPEDEF,
3175                                                  &objfile->static_psymbols,
3176                                                  sh.value, 0,
3177                                                  psymtab_language, objfile);
3178                             if (p[2] == 't')
3179                               {
3180                                 /* Also a typedef with the same name.  */
3181                                 add_psymbol_to_list (namestring,
3182                                                      p - namestring, 1,
3183                                                      VAR_DOMAIN, LOC_TYPEDEF,
3184                                                      &objfile->static_psymbols,
3185                                                      sh.value, 0,
3186                                                      psymtab_language,
3187                                                      objfile);
3188                                 p += 1;
3189                               }
3190                           }
3191                         goto check_enum;
3192                       case 't':
3193                         if (p != namestring)    /* a name is there, not
3194                                                    just :T...  */
3195                           {
3196                             add_psymbol_to_list (namestring, p - namestring, 1,
3197                                                  VAR_DOMAIN, LOC_TYPEDEF,
3198                                                  &objfile->static_psymbols,
3199                                                  sh.value, 0,
3200                                                  psymtab_language, objfile);
3201                           }
3202                       check_enum:
3203                         /* If this is an enumerated type, we need to add
3204                            all the enum constants to the partial symbol
3205                            table.  This does not cover enums without names,
3206                            e.g. "enum {a, b} c;" in C, but fortunately
3207                            those are rare.  There is no way for GDB to find
3208                            those from the enum type without spending too
3209                            much time on it.  Thus to solve this problem,
3210                            the compiler needs to put out the enum in a
3211                            nameless type.  GCC2 does this.  */
3212
3213                         /* We are looking for something of the form
3214                            <name> ":" ("t" | "T") [<number> "="] "e"
3215                            {<constant> ":" <value> ","} ";".  */
3216
3217                         /* Skip over the colon and the 't' or 'T'.  */
3218                         p += 2;
3219                         /* This type may be given a number.  Also, numbers
3220                            can come in pairs like (0,26).  Skip over it.  */
3221                         while ((*p >= '0' && *p <= '9')
3222                                || *p == '(' || *p == ',' || *p == ')'
3223                                || *p == '=')
3224                           p++;
3225
3226                         if (*p++ == 'e')
3227                           {
3228                             /* The aix4 compiler emits extra crud before
3229                                the members.  */
3230                             if (*p == '-')
3231                               {
3232                                 /* Skip over the type (?).  */
3233                                 while (*p != ':')
3234                                   p++;
3235
3236                                 /* Skip over the colon.  */
3237                                 p++;
3238                               }
3239
3240                             /* We have found an enumerated type.  */
3241                             /* According to comments in read_enum_type
3242                                a comma could end it instead of a semicolon.
3243                                I don't know where that happens.
3244                                Accept either.  */
3245                             while (*p && *p != ';' && *p != ',')
3246                               {
3247                                 char *q;
3248
3249                                 /* Check for and handle cretinous dbx
3250                                    symbol name continuation!  */
3251                                 if (*p == '\\' || (*p == '?' && p[1] == '\0'))
3252                                   p = next_symbol_text (objfile);
3253
3254                                 /* Point to the character after the name
3255                                    of the enum constant.  */
3256                                 for (q = p; *q && *q != ':'; q++)
3257                                   ;
3258                                 /* Note that the value doesn't matter for
3259                                    enum constants in psymtabs, just in
3260                                    symtabs.  */
3261                                 add_psymbol_to_list (p, q - p, 1,
3262                                                      VAR_DOMAIN, LOC_CONST,
3263                                                      &objfile->static_psymbols,
3264                                                      0, 0, psymtab_language,
3265                                                      objfile);
3266                                 /* Point past the name.  */
3267                                 p = q;
3268                                 /* Skip over the value.  */
3269                                 while (*p && *p != ',')
3270                                   p++;
3271                                 /* Advance past the comma.  */
3272                                 if (*p)
3273                                   p++;
3274                               }
3275                           }
3276                         continue;
3277                       case 'c':
3278                         /* Constant, e.g. from "const" in Pascal.  */
3279                         add_psymbol_to_list (namestring, p - namestring, 1,
3280                                              VAR_DOMAIN, LOC_CONST,
3281                                              &objfile->static_psymbols,
3282                                              sh.value, 0, psymtab_language,
3283                                              objfile);
3284                         continue;
3285
3286                       case 'f':
3287                         if (! pst)
3288                           {
3289                             int name_len = p - namestring;
3290                             char *name = xmalloc (name_len + 1);
3291
3292                             memcpy (name, namestring, name_len);
3293                             name[name_len] = '\0';
3294                             function_outside_compilation_unit_complaint (name);
3295                             xfree (name);
3296                           }
3297                         sh.value += ANOFFSET (objfile->section_offsets,
3298                                               SECT_OFF_TEXT (objfile));
3299                         add_psymbol_to_list (namestring, p - namestring, 1,
3300                                              VAR_DOMAIN, LOC_BLOCK,
3301                                              &objfile->static_psymbols,
3302                                              0, sh.value,
3303                                              psymtab_language, objfile);
3304                         continue;
3305
3306                         /* Global functions were ignored here, but now they
3307                            are put into the global psymtab like one would
3308                            expect.  They're also in the minimal symbol
3309                            table.  */
3310                       case 'F':
3311                         if (! pst)
3312                           {
3313                             int name_len = p - namestring;
3314                             char *name = xmalloc (name_len + 1);
3315
3316                             memcpy (name, namestring, name_len);
3317                             name[name_len] = '\0';
3318                             function_outside_compilation_unit_complaint (name);
3319                             xfree (name);
3320                           }
3321                         sh.value += ANOFFSET (objfile->section_offsets,
3322                                               SECT_OFF_TEXT (objfile));
3323                         add_psymbol_to_list (namestring, p - namestring, 1,
3324                                              VAR_DOMAIN, LOC_BLOCK,
3325                                              &objfile->global_psymbols,
3326                                              0, sh.value,
3327                                              psymtab_language, objfile);
3328                         continue;
3329
3330                         /* Two things show up here (hopefully); static
3331                            symbols of local scope (static used inside
3332                            braces) or extensions of structure symbols.  We
3333                            can ignore both.  */
3334                       case 'V':
3335                       case '(':
3336                       case '0':
3337                       case '1':
3338                       case '2':
3339                       case '3':
3340                       case '4':
3341                       case '5':
3342                       case '6':
3343                       case '7':
3344                       case '8':
3345                       case '9':
3346                       case '-':
3347                       case '#':         /* For symbol identification (used
3348                                            in live ranges).  */
3349                         continue;
3350
3351                       case ':':
3352                         /* It is a C++ nested symbol.  We don't need to
3353                            record it (I don't think); if we try to look up
3354                            foo::bar::baz, then symbols for the symtab
3355                            containing foo should get read in, I think.  */
3356                         /* Someone says sun cc puts out symbols like
3357                            /foo/baz/maclib::/usr/local/bin/maclib,
3358                            which would get here with a symbol type of ':'.  */
3359                         continue;
3360
3361                       default:
3362                         /* Unexpected symbol descriptor.  The second and
3363                            subsequent stabs of a continued stab can show up
3364                            here.  The question is whether they ever can
3365                            mimic a normal stab--it would be nice if not,
3366                            since we certainly don't want to spend the time
3367                            searching to the end of every string looking for
3368                            a backslash.  */
3369
3370                         complaint (&symfile_complaints,
3371                                    _("unknown symbol descriptor `%c'"), p[1]);
3372
3373                         /* Ignore it; perhaps it is an extension that we don't
3374                            know about.  */
3375                         continue;
3376                       }
3377
3378                   case N_EXCL:
3379                     continue;
3380
3381                   case N_ENDM:
3382                     /* Solaris 2 end of module, finish current partial
3383                        symbol table.  END_PSYMTAB will set
3384                        pst->texthigh to the proper value, which is
3385                        necessary if a module compiled without
3386                        debugging info follows this module.  */
3387                     if (pst
3388                         && gdbarch_sofun_address_maybe_missing (gdbarch))
3389                       {
3390                         pst = (struct partial_symtab *) 0;
3391                         includes_used = 0;
3392                         dependencies_used = 0;
3393                       }
3394                     continue;
3395
3396                   case N_RBRAC:
3397                     if (sh.value > save_pst->texthigh)
3398                       save_pst->texthigh = sh.value;
3399                     continue;
3400                   case N_EINCL:
3401                   case N_DSLINE:
3402                   case N_BSLINE:
3403                   case N_SSYM:          /* Claim: Structure or union
3404                                            element.  Hopefully, I can
3405                                            ignore this.  */
3406                   case N_ENTRY:         /* Alternate entry point; can
3407                                            ignore.  */
3408                   case N_MAIN:          /* Can definitely ignore this.   */
3409                   case N_CATCH:         /* These are GNU C++ extensions.  */
3410                   case N_EHDECL:        /* that can safely be ignored here.  */
3411                   case N_LENG:
3412                   case N_BCOMM:
3413                   case N_ECOMM:
3414                   case N_ECOML:
3415                   case N_FNAME:
3416                   case N_SLINE:
3417                   case N_RSYM:
3418                   case N_PSYM:
3419                   case N_LBRAC:
3420                   case N_NSYMS:         /* Ultrix 4.0: symbol count */
3421                   case N_DEFD:                  /* GNU Modula-2 */
3422                   case N_ALIAS:         /* SunPro F77: alias name, ignore
3423                                            for now.  */
3424
3425                   case N_OBJ:           /* Useless types from Solaris.  */
3426                   case N_OPT:
3427                     /* These symbols aren't interesting; don't worry about
3428                        them.  */
3429
3430                     continue;
3431
3432                   default:
3433                     /* If we haven't found it yet, ignore it.  It's
3434                        probably some new type we don't know about yet.  */
3435                     complaint (&symfile_complaints,
3436                                _("unknown symbol type %s"),
3437                                hex_string (type_code)); /* CUR_SYMBOL_TYPE */
3438                     continue;
3439                   }
3440                 if (stabstring
3441                     && stabstring != debug_info->ss + fh->issBase + sh.iss)
3442                   xfree (stabstring);
3443               }
3444               /* end - Handle continuation */
3445             }
3446         }
3447       else
3448         {
3449           for (cur_sdx = 0; cur_sdx < fh->csym;)
3450             {
3451               char *name;
3452               enum address_class class;
3453
3454               (*swap_sym_in) (cur_bfd,
3455                               ((char *) debug_info->external_sym
3456                                + ((fh->isymBase + cur_sdx)
3457                                   * external_sym_size)),
3458                               &sh);
3459
3460               if (ECOFF_IS_STAB (&sh))
3461                 {
3462                   cur_sdx++;
3463                   continue;
3464                 }
3465
3466               /* Non absolute static symbols go into the minimal table.  */
3467               if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil
3468                   || (sh.index == indexNil
3469                       && (sh.st != stStatic || sh.sc == scAbs)))
3470                 {
3471                   /* FIXME, premature?  */
3472                   cur_sdx++;
3473                   continue;
3474                 }
3475
3476               name = debug_info->ss + fh->issBase + sh.iss;
3477
3478               switch (sh.sc)
3479                 {
3480                 case scText:
3481                 case scRConst:
3482                   /* The value of a stEnd symbol is the displacement from the
3483                      corresponding start symbol value, do not relocate it.  */
3484                   if (sh.st != stEnd)
3485                     sh.value += ANOFFSET (objfile->section_offsets,
3486                                           SECT_OFF_TEXT (objfile));
3487                   break;
3488                 case scData:
3489                 case scSData:
3490                 case scRData:
3491                 case scPData:
3492                 case scXData:
3493                   sh.value += ANOFFSET (objfile->section_offsets,
3494                                         SECT_OFF_DATA (objfile));
3495                   break;
3496                 case scBss:
3497                 case scSBss:
3498                   sh.value += ANOFFSET (objfile->section_offsets,
3499                                         SECT_OFF_BSS (objfile));
3500                   break;
3501                 }
3502
3503               switch (sh.st)
3504                 {
3505                   CORE_ADDR high;
3506                   CORE_ADDR procaddr;
3507                   int new_sdx;
3508
3509                 case stStaticProc:
3510                   prim_record_minimal_symbol_and_info (name, sh.value,
3511                                                        mst_file_text,
3512                                                        SECT_OFF_TEXT (objfile),
3513                                                        NULL, objfile);
3514
3515                   /* FALLTHROUGH */
3516
3517                 case stProc:
3518                   /* Ignore all parameter symbol records.  */
3519                   if (sh.index >= hdr->iauxMax)
3520                     {
3521                       /* Should not happen, but does when cross-compiling
3522                          with the MIPS compiler.  FIXME -- pull later.  */
3523                       index_complaint (name);
3524                       new_sdx = cur_sdx + 1;    /* Don't skip at all.  */
3525                     }
3526                   else
3527                     new_sdx = AUX_GET_ISYM (fh->fBigendian,
3528                                             (debug_info->external_aux
3529                                              + fh->iauxBase
3530                                              + sh.index));
3531
3532                   if (new_sdx <= cur_sdx)
3533                     {
3534                       /* This should not happen either... FIXME.  */
3535                       complaint (&symfile_complaints,
3536                                  _("bad proc end in aux found from symbol %s"),
3537                                  name);
3538                       new_sdx = cur_sdx + 1;    /* Don't skip backward.  */
3539                     }
3540
3541                   /* For stProc symbol records, we need to check the
3542                      storage class as well, as only (stProc, scText)
3543                      entries represent "real" procedures - See the
3544                      Compaq document titled "Object File / Symbol Table
3545                      Format Specification" for more information.  If the
3546                      storage class is not scText, we discard the whole
3547                      block of symbol records for this stProc.  */
3548                   if (sh.st == stProc && sh.sc != scText)
3549                     goto skip;
3550
3551                   /* Usually there is a local and a global stProc symbol
3552                      for a function.  This means that the function name
3553                      has already been entered into the mimimal symbol table
3554                      while processing the global symbols in pass 2 above.
3555                      One notable exception is the PROGRAM name from
3556                      f77 compiled executables, it is only put out as
3557                      local stProc symbol, and a global MAIN__ stProc symbol
3558                      points to it.  It doesn't matter though, as gdb is
3559                      still able to find the PROGRAM name via the partial
3560                      symbol table, and the MAIN__ symbol via the minimal
3561                      symbol table.  */
3562                   if (sh.st == stProc)
3563                     add_psymbol_to_list (name, strlen (name), 1,
3564                                          VAR_DOMAIN, LOC_BLOCK,
3565                                          &objfile->global_psymbols,
3566                                     0, sh.value, psymtab_language, objfile);
3567                   else
3568                     add_psymbol_to_list (name, strlen (name), 1,
3569                                          VAR_DOMAIN, LOC_BLOCK,
3570                                          &objfile->static_psymbols,
3571                                     0, sh.value, psymtab_language, objfile);
3572
3573                   procaddr = sh.value;
3574
3575                   cur_sdx = new_sdx;
3576                   (*swap_sym_in) (cur_bfd,
3577                                   ((char *) debug_info->external_sym
3578                                    + ((fh->isymBase + cur_sdx - 1)
3579                                       * external_sym_size)),
3580                                   &sh);
3581                   if (sh.st != stEnd)
3582                     continue;
3583
3584                   /* Kludge for Irix 5.2 zero fh->adr.  */
3585                   if (!relocatable
3586                       && (pst->textlow == 0 || procaddr < pst->textlow))
3587                     pst->textlow = procaddr;
3588
3589                   high = procaddr + sh.value;
3590                   if (high > pst->texthigh)
3591                     pst->texthigh = high;
3592                   continue;
3593
3594                 case stStatic:  /* Variable */
3595                   if (SC_IS_DATA (sh.sc))
3596                     prim_record_minimal_symbol_and_info (name, sh.value,
3597                                                          mst_file_data,
3598                                                          SECT_OFF_DATA (objfile),
3599                                                          NULL,
3600                                                          objfile);
3601                   else
3602                     prim_record_minimal_symbol_and_info (name, sh.value,
3603                                                          mst_file_bss,
3604                                                          SECT_OFF_BSS (objfile),
3605                                                          NULL,
3606                                                          objfile);
3607                   class = LOC_STATIC;
3608                   break;
3609
3610                 case stIndirect:        /* Irix5 forward declaration */
3611                   /* Skip forward declarations from Irix5 cc.  */
3612                   goto skip;
3613
3614                 case stTypedef: /* Typedef */
3615                   /* Skip typedefs for forward declarations and opaque
3616                      structs from alpha and mips cc.  */
3617                   if (sh.iss == 0 || has_opaque_xref (fh, &sh))
3618                     goto skip;
3619                   class = LOC_TYPEDEF;
3620                   break;
3621
3622                 case stConstant:        /* Constant decl */
3623                   class = LOC_CONST;
3624                   break;
3625
3626                 case stUnion:
3627                 case stStruct:
3628                 case stEnum:
3629                 case stBlock:   /* { }, str, un, enum */
3630                   /* Do not create a partial symbol for cc unnamed aggregates
3631                      and gcc empty aggregates.  */
3632                   if ((sh.sc == scInfo
3633                        || SC_IS_COMMON (sh.sc))
3634                       && sh.iss != 0
3635                       && sh.index != cur_sdx + 2)
3636                     {
3637                       add_psymbol_to_list (name, strlen (name), 1,
3638                                            STRUCT_DOMAIN, LOC_TYPEDEF,
3639                                            &objfile->static_psymbols,
3640                                            0, (CORE_ADDR) 0,
3641                                            psymtab_language, objfile);
3642                     }
3643                   handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
3644
3645                   /* Skip over the block.  */
3646                   new_sdx = sh.index;
3647                   if (new_sdx <= cur_sdx)
3648                     {
3649                       /* This happens with the Ultrix kernel.  */
3650                       complaint (&symfile_complaints,
3651                                  _("bad aux index at block symbol %s"), name);
3652                       new_sdx = cur_sdx + 1;    /* Don't skip backward.  */
3653                     }
3654                   cur_sdx = new_sdx;
3655                   continue;
3656
3657                 case stFile:    /* File headers */
3658                 case stLabel:   /* Labels */
3659                 case stEnd:     /* Ends of files */
3660                   goto skip;
3661
3662                 case stLocal:   /* Local variables */
3663                   /* Normally these are skipped because we skip over
3664                      all blocks we see.  However, these can occur
3665                      as visible symbols in a .h file that contains code.  */
3666                   goto skip;
3667
3668                 default:
3669                   /* Both complaints are valid:  one gives symbol name,
3670                      the other the offending symbol type.  */
3671                   complaint (&symfile_complaints, _("unknown local symbol %s"),
3672                              name);
3673                   complaint (&symfile_complaints, _("with type %d"), sh.st);
3674                   cur_sdx++;
3675                   continue;
3676                 }
3677               /* Use this gdb symbol.  */
3678               add_psymbol_to_list (name, strlen (name), 1,
3679                                    VAR_DOMAIN, class,
3680                                    &objfile->static_psymbols,
3681                                    0, sh.value, psymtab_language, objfile);
3682             skip:
3683               cur_sdx++;        /* Go to next file symbol.  */
3684             }
3685
3686           /* Now do enter the external symbols.  */
3687           ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset];
3688           cur_sdx = fdr_to_pst[f_idx].n_globals;
3689           PST_PRIVATE (save_pst)->extern_count = cur_sdx;
3690           PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
3691           for (; --cur_sdx >= 0; ext_ptr++)
3692             {
3693               enum address_class class;
3694               SYMR *psh;
3695               char *name;
3696               CORE_ADDR svalue;
3697
3698               if (ext_ptr->ifd != f_idx)
3699                 internal_error (__FILE__, __LINE__,
3700                                 _("failed internal consistency check"));
3701               psh = &ext_ptr->asym;
3702
3703               /* Do not add undefined symbols to the partial symbol table.  */
3704               if (SC_IS_UNDEF (psh->sc) || psh->sc == scNil)
3705                 continue;
3706
3707               svalue = psh->value;
3708               switch (psh->sc)
3709                 {
3710                 case scText:
3711                 case scRConst:
3712                   svalue += ANOFFSET (objfile->section_offsets,
3713                                       SECT_OFF_TEXT (objfile));
3714                   break;
3715                 case scData:
3716                 case scSData:
3717                 case scRData:
3718                 case scPData:
3719                 case scXData:
3720                   svalue += ANOFFSET (objfile->section_offsets,
3721                                       SECT_OFF_DATA (objfile));
3722                   break;
3723                 case scBss:
3724                 case scSBss:
3725                   svalue += ANOFFSET (objfile->section_offsets,
3726                                       SECT_OFF_BSS (objfile));
3727                   break;
3728                 }
3729
3730               switch (psh->st)
3731                 {
3732                 case stNil:
3733                   /* These are generated for static symbols in .o files,
3734                      ignore them.  */
3735                   continue;
3736                 case stProc:
3737                 case stStaticProc:
3738                   /* External procedure symbols have been entered
3739                      into the minimal symbol table in pass 2 above.
3740                      Ignore them, as parse_external will ignore them too.  */
3741                   continue;
3742                 case stLabel:
3743                   class = LOC_LABEL;
3744                   break;
3745                 default:
3746                   unknown_ext_complaint (debug_info->ssext + psh->iss);
3747                   /* Fall through, pretend it's global.  */
3748                 case stGlobal:
3749                   /* Global common symbols are resolved by the runtime loader,
3750                      ignore them.  */
3751                   if (SC_IS_COMMON (psh->sc))
3752                     continue;
3753
3754                   class = LOC_STATIC;
3755                   break;
3756                 }
3757               name = debug_info->ssext + psh->iss;
3758               add_psymbol_to_list (name, strlen (name), 1,
3759                                    VAR_DOMAIN, class,
3760                                    &objfile->global_psymbols,
3761                                    0, svalue,
3762                                    psymtab_language, objfile);
3763             }
3764         }
3765
3766       /* Link pst to FDR.  end_psymtab returns NULL if the psymtab was
3767          empty and put on the free list.  */
3768       fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
3769                                         psymtab_include_list, includes_used,
3770                                            -1, save_pst->texthigh,
3771                        dependency_list, dependencies_used, textlow_not_set);
3772       includes_used = 0;
3773       dependencies_used = 0;
3774
3775       /* The objfile has its functions reordered if this partial symbol
3776          table overlaps any other partial symbol table.
3777          We cannot assume a reordered objfile if a partial symbol table
3778          is contained within another partial symbol table, as partial symbol
3779          tables for include files with executable code are contained
3780          within the partial symbol table for the including source file,
3781          and we do not want to flag the objfile reordered for these cases.
3782
3783          This strategy works well for Irix-5.2 shared libraries, but we
3784          might have to use a more elaborate (and slower) algorithm for
3785          other cases.  */
3786       save_pst = fdr_to_pst[f_idx].pst;
3787       if (save_pst != NULL
3788           && save_pst->textlow != 0
3789           && !(objfile->flags & OBJF_REORDERED))
3790         {
3791           ALL_OBJFILE_PSYMTABS (objfile, pst)
3792           {
3793             if (save_pst != pst
3794                 && save_pst->textlow >= pst->textlow
3795                 && save_pst->textlow < pst->texthigh
3796                 && save_pst->texthigh > pst->texthigh)
3797               {
3798                 objfile->flags |= OBJF_REORDERED;
3799                 break;
3800               }
3801           }
3802         }
3803     }
3804
3805   /* Now scan the FDRs for dependencies.  */
3806   for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
3807     {
3808       fh = f_idx + debug_info->fdr;
3809       pst = fdr_to_pst[f_idx].pst;
3810
3811       if (pst == (struct partial_symtab *) NULL)
3812         continue;
3813
3814       /* This should catch stabs-in-ecoff.  */
3815       if (fh->crfd <= 1)
3816         continue;
3817
3818       /* Skip the first file indirect entry as it is a self dependency for
3819          source files or a reverse .h -> .c dependency for header files.  */
3820       pst->number_of_dependencies = 0;
3821       pst->dependencies =
3822         ((struct partial_symtab **)
3823          obstack_alloc (&objfile->objfile_obstack,
3824                         ((fh->crfd - 1)
3825                          * sizeof (struct partial_symtab *))));
3826       for (s_idx = 1; s_idx < fh->crfd; s_idx++)
3827         {
3828           RFDT rh;
3829
3830           (*swap_rfd_in) (cur_bfd,
3831                           ((char *) debug_info->external_rfd
3832                            + (fh->rfdBase + s_idx) * external_rfd_size),
3833                           &rh);
3834           if (rh < 0 || rh >= hdr->ifdMax)
3835             {
3836               complaint (&symfile_complaints, _("bad file number %ld"), rh);
3837               continue;
3838             }
3839
3840           /* Skip self dependencies of header files.  */
3841           if (rh == f_idx)
3842             continue;
3843
3844           /* Do not add to dependeny list if psymtab was empty.  */
3845           if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL)
3846             continue;
3847           pst->dependencies[pst->number_of_dependencies++]
3848             = fdr_to_pst[rh].pst;
3849         }
3850     }
3851
3852   /* Remove the dummy psymtab created for -O3 images above, if it is
3853      still empty, to enable the detection of stripped executables.  */
3854   if (objfile->psymtabs->next == NULL
3855       && objfile->psymtabs->number_of_dependencies == 0
3856       && objfile->psymtabs->n_global_syms == 0
3857       && objfile->psymtabs->n_static_syms == 0)
3858     objfile->psymtabs = NULL;
3859   do_cleanups (old_chain);
3860 }
3861
3862 /* If the current psymbol has an enumerated type, we need to add
3863    all the enum constants to the partial symbol table.  */
3864
3865 static void
3866 handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
3867                             CORE_ADDR svalue)
3868 {
3869   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
3870   void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
3871   char *ext_sym = ((char *) debug_info->external_sym
3872                    + ((fh->isymBase + cur_sdx + 1) * external_sym_size));
3873   SYMR sh;
3874   TIR tir;
3875
3876   switch (stype)
3877     {
3878     case stEnum:
3879       break;
3880
3881     case stBlock:
3882       /* It is an enumerated type if the next symbol entry is a stMember
3883          and its auxiliary index is indexNil or its auxiliary entry
3884          is a plain btNil or btVoid.
3885          Alpha cc -migrate enums are recognized by a zero index and
3886          a zero symbol value.
3887          DU 4.0 cc enums are recognized by a member type of btEnum without
3888          qualifiers and a zero symbol value.  */
3889       (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3890       if (sh.st != stMember)
3891         return;
3892
3893       if (sh.index == indexNil
3894           || (sh.index == 0 && svalue == 0))
3895         break;
3896       (*debug_swap->swap_tir_in) (fh->fBigendian,
3897                                   &(debug_info->external_aux
3898                                     + fh->iauxBase + sh.index)->a_ti,
3899                                   &tir);
3900       if ((tir.bt != btNil
3901            && tir.bt != btVoid
3902            && (tir.bt != btEnum || svalue != 0))
3903           || tir.tq0 != tqNil)
3904         return;
3905       break;
3906
3907     default:
3908       return;
3909     }
3910
3911   for (;;)
3912     {
3913       char *name;
3914
3915       (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3916       if (sh.st != stMember)
3917         break;
3918       name = debug_info->ss + cur_fdr->issBase + sh.iss;
3919
3920       /* Note that the value doesn't matter for enum constants
3921          in psymtabs, just in symtabs.  */
3922       add_psymbol_to_list (name, strlen (name), 1,
3923                            VAR_DOMAIN, LOC_CONST,
3924                            &objfile->static_psymbols, 0,
3925                            (CORE_ADDR) 0, psymtab_language, objfile);
3926       ext_sym += external_sym_size;
3927     }
3928 }
3929
3930 /* Get the next symbol.  OBJFILE is unused.  */
3931
3932 static char *
3933 mdebug_next_symbol_text (struct objfile *objfile)
3934 {
3935   SYMR sh;
3936
3937   cur_sdx++;
3938   (*debug_swap->swap_sym_in) (cur_bfd,
3939                               ((char *) debug_info->external_sym
3940                                + ((cur_fdr->isymBase + cur_sdx)
3941                                   * debug_swap->external_sym_size)),
3942                               &sh);
3943   return debug_info->ss + cur_fdr->issBase + sh.iss;
3944 }
3945
3946 /* Ancillary function to psymtab_to_symtab().  Does all the work
3947    for turning the partial symtab PST into a symtab, recurring
3948    first on all dependent psymtabs.  The argument FILENAME is
3949    only passed so we can see in debug stack traces what file
3950    is being read.
3951
3952    This function has a split personality, based on whether the
3953    symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3954    The flow of control and even the memory allocation differs.  FIXME.  */
3955
3956 static void
3957 psymtab_to_symtab_1 (struct partial_symtab *pst, const char *filename)
3958 {
3959   bfd_size_type external_sym_size;
3960   bfd_size_type external_pdr_size;
3961   void (*swap_sym_in) (bfd *, void *, SYMR *);
3962   void (*swap_pdr_in) (bfd *, void *, PDR *);
3963   int i;
3964   struct symtab *st = NULL;
3965   FDR *fh;
3966   struct linetable *lines;
3967   CORE_ADDR lowest_pdr_addr = 0;
3968   int last_symtab_ended = 0;
3969
3970   if (pst->readin)
3971     return;
3972   pst->readin = 1;
3973
3974   /* Read in all partial symbtabs on which this one is dependent.
3975      NOTE that we do have circular dependencies, sigh.  We solved
3976      that by setting pst->readin before this point.  */
3977
3978   for (i = 0; i < pst->number_of_dependencies; i++)
3979     if (!pst->dependencies[i]->readin)
3980       {
3981         /* Inform about additional files to be read in.  */
3982         if (info_verbose)
3983           {
3984             fputs_filtered (" ", gdb_stdout);
3985             wrap_here ("");
3986             fputs_filtered ("and ", gdb_stdout);
3987             wrap_here ("");
3988             printf_filtered ("%s...",
3989                              pst->dependencies[i]->filename);
3990             wrap_here ("");     /* Flush output */
3991             gdb_flush (gdb_stdout);
3992           }
3993         /* We only pass the filename for debug purposes.  */
3994         psymtab_to_symtab_1 (pst->dependencies[i],
3995                              pst->dependencies[i]->filename);
3996       }
3997
3998   /* Do nothing if this is a dummy psymtab.  */
3999
4000   if (pst->n_global_syms == 0 && pst->n_static_syms == 0
4001       && pst->textlow == 0 && pst->texthigh == 0)
4002     return;
4003
4004   /* Now read the symbols for this symtab.  */
4005
4006   cur_bfd = CUR_BFD (pst);
4007   debug_swap = DEBUG_SWAP (pst);
4008   debug_info = DEBUG_INFO (pst);
4009   pending_list = PENDING_LIST (pst);
4010   external_sym_size = debug_swap->external_sym_size;
4011   external_pdr_size = debug_swap->external_pdr_size;
4012   swap_sym_in = debug_swap->swap_sym_in;
4013   swap_pdr_in = debug_swap->swap_pdr_in;
4014   current_objfile = pst->objfile;
4015   cur_fd = FDR_IDX (pst);
4016   fh = ((cur_fd == -1)
4017         ? (FDR *) NULL
4018         : debug_info->fdr + cur_fd);
4019   cur_fdr = fh;
4020
4021   /* See comment in parse_partial_symbols about the @stabs sentinel.  */
4022   processing_gcc_compilation = 0;
4023   if (fh != (FDR *) NULL && fh->csym >= 2)
4024     {
4025       SYMR sh;
4026
4027       (*swap_sym_in) (cur_bfd,
4028                       ((char *) debug_info->external_sym
4029                        + (fh->isymBase + 1) * external_sym_size),
4030                       &sh);
4031       if (strcmp (debug_info->ss + fh->issBase + sh.iss,
4032                   stabs_symbol) == 0)
4033         {
4034           /* We indicate that this is a GCC compilation so that certain
4035              features will be enabled in stabsread/dbxread.  */
4036           processing_gcc_compilation = 2;
4037         }
4038     }
4039
4040   if (processing_gcc_compilation != 0)
4041     {
4042       struct gdbarch *gdbarch = get_objfile_arch (pst->objfile);
4043
4044       /* This symbol table contains stabs-in-ecoff entries.  */
4045
4046       /* Parse local symbols first.  */
4047
4048       if (fh->csym <= 2)        /* FIXME, this blows psymtab->symtab ptr.  */
4049         {
4050           current_objfile = NULL;
4051           return;
4052         }
4053       for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
4054         {
4055           SYMR sh;
4056           char *name;
4057           CORE_ADDR valu;
4058
4059           (*swap_sym_in) (cur_bfd,
4060                           (((char *) debug_info->external_sym)
4061                            + (fh->isymBase + cur_sdx) * external_sym_size),
4062                           &sh);
4063           name = debug_info->ss + fh->issBase + sh.iss;
4064           valu = sh.value;
4065           /* XXX This is a hack.  It will go away!  */
4066           if (ECOFF_IS_STAB (&sh) || (name[0] == '#'))
4067             {
4068               int type_code = ECOFF_UNMARK_STAB (sh.index);
4069
4070               /* We should never get non N_STAB symbols here, but they
4071                  should be harmless, so keep process_one_symbol from
4072                  complaining about them.  */
4073               if (type_code & N_STAB)
4074                 {
4075                   /* If we found a trailing N_SO with no name, process
4076                      it here instead of in process_one_symbol, so we
4077                      can keep a handle to its symtab.  The symtab
4078                      would otherwise be ended twice, once in
4079                      process_one_symbol, and once after this loop.  */
4080                   if (type_code == N_SO
4081                       && last_source_file
4082                       && previous_stab_code != (unsigned char) N_SO
4083                       && *name == '\000')
4084                     {
4085                       valu += ANOFFSET (pst->section_offsets,
4086                                         SECT_OFF_TEXT (pst->objfile));
4087                       previous_stab_code = N_SO;
4088                       st = end_symtab (valu, pst->objfile,
4089                                        SECT_OFF_TEXT (pst->objfile));
4090                       end_stabs ();
4091                       last_symtab_ended = 1;
4092                     }
4093                   else
4094                     {
4095                       last_symtab_ended = 0;
4096                       process_one_symbol (type_code, 0, valu, name,
4097                                           pst->section_offsets, pst->objfile);
4098                     }
4099                 }
4100               /* Similarly a hack.  */
4101               else if (name[0] == '#')
4102                 {
4103                   process_one_symbol (N_SLINE, 0, valu, name,
4104                                       pst->section_offsets, pst->objfile);
4105                 }
4106               if (type_code == N_FUN)
4107                 {
4108                   /* Make up special symbol to contain
4109                      procedure specific info.  */
4110                   struct mdebug_extra_func_info *e =
4111                     ((struct mdebug_extra_func_info *)
4112                      obstack_alloc (&current_objfile->objfile_obstack,
4113                                     sizeof (struct mdebug_extra_func_info)));
4114                   struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
4115
4116                   memset (e, 0, sizeof (struct mdebug_extra_func_info));
4117                   SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
4118                   SYMBOL_CLASS (s) = LOC_CONST;
4119                   SYMBOL_TYPE (s) = objfile_type (pst->objfile)->builtin_void;
4120                   SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
4121                   e->pdr.framereg = -1;
4122                   add_symbol_to_list (s, &local_symbols);
4123                 }
4124             }
4125           else if (sh.st == stLabel)
4126             {
4127               if (sh.index == indexNil)
4128                 {
4129                   /* This is what the gcc2_compiled and __gnu_compiled_*
4130                      show up as.  So don't complain.  */
4131                   ;
4132                 }
4133               else
4134                 {
4135                   /* Handle encoded stab line number.  */
4136                   valu += ANOFFSET (pst->section_offsets,
4137                                     SECT_OFF_TEXT (pst->objfile));
4138                   record_line (current_subfile, sh.index,
4139                                gdbarch_addr_bits_remove (gdbarch, valu));
4140                 }
4141             }
4142           else if (sh.st == stProc || sh.st == stStaticProc
4143                    || sh.st == stStatic || sh.st == stEnd)
4144             /* These are generated by gcc-2.x, do not complain.  */
4145             ;
4146           else
4147             complaint (&symfile_complaints,
4148                        _("unknown stabs symbol %s"), name);
4149         }
4150
4151       if (! last_symtab_ended)
4152         {
4153           st = end_symtab (pst->texthigh, pst->objfile,
4154                            SECT_OFF_TEXT (pst->objfile));
4155           end_stabs ();
4156         }
4157
4158       /* There used to be a call to sort_blocks here, but this should not
4159          be necessary for stabs symtabs.  And as sort_blocks modifies the
4160          start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
4161          it did the wrong thing if the first procedure in a file was
4162          generated via asm statements.  */
4163
4164       /* Fill in procedure info next.  */
4165       if (fh->cpd > 0)
4166         {
4167           PDR *pr_block;
4168           struct cleanup *old_chain;
4169           char *pdr_ptr;
4170           char *pdr_end;
4171           PDR *pdr_in;
4172           PDR *pdr_in_end;
4173
4174           pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
4175           old_chain = make_cleanup (xfree, pr_block);
4176
4177           pdr_ptr = ((char *) debug_info->external_pdr
4178                      + fh->ipdFirst * external_pdr_size);
4179           pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
4180           pdr_in = pr_block;
4181           for (;
4182                pdr_ptr < pdr_end;
4183                pdr_ptr += external_pdr_size, pdr_in++)
4184             {
4185               (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
4186
4187               /* Determine lowest PDR address, the PDRs are not always
4188                  sorted.  */
4189               if (pdr_in == pr_block)
4190                 lowest_pdr_addr = pdr_in->adr;
4191               else if (pdr_in->adr < lowest_pdr_addr)
4192                 lowest_pdr_addr = pdr_in->adr;
4193             }
4194
4195           pdr_in = pr_block;
4196           pdr_in_end = pdr_in + fh->cpd;
4197           for (; pdr_in < pdr_in_end; pdr_in++)
4198             parse_procedure (pdr_in, st, pst);
4199
4200           do_cleanups (old_chain);
4201         }
4202     }
4203   else
4204     {
4205       /* This symbol table contains ordinary ecoff entries.  */
4206
4207       int maxlines;
4208       EXTR *ext_ptr;
4209
4210       if (fh == 0)
4211         {
4212           maxlines = 0;
4213           st = new_symtab ("unknown", 0, pst->objfile);
4214         }
4215       else
4216         {
4217           maxlines = 2 * fh->cline;
4218           st = new_symtab (pst->filename, maxlines, pst->objfile);
4219
4220           /* The proper language was already determined when building
4221              the psymtab, use it.  */
4222           st->language = PST_PRIVATE (pst)->pst_language;
4223         }
4224
4225       psymtab_language = st->language;
4226
4227       lines = LINETABLE (st);
4228
4229       /* Get a new lexical context.  */
4230
4231       push_parse_stack ();
4232       top_stack->cur_st = st;
4233       top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
4234                                                 STATIC_BLOCK);
4235       BLOCK_START (top_stack->cur_block) = pst->textlow;
4236       BLOCK_END (top_stack->cur_block) = 0;
4237       top_stack->blocktype = stFile;
4238       top_stack->cur_type = 0;
4239       top_stack->procadr = 0;
4240       top_stack->numargs = 0;
4241       found_ecoff_debugging_info = 0;
4242
4243       if (fh)
4244         {
4245           char *sym_ptr;
4246           char *sym_end;
4247
4248           /* Parse local symbols first.  */
4249           sym_ptr = ((char *) debug_info->external_sym
4250                      + fh->isymBase * external_sym_size);
4251           sym_end = sym_ptr + fh->csym * external_sym_size;
4252           while (sym_ptr < sym_end)
4253             {
4254               SYMR sh;
4255               int c;
4256
4257               (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
4258               c = parse_symbol (&sh,
4259                                 debug_info->external_aux + fh->iauxBase,
4260                                 sym_ptr, fh->fBigendian,
4261                                 pst->section_offsets, pst->objfile);
4262               sym_ptr += c * external_sym_size;
4263             }
4264
4265           /* Linenumbers.  At the end, check if we can save memory.
4266              parse_lines has to look ahead an arbitrary number of PDR
4267              structures, so we swap them all first.  */
4268           if (fh->cpd > 0)
4269             {
4270               PDR *pr_block;
4271               struct cleanup *old_chain;
4272               char *pdr_ptr;
4273               char *pdr_end;
4274               PDR *pdr_in;
4275               PDR *pdr_in_end;
4276
4277               pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
4278
4279               old_chain = make_cleanup (xfree, pr_block);
4280
4281               pdr_ptr = ((char *) debug_info->external_pdr
4282                          + fh->ipdFirst * external_pdr_size);
4283               pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
4284               pdr_in = pr_block;
4285               for (;
4286                    pdr_ptr < pdr_end;
4287                    pdr_ptr += external_pdr_size, pdr_in++)
4288                 {
4289                   (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
4290
4291                   /* Determine lowest PDR address, the PDRs are not always
4292                      sorted.  */
4293                   if (pdr_in == pr_block)
4294                     lowest_pdr_addr = pdr_in->adr;
4295                   else if (pdr_in->adr < lowest_pdr_addr)
4296                     lowest_pdr_addr = pdr_in->adr;
4297                 }
4298
4299               parse_lines (fh, pr_block, lines, maxlines,
4300                            pst, lowest_pdr_addr);
4301               if (lines->nitems < fh->cline)
4302                 lines = shrink_linetable (lines);
4303
4304               /* Fill in procedure info next.  */
4305               pdr_in = pr_block;
4306               pdr_in_end = pdr_in + fh->cpd;
4307               for (; pdr_in < pdr_in_end; pdr_in++)
4308                 parse_procedure (pdr_in, 0, pst);
4309
4310               do_cleanups (old_chain);
4311             }
4312         }
4313
4314       LINETABLE (st) = lines;
4315
4316       /* .. and our share of externals.
4317          XXX use the global list to speed up things here.  How?
4318          FIXME, Maybe quit once we have found the right number of ext's?  */
4319       top_stack->cur_st = st;
4320       top_stack->cur_block
4321         = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
4322                              GLOBAL_BLOCK);
4323       top_stack->blocktype = stFile;
4324
4325       ext_ptr = PST_PRIVATE (pst)->extern_tab;
4326       for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
4327         parse_external (ext_ptr, fh->fBigendian,
4328                         pst->section_offsets, pst->objfile);
4329
4330       /* If there are undefined symbols, tell the user.
4331          The alpha has an undefined symbol for every symbol that is
4332          from a shared library, so tell the user only if verbose is on.  */
4333       if (info_verbose && n_undef_symbols)
4334         {
4335           printf_filtered (_("File %s contains %d unresolved references:"),
4336                            st->filename, n_undef_symbols);
4337           printf_filtered ("\n\t%4d variables\n\t%4d "
4338                            "procedures\n\t%4d labels\n",
4339                            n_undef_vars, n_undef_procs, n_undef_labels);
4340           n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0;
4341
4342         }
4343       pop_parse_stack ();
4344
4345       st->primary = 1;
4346
4347       sort_blocks (st);
4348     }
4349
4350   /* Now link the psymtab and the symtab.  */
4351   pst->symtab = st;
4352
4353   current_objfile = NULL;
4354 }
4355 \f
4356 /* Ancillary parsing procedures.  */
4357
4358 /* Return 1 if the symbol pointed to by SH has a cross reference
4359    to an opaque aggregate type, else 0.  */
4360
4361 static int
4362 has_opaque_xref (FDR *fh, SYMR *sh)
4363 {
4364   TIR tir;
4365   union aux_ext *ax;
4366   RNDXR rn[1];
4367   unsigned int rf;
4368
4369   if (sh->index == indexNil)
4370     return 0;
4371
4372   ax = debug_info->external_aux + fh->iauxBase + sh->index;
4373   (*debug_swap->swap_tir_in) (fh->fBigendian, &ax->a_ti, &tir);
4374   if (tir.bt != btStruct && tir.bt != btUnion && tir.bt != btEnum)
4375     return 0;
4376
4377   ax++;
4378   (*debug_swap->swap_rndx_in) (fh->fBigendian, &ax->a_rndx, rn);
4379   if (rn->rfd == 0xfff)
4380     rf = AUX_GET_ISYM (fh->fBigendian, ax + 1);
4381   else
4382     rf = rn->rfd;
4383   if (rf != -1)
4384     return 0;
4385   return 1;
4386 }
4387
4388 /* Lookup the type at relative index RN.  Return it in TPP
4389    if found and in any event come up with its name PNAME.
4390    BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4391    Return value says how many aux symbols we ate.  */
4392
4393 static int
4394 cross_ref (int fd, union aux_ext *ax, struct type **tpp,
4395            enum type_code type_code,
4396            /* Use to alloc new type if none is found.  */
4397            char **pname, int bigend, char *sym_name)
4398 {
4399   RNDXR rn[1];
4400   unsigned int rf;
4401   int result = 1;
4402   FDR *fh;
4403   char *esh;
4404   SYMR sh;
4405   int xref_fd;
4406   struct mdebug_pending *pend;
4407
4408   *tpp = (struct type *) NULL;
4409
4410   (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
4411
4412   /* Escape index means 'the next one'.  */
4413   if (rn->rfd == 0xfff)
4414     {
4415       result++;
4416       rf = AUX_GET_ISYM (bigend, ax + 1);
4417     }
4418   else
4419     {
4420       rf = rn->rfd;
4421     }
4422
4423   /* mips cc uses a rf of -1 for opaque struct definitions.
4424      Set TYPE_FLAG_STUB for these types so that check_typedef will
4425      resolve them if the struct gets defined in another compilation unit.  */
4426   if (rf == -1)
4427     {
4428       *pname = "<undefined>";
4429       *tpp = init_type (type_code, 0, TYPE_FLAG_STUB,
4430                         (char *) NULL, current_objfile);
4431       return result;
4432     }
4433
4434   /* mips cc uses an escaped rn->index of 0 for struct return types
4435      of procedures that were compiled without -g.  These will always remain
4436      undefined.  */
4437   if (rn->rfd == 0xfff && rn->index == 0)
4438     {
4439       *pname = "<undefined>";
4440       return result;
4441     }
4442
4443   /* Find the relative file descriptor and the symbol in it.  */
4444   fh = get_rfd (fd, rf);
4445   xref_fd = fh - debug_info->fdr;
4446
4447   if (rn->index >= fh->csym)
4448     {
4449       /* File indirect entry is corrupt.  */
4450       *pname = "<illegal>";
4451       bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4452       return result;
4453     }
4454
4455   /* If we have processed this symbol then we left a forwarding
4456      pointer to the type in the pending list.  If not, we`ll put
4457      it in a list of pending types, to be processed later when
4458      the file will be.  In any event, we collect the name for the
4459      type here.  */
4460
4461   esh = ((char *) debug_info->external_sym
4462          + ((fh->isymBase + rn->index)
4463             * debug_swap->external_sym_size));
4464   (*debug_swap->swap_sym_in) (cur_bfd, esh, &sh);
4465
4466   /* Make sure that this type of cross reference can be handled.  */
4467   if ((sh.sc != scInfo
4468        || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect
4469            && sh.st != stStruct && sh.st != stUnion
4470            && sh.st != stEnum))
4471       && (sh.st != stBlock || !SC_IS_COMMON (sh.sc)))
4472     {
4473       /* File indirect entry is corrupt.  */
4474       *pname = "<illegal>";
4475       bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4476       return result;
4477     }
4478
4479   *pname = debug_info->ss + fh->issBase + sh.iss;
4480
4481   pend = is_pending_symbol (fh, esh);
4482   if (pend)
4483     *tpp = pend->t;
4484   else
4485     {
4486       /* We have not yet seen this type.  */
4487
4488       if ((sh.iss == 0 && sh.st == stTypedef) || sh.st == stIndirect)
4489         {
4490           TIR tir;
4491
4492           /* alpha cc puts out a stTypedef with a sh.iss of zero for
4493              two cases:
4494              a) forward declarations of structs/unions/enums which are not
4495              defined in this compilation unit.
4496              For these the type will be void.  This is a bad design decision
4497              as cross referencing across compilation units is impossible
4498              due to the missing name.
4499              b) forward declarations of structs/unions/enums/typedefs which
4500              are defined later in this file or in another file in the same
4501              compilation unit.  Irix5 cc uses a stIndirect symbol for this.
4502              Simply cross reference those again to get the true type.
4503              The forward references are not entered in the pending list and
4504              in the symbol table.  */
4505
4506           (*debug_swap->swap_tir_in) (bigend,
4507                                       &(debug_info->external_aux
4508                                         + fh->iauxBase + sh.index)->a_ti,
4509                                       &tir);
4510           if (tir.tq0 != tqNil)
4511             complaint (&symfile_complaints,
4512                        _("illegal tq0 in forward typedef for %s"), sym_name);
4513           switch (tir.bt)
4514             {
4515             case btVoid:
4516               *tpp = init_type (type_code, 0, 0, (char *) NULL,
4517                                 current_objfile);
4518               *pname = "<undefined>";
4519               break;
4520
4521             case btStruct:
4522             case btUnion:
4523             case btEnum:
4524               cross_ref (xref_fd,
4525                          (debug_info->external_aux
4526                           + fh->iauxBase + sh.index + 1),
4527                          tpp, type_code, pname,
4528                          fh->fBigendian, sym_name);
4529               break;
4530
4531             case btTypedef:
4532               /* Follow a forward typedef.  This might recursively
4533                  call cross_ref till we get a non typedef'ed type.
4534                  FIXME: This is not correct behaviour, but gdb currently
4535                  cannot handle typedefs without type copying.  Type
4536                  copying is impossible as we might have mutual forward
4537                  references between two files and the copied type would not
4538                  get filled in when we later parse its definition.  */
4539               *tpp = parse_type (xref_fd,
4540                                  debug_info->external_aux + fh->iauxBase,
4541                                  sh.index,
4542                                  (int *) NULL,
4543                                  fh->fBigendian,
4544                                  debug_info->ss + fh->issBase + sh.iss);
4545               add_pending (fh, esh, *tpp);
4546               break;
4547
4548             default:
4549               complaint (&symfile_complaints,
4550                          _("illegal bt %d in forward typedef for %s"), tir.bt,
4551                          sym_name);
4552               *tpp = init_type (type_code, 0, 0, (char *) NULL,
4553                                 current_objfile);
4554               break;
4555             }
4556           return result;
4557         }
4558       else if (sh.st == stTypedef)
4559         {
4560           /* Parse the type for a normal typedef.  This might recursively call
4561              cross_ref till we get a non typedef'ed type.
4562              FIXME: This is not correct behaviour, but gdb currently
4563              cannot handle typedefs without type copying.  But type copying is
4564              impossible as we might have mutual forward references between
4565              two files and the copied type would not get filled in when
4566              we later parse its definition.   */
4567           *tpp = parse_type (xref_fd,
4568                              debug_info->external_aux + fh->iauxBase,
4569                              sh.index,
4570                              (int *) NULL,
4571                              fh->fBigendian,
4572                              debug_info->ss + fh->issBase + sh.iss);
4573         }
4574       else
4575         {
4576           /* Cross reference to a struct/union/enum which is defined
4577              in another file in the same compilation unit but that file
4578              has not been parsed yet.
4579              Initialize the type only, it will be filled in when
4580              it's definition is parsed.  */
4581           *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
4582         }
4583       add_pending (fh, esh, *tpp);
4584     }
4585
4586   /* We used one auxent normally, two if we got a "next one" rf.  */
4587   return result;
4588 }
4589
4590
4591 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4592    keeping the symtab sorted.  */
4593
4594 static struct symbol *
4595 mylookup_symbol (char *name, struct block *block,
4596                  domain_enum domain, enum address_class class)
4597 {
4598   struct dict_iterator iter;
4599   int inc;
4600   struct symbol *sym;
4601
4602   inc = name[0];
4603   ALL_BLOCK_SYMBOLS (block, iter, sym)
4604     {
4605       if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
4606           && SYMBOL_DOMAIN (sym) == domain
4607           && SYMBOL_CLASS (sym) == class
4608           && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0)
4609         return sym;
4610     }
4611
4612   block = BLOCK_SUPERBLOCK (block);
4613   if (block)
4614     return mylookup_symbol (name, block, domain, class);
4615   return 0;
4616 }
4617
4618
4619 /* Add a new symbol S to a block B.  */
4620
4621 static void
4622 add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
4623 {
4624   SYMBOL_SYMTAB (s) = symtab;
4625   dict_add_symbol (BLOCK_DICT (b), s);
4626 }
4627
4628 /* Add a new block B to a symtab S.  */
4629
4630 static void
4631 add_block (struct block *b, struct symtab *s)
4632 {
4633   struct blockvector *bv = BLOCKVECTOR (s);
4634
4635   bv = (struct blockvector *) xrealloc ((void *) bv,
4636                                         (sizeof (struct blockvector)
4637                                          + BLOCKVECTOR_NBLOCKS (bv)
4638                                          * sizeof (bv->block)));
4639   if (bv != BLOCKVECTOR (s))
4640     BLOCKVECTOR (s) = bv;
4641
4642   BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b;
4643 }
4644
4645 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4646    MIPS' linenumber encoding might need more than one byte
4647    to describe it, LAST is used to detect these continuation lines.
4648
4649    Combining lines with the same line number seems like a bad idea.
4650    E.g: There could be a line number entry with the same line number after the
4651    prologue and GDB should not ignore it (this is a better way to find
4652    a prologue than mips_skip_prologue).
4653    But due to the compressed line table format there are line number entries
4654    for the same line which are needed to bridge the gap to the next
4655    line number entry.  These entries have a bogus address info with them
4656    and we are unable to tell them from intended duplicate line number
4657    entries.
4658    This is another reason why -ggdb debugging format is preferable.  */
4659
4660 static int
4661 add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last)
4662 {
4663   /* DEC c89 sometimes produces zero linenos which confuse gdb.
4664      Change them to something sensible.  */
4665   if (lineno == 0)
4666     lineno = 1;
4667   if (last == 0)
4668     last = -2;                  /* Make sure we record first line.  */
4669
4670   if (last == lineno)           /* Skip continuation lines.  */
4671     return lineno;
4672
4673   lt->item[lt->nitems].line = lineno;
4674   lt->item[lt->nitems++].pc = adr << 2;
4675   return lineno;
4676 }
4677 \f
4678 /* Sorting and reordering procedures.  */
4679
4680 /* Blocks with a smaller low bound should come first.  */
4681
4682 static int
4683 compare_blocks (const void *arg1, const void *arg2)
4684 {
4685   LONGEST addr_diff;
4686   struct block **b1 = (struct block **) arg1;
4687   struct block **b2 = (struct block **) arg2;
4688
4689   addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2)));
4690   if (addr_diff == 0)
4691     return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1)));
4692   return addr_diff;
4693 }
4694
4695 /* Sort the blocks of a symtab S.
4696    Reorder the blocks in the blockvector by code-address,
4697    as required by some MI search routines.  */
4698
4699 static void
4700 sort_blocks (struct symtab *s)
4701 {
4702   struct blockvector *bv = BLOCKVECTOR (s);
4703
4704   if (BLOCKVECTOR_NBLOCKS (bv) <= 2)
4705     {
4706       /* Cosmetic */
4707       if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0)
4708         BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0;
4709       if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0)
4710         BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0;
4711       return;
4712     }
4713   /*
4714    * This is very unfortunate: normally all functions are compiled in
4715    * the order they are found, but if the file is compiled -O3 things
4716    * are very different.  It would be nice to find a reliable test
4717    * to detect -O3 images in advance.
4718    */
4719   if (BLOCKVECTOR_NBLOCKS (bv) > 3)
4720     qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
4721            BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK,
4722            sizeof (struct block *),
4723            compare_blocks);
4724
4725   {
4726     CORE_ADDR high = 0;
4727     int i, j = BLOCKVECTOR_NBLOCKS (bv);
4728
4729     for (i = FIRST_LOCAL_BLOCK; i < j; i++)
4730       if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)))
4731         high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i));
4732     BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high;
4733   }
4734
4735   BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) =
4736     BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK));
4737
4738   BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4739     BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4740   BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4741     BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4742 }
4743 \f
4744
4745 /* Constructor/restructor/destructor procedures.  */
4746
4747 /* Allocate a new symtab for NAME.  Needs an estimate of how many
4748    linenumbers MAXLINES we'll put in it.  */
4749
4750 static struct symtab *
4751 new_symtab (const char *name, int maxlines, struct objfile *objfile)
4752 {
4753   struct symtab *s = allocate_symtab (name, objfile);
4754
4755   LINETABLE (s) = new_linetable (maxlines);
4756
4757   /* All symtabs must have at least two blocks.  */
4758   BLOCKVECTOR (s) = new_bvect (2);
4759   BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK)
4760     = new_block (NON_FUNCTION_BLOCK);
4761   BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
4762     = new_block (NON_FUNCTION_BLOCK);
4763   BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
4764     BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4765
4766   s->free_code = free_linetable;
4767   s->debugformat = "ECOFF";
4768   return (s);
4769 }
4770
4771 /* Allocate a new partial_symtab NAME.  */
4772
4773 static struct partial_symtab *
4774 new_psymtab (char *name, struct objfile *objfile)
4775 {
4776   struct partial_symtab *psymtab;
4777
4778   psymtab = allocate_psymtab (name, objfile);
4779   psymtab->section_offsets = objfile->section_offsets;
4780
4781   /* Keep a backpointer to the file's symbols.  */
4782
4783   psymtab->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
4784                                                 sizeof (struct symloc));
4785   memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
4786   CUR_BFD (psymtab) = cur_bfd;
4787   DEBUG_SWAP (psymtab) = debug_swap;
4788   DEBUG_INFO (psymtab) = debug_info;
4789   PENDING_LIST (psymtab) = pending_list;
4790
4791   /* The way to turn this into a symtab is to call...  */
4792   psymtab->read_symtab = mdebug_psymtab_to_symtab;
4793   return (psymtab);
4794 }
4795
4796
4797 /* Allocate a linetable array of the given SIZE.  Since the struct
4798    already includes one item, we subtract one when calculating the
4799    proper size to allocate.  */
4800
4801 static struct linetable *
4802 new_linetable (int size)
4803 {
4804   struct linetable *l;
4805
4806   size = (size - 1) * sizeof (l->item) + sizeof (struct linetable);
4807   l = (struct linetable *) xmalloc (size);
4808   l->nitems = 0;
4809   return l;
4810 }
4811
4812 /* Oops, too big.  Shrink it.  This was important with the 2.4 linetables,
4813    I am not so sure about the 3.4 ones.
4814
4815    Since the struct linetable already includes one item, we subtract one when
4816    calculating the proper size to allocate.  */
4817
4818 static struct linetable *
4819 shrink_linetable (struct linetable *lt)
4820 {
4821   return (struct linetable *) xrealloc ((void *) lt,
4822                                         (sizeof (struct linetable)
4823                                          + ((lt->nitems - 1)
4824                                             * sizeof (lt->item))));
4825 }
4826
4827 /* Allocate and zero a new blockvector of NBLOCKS blocks.  */
4828
4829 static struct blockvector *
4830 new_bvect (int nblocks)
4831 {
4832   struct blockvector *bv;
4833   int size;
4834
4835   size = sizeof (struct blockvector) + nblocks * sizeof (struct block *);
4836   bv = (struct blockvector *) xzalloc (size);
4837
4838   BLOCKVECTOR_NBLOCKS (bv) = nblocks;
4839
4840   return bv;
4841 }
4842
4843 /* Allocate and zero a new block, and set its BLOCK_DICT.  If function
4844    is non-zero, assume the block is associated to a function, and make
4845    sure that the symbols are stored linearly; otherwise, store them
4846    hashed.  */
4847
4848 static struct block *
4849 new_block (enum block_type type)
4850 {
4851   /* FIXME: carlton/2003-09-11: This should use allocate_block to
4852      allocate the block.  Which, in turn, suggests that the block
4853      should be allocated on an obstack.  */
4854   struct block *retval = xzalloc (sizeof (struct block));
4855
4856   if (type == FUNCTION_BLOCK)
4857     BLOCK_DICT (retval) = dict_create_linear_expandable ();
4858   else
4859     BLOCK_DICT (retval) = dict_create_hashed_expandable ();
4860
4861   return retval;
4862 }
4863
4864 /* Create a new symbol with printname NAME.  */
4865
4866 static struct symbol *
4867 new_symbol (char *name)
4868 {
4869   struct symbol *s = ((struct symbol *)
4870                       obstack_alloc (&current_objfile->objfile_obstack,
4871                                      sizeof (struct symbol)));
4872
4873   memset (s, 0, sizeof (*s));
4874   SYMBOL_SET_LANGUAGE (s, psymtab_language);
4875   SYMBOL_SET_NAMES (s, name, strlen (name), 1, current_objfile);
4876   return s;
4877 }
4878
4879 /* Create a new type with printname NAME.  */
4880
4881 static struct type *
4882 new_type (char *name)
4883 {
4884   struct type *t;
4885
4886   t = alloc_type (current_objfile);
4887   TYPE_NAME (t) = name;
4888   INIT_CPLUS_SPECIFIC (t);
4889   return t;
4890 }
4891 \f
4892 /* Read ECOFF debugging information from a BFD section.  This is
4893    called from elfread.c.  It parses the section into a
4894    ecoff_debug_info struct, and then lets the rest of the file handle
4895    it as normal.  */
4896
4897 void
4898 elfmdebug_build_psymtabs (struct objfile *objfile,
4899                           const struct ecoff_debug_swap *swap, asection *sec)
4900 {
4901   bfd *abfd = objfile->obfd;
4902   struct ecoff_debug_info *info;
4903   struct cleanup *back_to;
4904
4905   /* FIXME: It's not clear whether we should be getting minimal symbol
4906      information from .mdebug in an ELF file, or whether we will.
4907      Re-initialize the minimal symbol reader in case we do.  */
4908
4909   init_minimal_symbol_collection ();
4910   back_to = make_cleanup_discard_minimal_symbols ();
4911
4912   info = ((struct ecoff_debug_info *)
4913           obstack_alloc (&objfile->objfile_obstack,
4914                          sizeof (struct ecoff_debug_info)));
4915
4916   if (!(*swap->read_debug_info) (abfd, sec, info))
4917     error (_("Error reading ECOFF debugging information: %s"),
4918            bfd_errmsg (bfd_get_error ()));
4919
4920   mdebug_build_psymtabs (objfile, swap, info);
4921
4922   install_minimal_symbols (objfile);
4923   do_cleanups (back_to);
4924 }
4925
4926 void
4927 _initialize_mdebugread (void)
4928 {
4929   basic_type_data = register_objfile_data ();
4930 }