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