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