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