GDB copyright headers update after running GDB's copyright.py script.
[external/binutils.git] / gdb / mdebugread.c
1 /* Read a symbol table in ECOFF format (Third-Eye).
2
3    Copyright (C) 1986-2016 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 extern void _initialize_mdebugread (void);
72
73 /* Provide a way to test if we have both ECOFF and ELF symbol tables.
74    We use this define in order to know whether we should override a 
75    symbol's ECOFF section with its ELF section.  This is necessary in 
76    case the symbol's ELF section could not be represented in ECOFF.  */
77 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
78                            && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
79
80 /* The objfile we are currently reading.  */
81
82 static struct objfile *mdebugread_objfile;
83
84 \f
85
86 /* We put a pointer to this structure in the read_symtab_private field
87    of the psymtab.  */
88
89 struct symloc
90   {
91     /* Index of the FDR that this psymtab represents.  */
92     int fdr_idx;
93     /* The BFD that the psymtab was created from.  */
94     bfd *cur_bfd;
95     const struct ecoff_debug_swap *debug_swap;
96     struct ecoff_debug_info *debug_info;
97     struct mdebug_pending **pending_list;
98     /* Pointer to external symbols for this file.  */
99     EXTR *extern_tab;
100     /* Size of extern_tab.  */
101     int extern_count;
102     enum language pst_language;
103   };
104
105 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
106 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
107 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
108 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
109 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
110 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
111
112 #define SC_IS_TEXT(sc) ((sc) == scText \
113                    || (sc) == scRConst \
114                    || (sc) == scInit \
115                    || (sc) == scFini)
116 #define SC_IS_DATA(sc) ((sc) == scData \
117                    || (sc) == scSData \
118                    || (sc) == scRData \
119                    || (sc) == scPData \
120                    || (sc) == scXData)
121 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
122 #define SC_IS_BSS(sc) ((sc) == scBss)
123 #define SC_IS_SBSS(sc) ((sc) == scSBss)
124 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
125 \f
126 /* Various complaints about symbol reading that don't abort the process.  */
127 static void
128 index_complaint (const char *arg1)
129 {
130   complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
131 }
132
133 static void
134 unknown_ext_complaint (const char *arg1)
135 {
136   complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
137 }
138
139 static void
140 basic_type_complaint (int arg1, const char *arg2)
141 {
142   complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
143              arg1, arg2);
144 }
145
146 static void
147 bad_tag_guess_complaint (const char *arg1)
148 {
149   complaint (&symfile_complaints,
150              _("guessed tag type of %s incorrectly"), arg1);
151 }
152
153 static void
154 bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
155 {
156   complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
157              arg1, arg2, arg3);
158 }
159
160 static void
161 unexpected_type_code_complaint (const char *arg1)
162 {
163   complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
164 }
165
166 /* Macros and extra defs.  */
167
168 /* Puns: hard to find whether -g was used and how.  */
169
170 #define MIN_GLEVEL GLEVEL_0
171 #define compare_glevel(a,b)                                     \
172         (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) :                 \
173          ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
174 \f
175 /* Things that really are local to this module.  */
176
177 /* Remember what we deduced to be the source language of this psymtab.  */
178
179 static enum language psymtab_language = language_unknown;
180
181 /* Current BFD.  */
182
183 static bfd *cur_bfd;
184
185 /* How to parse debugging information for CUR_BFD.  */
186
187 static const struct ecoff_debug_swap *debug_swap;
188
189 /* Pointers to debugging information for CUR_BFD.  */
190
191 static struct ecoff_debug_info *debug_info;
192
193 /* Pointer to current file decriptor record, and its index.  */
194
195 static FDR *cur_fdr;
196 static int cur_fd;
197
198 /* Index of current symbol.  */
199
200 static int cur_sdx;
201
202 /* Note how much "debuggable" this image is.  We would like
203    to see at least one FDR with full symbols.  */
204
205 static int max_gdbinfo;
206 static int max_glevel;
207
208 /* When examining .o files, report on undefined symbols.  */
209
210 static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
211
212 /* Pseudo symbol to use when putting stabs into the symbol table.  */
213
214 static char stabs_symbol[] = STABS_SYMBOL;
215
216 /* Nonzero if we have seen ecoff debugging info for a file.  */
217
218 static int found_ecoff_debugging_info;
219
220 /* Forward declarations.  */
221
222 static int upgrade_type (int, struct type **, int, union aux_ext *,
223                          int, char *);
224
225 static void parse_partial_symbols (struct objfile *);
226
227 static int has_opaque_xref (FDR *, SYMR *);
228
229 static int cross_ref (int, union aux_ext *, struct type **, enum type_code,
230                       char **, int, char *);
231
232 static struct symbol *new_symbol (char *);
233
234 static struct type *new_type (char *);
235
236 enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };
237
238 static struct block *new_block (enum block_type);
239
240 static struct compunit_symtab *new_symtab (const char *, int, struct objfile *);
241
242 static struct linetable *new_linetable (int);
243
244 static struct blockvector *new_bvect (int);
245
246 static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
247                                 int, char *);
248
249 static struct symbol *mylookup_symbol (char *, const struct block *,
250                                        domain_enum, enum address_class);
251
252 static void sort_blocks (struct symtab *);
253
254 static struct partial_symtab *new_psymtab (char *, struct objfile *);
255
256 static void psymtab_to_symtab_1 (struct objfile *objfile,
257                                  struct partial_symtab *, const char *);
258
259 static void add_block (struct block *, struct symtab *);
260
261 static void add_symbol (struct symbol *, struct symtab *, struct block *);
262
263 static int add_line (struct linetable *, int, CORE_ADDR, int);
264
265 static struct linetable *shrink_linetable (struct linetable *);
266
267 static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
268                                         CORE_ADDR);
269
270 static char *mdebug_next_symbol_text (struct objfile *);
271 \f
272 /* Exported procedure: Builds a symtab from the partial symtab SELF.
273    Restores the environment in effect when SELF was created, delegates
274    most of the work to an ancillary procedure, and sorts
275    and reorders the symtab list at the end.  SELF is not NULL.  */
276
277 static void
278 mdebug_read_symtab (struct partial_symtab *self, struct objfile *objfile)
279 {
280   if (info_verbose)
281     {
282       printf_filtered (_("Reading in symbols for %s..."), self->filename);
283       gdb_flush (gdb_stdout);
284     }
285
286   next_symbol_text_func = mdebug_next_symbol_text;
287
288   psymtab_to_symtab_1 (objfile, self, self->filename);
289
290   /* Match with global symbols.  This only needs to be done once,
291      after all of the symtabs and dependencies have been read in.  */
292   scan_file_globals (objfile);
293
294   if (info_verbose)
295     printf_filtered (_("done.\n"));
296 }
297 \f
298 /* File-level interface functions.  */
299
300 /* Find a file descriptor given its index RF relative to a file CF.  */
301
302 static FDR *
303 get_rfd (int cf, int rf)
304 {
305   FDR *fdrs;
306   FDR *f;
307   RFDT rfd;
308
309   fdrs = debug_info->fdr;
310   f = fdrs + cf;
311   /* Object files do not have the RFD table, all refs are absolute.  */
312   if (f->rfdBase == 0)
313     return fdrs + rf;
314   (*debug_swap->swap_rfd_in) (cur_bfd,
315                               ((char *) debug_info->external_rfd
316                                + ((f->rfdBase + rf)
317                                   * debug_swap->external_rfd_size)),
318                               &rfd);
319   return fdrs + rfd;
320 }
321
322 /* Return a safer print NAME for a file descriptor.  */
323
324 static char *
325 fdr_name (FDR *f)
326 {
327   if (f->rss == -1)
328     return "<stripped file>";
329   if (f->rss == 0)
330     return "<NFY>";
331   return debug_info->ss + f->issBase + f->rss;
332 }
333
334
335 /* Read in and parse the symtab of the file OBJFILE.  Symbols from
336    different sections are relocated via the SECTION_OFFSETS.  */
337
338 void
339 mdebug_build_psymtabs (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 (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, 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   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_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED,
1406                       "adr_32", objfile);
1407       TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
1408       break;
1409
1410     case btChar:
1411       tp = init_type (TYPE_CODE_INT, 1, 0,
1412                       "char", objfile);
1413       break;
1414
1415     case btUChar:
1416       tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
1417                       "unsigned char", objfile);
1418       break;
1419
1420     case btShort:
1421       tp = init_type (TYPE_CODE_INT, 2, 0,
1422                       "short", objfile);
1423       break;
1424
1425     case btUShort:
1426       tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
1427                       "unsigned short", objfile);
1428       break;
1429
1430     case btInt:
1431       tp = init_type (TYPE_CODE_INT, 4, 0,
1432                       "int", objfile);
1433       break;
1434
1435    case btUInt:
1436       tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1437                       "unsigned int", objfile);
1438       break;
1439
1440     case btLong:
1441       tp = init_type (TYPE_CODE_INT, 4, 0,
1442                       "long", objfile);
1443       break;
1444
1445     case btULong:
1446       tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1447                       "unsigned long", objfile);
1448       break;
1449
1450     case btFloat:
1451       tp = init_type (TYPE_CODE_FLT,
1452                       gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1453                       "float", objfile);
1454       break;
1455
1456     case btDouble:
1457       tp = init_type (TYPE_CODE_FLT,
1458                       gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1459                       "double", objfile);
1460       break;
1461
1462     case btComplex:
1463       tp = init_type (TYPE_CODE_COMPLEX,
1464                       2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1465                       "complex", objfile);
1466       TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile);
1467       break;
1468
1469     case btDComplex:
1470       tp = init_type (TYPE_CODE_COMPLEX,
1471                       2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1472                       "double complex", objfile);
1473       TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile);
1474       break;
1475
1476     case btFixedDec:
1477       /* We use TYPE_CODE_INT to print these as integers.  Does this do any
1478          good?  Would we be better off with TYPE_CODE_ERROR?  Should
1479          TYPE_CODE_ERROR print things in hex if it knows the size?  */
1480       tp = init_type (TYPE_CODE_INT,
1481                       gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1482                       "fixed decimal", objfile);
1483       break;
1484
1485     case btFloatDec:
1486       tp = init_type (TYPE_CODE_ERROR,
1487                       gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1488                       "floating decimal", objfile);
1489       break;
1490
1491     case btString:
1492       /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
1493          FIXME.  */
1494       tp = init_type (TYPE_CODE_STRING, 1, 0,
1495                       "string", objfile);
1496       break;
1497
1498     case btVoid:
1499       tp = objfile_type (objfile)->builtin_void;
1500       break;
1501
1502     case btLong64:
1503       tp = init_type (TYPE_CODE_INT, 8, 0,
1504                       "long", objfile);
1505       break;
1506
1507     case btULong64:
1508       tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1509                       "unsigned long", objfile);
1510       break;
1511
1512     case btLongLong64:
1513       tp = init_type (TYPE_CODE_INT, 8, 0,
1514                       "long long", objfile);
1515       break;
1516
1517     case btULongLong64:
1518       tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1519                       "unsigned long long", objfile);
1520       break;
1521
1522     case btAdr64:
1523       tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED,
1524                       "adr_64", objfile);
1525       TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
1526       break;
1527
1528     case btInt64:
1529       tp = init_type (TYPE_CODE_INT, 8, 0,
1530                       "int", objfile);
1531       break;
1532
1533     case btUInt64:
1534       tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1535                       "unsigned int", objfile);
1536       break;
1537
1538     default:
1539       tp = NULL;
1540       break;
1541     }
1542
1543   map_bt[bt] = tp;
1544   return tp;
1545 }
1546
1547 /* Parse the type information provided in the raw AX entries for
1548    the symbol SH.  Return the bitfield size in BS, in case.
1549    We must byte-swap the AX entries before we use them; BIGEND says whether
1550    they are big-endian or little-endian (from fh->fBigendian).  */
1551
1552 static struct type *
1553 parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
1554             int bigend, char *sym_name)
1555 {
1556   TIR t[1];
1557   struct type *tp = 0;
1558   enum type_code type_code = TYPE_CODE_UNDEF;
1559
1560   /* Handle undefined types, they have indexNil.  */
1561   if (aux_index == indexNil)
1562     return basic_type (btInt, mdebugread_objfile);
1563
1564   /* Handle corrupt aux indices.  */
1565   if (aux_index >= (debug_info->fdr + fd)->caux)
1566     {
1567       index_complaint (sym_name);
1568       return basic_type (btInt, mdebugread_objfile);
1569     }
1570   ax += aux_index;
1571
1572   /* Use aux as a type information record, map its basic type.  */
1573   (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1574   tp = basic_type (t->bt, mdebugread_objfile);
1575   if (tp == NULL)
1576     {
1577       /* Cannot use builtin types -- build our own.  */
1578       switch (t->bt)
1579         {
1580         case btStruct:
1581           type_code = TYPE_CODE_STRUCT;
1582           break;
1583         case btUnion:
1584           type_code = TYPE_CODE_UNION;
1585           break;
1586         case btEnum:
1587           type_code = TYPE_CODE_ENUM;
1588           break;
1589         case btRange:
1590           type_code = TYPE_CODE_RANGE;
1591           break;
1592         case btSet:
1593           type_code = TYPE_CODE_SET;
1594           break;
1595         case btIndirect:
1596           /* alpha cc -migrate uses this for typedefs.  The true type will
1597              be obtained by crossreferencing below.  */
1598           type_code = TYPE_CODE_ERROR;
1599           break;
1600         case btTypedef:
1601           /* alpha cc uses this for typedefs.  The true type will be
1602              obtained by crossreferencing below.  */
1603           type_code = TYPE_CODE_ERROR;
1604           break;
1605         default:
1606           basic_type_complaint (t->bt, sym_name);
1607           return basic_type (btInt, mdebugread_objfile);
1608         }
1609     }
1610
1611   /* Move on to next aux.  */
1612   ax++;
1613
1614   if (t->fBitfield)
1615     {
1616       int width = AUX_GET_WIDTH (bigend, ax);
1617
1618       /* Inhibit core dumps if TIR is corrupted.  */
1619       if (bs == (int *) NULL)
1620         {
1621           /* Alpha cc -migrate encodes char and unsigned char types
1622              as short and unsigned short types with a field width of 8.
1623              Enum types also have a field width which we ignore for now.  */
1624           if (t->bt == btShort && width == 8)
1625             tp = basic_type (btChar, mdebugread_objfile);
1626           else if (t->bt == btUShort && width == 8)
1627             tp = basic_type (btUChar, mdebugread_objfile);
1628           else if (t->bt == btEnum)
1629             ;
1630           else
1631             complaint (&symfile_complaints,
1632                        _("can't handle TIR fBitfield for %s"),
1633                        sym_name);
1634         }
1635       else
1636         *bs = width;
1637       ax++;
1638     }
1639
1640   /* A btIndirect entry cross references to an aux entry containing
1641      the type.  */
1642   if (t->bt == btIndirect)
1643     {
1644       RNDXR rn[1];
1645       int rf;
1646       FDR *xref_fh;
1647       int xref_fd;
1648
1649       (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
1650       ax++;
1651       if (rn->rfd == 0xfff)
1652         {
1653           rf = AUX_GET_ISYM (bigend, ax);
1654           ax++;
1655         }
1656       else
1657         rf = rn->rfd;
1658
1659       if (rf == -1)
1660         {
1661           complaint (&symfile_complaints,
1662                      _("unable to cross ref btIndirect for %s"), sym_name);
1663           return basic_type (btInt, mdebugread_objfile);
1664         }
1665       xref_fh = get_rfd (fd, rf);
1666       xref_fd = xref_fh - debug_info->fdr;
1667       tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase,
1668                     rn->index, (int *) NULL, xref_fh->fBigendian, sym_name);
1669     }
1670
1671   /* All these types really point to some (common) MIPS type
1672      definition, and only the type-qualifiers fully identify
1673      them.  We'll make the same effort at sharing.  */
1674   if (t->bt == btStruct ||
1675       t->bt == btUnion ||
1676       t->bt == btEnum ||
1677
1678   /* btSet (I think) implies that the name is a tag name, not a typedef
1679      name.  This apparently is a MIPS extension for C sets.  */
1680       t->bt == btSet)
1681     {
1682       char *name;
1683
1684       /* Try to cross reference this type, build new type on failure.  */
1685       ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1686       if (tp == (struct type *) NULL)
1687         tp = init_type (type_code, 0, 0, (char *) NULL, mdebugread_objfile);
1688
1689       /* DEC c89 produces cross references to qualified aggregate types,
1690          dereference them.  */
1691       while (TYPE_CODE (tp) == TYPE_CODE_PTR
1692              || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
1693         tp = TYPE_TARGET_TYPE (tp);
1694
1695       /* Make sure that TYPE_CODE(tp) has an expected type code.
1696          Any type may be returned from cross_ref if file indirect entries
1697          are corrupted.  */
1698       if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
1699           && TYPE_CODE (tp) != TYPE_CODE_UNION
1700           && TYPE_CODE (tp) != TYPE_CODE_ENUM)
1701         {
1702           unexpected_type_code_complaint (sym_name);
1703         }
1704       else
1705         {
1706           /* Usually, TYPE_CODE(tp) is already type_code.  The main
1707              exception is if we guessed wrong re struct/union/enum.
1708              But for struct vs. union a wrong guess is harmless, so
1709              don't complain().  */
1710           if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
1711                && type_code != TYPE_CODE_ENUM)
1712               || (TYPE_CODE (tp) != TYPE_CODE_ENUM
1713                   && type_code == TYPE_CODE_ENUM))
1714             {
1715               bad_tag_guess_complaint (sym_name);
1716             }
1717
1718           if (TYPE_CODE (tp) != type_code)
1719             {
1720               TYPE_CODE (tp) = type_code;
1721             }
1722
1723           /* Do not set the tag name if it is a compiler generated tag name
1724              (.Fxx or .xxfake or empty) for unnamed struct/union/enums.  */
1725           if (name[0] == '.' || name[0] == '\0')
1726             TYPE_TAG_NAME (tp) = NULL;
1727           else if (TYPE_TAG_NAME (tp) == NULL
1728                    || strcmp (TYPE_TAG_NAME (tp), name) != 0)
1729             TYPE_TAG_NAME (tp)
1730               = ((const char *)
1731                  obstack_copy0 (&mdebugread_objfile->objfile_obstack,
1732                                 name, strlen (name)));
1733         }
1734     }
1735
1736   /* All these types really point to some (common) MIPS type
1737      definition, and only the type-qualifiers fully identify
1738      them.  We'll make the same effort at sharing.
1739      FIXME: We are not doing any guessing on range types.  */
1740   if (t->bt == btRange)
1741     {
1742       char *name;
1743
1744       /* Try to cross reference this type, build new type on failure.  */
1745       ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1746       if (tp == (struct type *) NULL)
1747         tp = init_type (type_code, 0, 0, (char *) NULL, mdebugread_objfile);
1748
1749       /* Make sure that TYPE_CODE(tp) has an expected type code.
1750          Any type may be returned from cross_ref if file indirect entries
1751          are corrupted.  */
1752       if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
1753         {
1754           unexpected_type_code_complaint (sym_name);
1755         }
1756       else
1757         {
1758           /* Usually, TYPE_CODE(tp) is already type_code.  The main
1759              exception is if we guessed wrong re struct/union/enum.  */
1760           if (TYPE_CODE (tp) != type_code)
1761             {
1762               bad_tag_guess_complaint (sym_name);
1763               TYPE_CODE (tp) = type_code;
1764             }
1765           if (TYPE_NAME (tp) == NULL
1766               || strcmp (TYPE_NAME (tp), name) != 0)
1767             TYPE_NAME (tp)
1768               = ((const char *)
1769                  obstack_copy0 (&mdebugread_objfile->objfile_obstack,
1770                                 name, strlen (name)));
1771         }
1772     }
1773   if (t->bt == btTypedef)
1774     {
1775       char *name;
1776
1777       /* Try to cross reference this type, it should succeed.  */
1778       ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1779       if (tp == (struct type *) NULL)
1780         {
1781           complaint (&symfile_complaints,
1782                      _("unable to cross ref btTypedef for %s"), sym_name);
1783           tp = basic_type (btInt, mdebugread_objfile);
1784         }
1785     }
1786
1787   /* Deal with range types.  */
1788   if (t->bt == btRange)
1789     {
1790       TYPE_NFIELDS (tp) = 0;
1791       TYPE_RANGE_DATA (tp) = ((struct range_bounds *)
1792                           TYPE_ZALLOC (tp, sizeof (struct range_bounds)));
1793       TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
1794       ax++;
1795       TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
1796       ax++;
1797     }
1798
1799   /* Parse all the type qualifiers now.  If there are more
1800      than 6 the game will continue in the next aux.  */
1801
1802   while (1)
1803     {
1804 #define PARSE_TQ(tq) \
1805       if (t->tq != tqNil) \
1806         ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1807       else \
1808         break;
1809
1810       PARSE_TQ (tq0);
1811       PARSE_TQ (tq1);
1812       PARSE_TQ (tq2);
1813       PARSE_TQ (tq3);
1814       PARSE_TQ (tq4);
1815       PARSE_TQ (tq5);
1816 #undef  PARSE_TQ
1817
1818       /* mips cc 2.x and gcc never put out continued aux entries.  */
1819       if (!t->continued)
1820         break;
1821
1822       (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1823       ax++;
1824     }
1825
1826   /* Complain for illegal continuations due to corrupt aux entries.  */
1827   if (t->continued)
1828     complaint (&symfile_complaints,
1829                _("illegal TIR continued for %s"), sym_name);
1830
1831   return tp;
1832 }
1833
1834 /* Make up a complex type from a basic one.  Type is passed by
1835    reference in TPP and side-effected as necessary.  The type
1836    qualifier TQ says how to handle the aux symbols at AX for
1837    the symbol SX we are currently analyzing.  BIGEND says whether
1838    aux symbols are big-endian or little-endian.
1839    Returns the number of aux symbols we parsed.  */
1840
1841 static int
1842 upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
1843               char *sym_name)
1844 {
1845   int off;
1846   struct type *t;
1847
1848   /* Used in array processing.  */
1849   int rf, id;
1850   FDR *fh;
1851   struct type *range;
1852   struct type *indx;
1853   int lower, upper;
1854   RNDXR rndx;
1855
1856   switch (tq)
1857     {
1858     case tqPtr:
1859       t = lookup_pointer_type (*tpp);
1860       *tpp = t;
1861       return 0;
1862
1863     case tqProc:
1864       t = lookup_function_type (*tpp);
1865       *tpp = t;
1866       return 0;
1867
1868     case tqArray:
1869       off = 0;
1870
1871       /* Determine and record the domain type (type of index).  */
1872       (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx);
1873       id = rndx.index;
1874       rf = rndx.rfd;
1875       if (rf == 0xfff)
1876         {
1877           ax++;
1878           rf = AUX_GET_ISYM (bigend, ax);
1879           off++;
1880         }
1881       fh = get_rfd (fd, rf);
1882
1883       indx = parse_type (fh - debug_info->fdr,
1884                          debug_info->external_aux + fh->iauxBase,
1885                          id, (int *) NULL, bigend, sym_name);
1886
1887       /* The bounds type should be an integer type, but might be anything
1888          else due to corrupt aux entries.  */
1889       if (TYPE_CODE (indx) != TYPE_CODE_INT)
1890         {
1891           complaint (&symfile_complaints,
1892                      _("illegal array index type for %s, assuming int"),
1893                      sym_name);
1894           indx = objfile_type (mdebugread_objfile)->builtin_int;
1895         }
1896
1897       /* Get the bounds, and create the array type.  */
1898       ax++;
1899       lower = AUX_GET_DNLOW (bigend, ax);
1900       ax++;
1901       upper = AUX_GET_DNHIGH (bigend, ax);
1902       ax++;
1903       rf = AUX_GET_WIDTH (bigend, ax);  /* bit size of array element */
1904
1905       range = create_static_range_type ((struct type *) NULL, indx,
1906                                         lower, upper);
1907
1908       t = create_array_type ((struct type *) NULL, *tpp, range);
1909
1910       /* We used to fill in the supplied array element bitsize
1911          here if the TYPE_LENGTH of the target type was zero.
1912          This happens for a `pointer to an array of anonymous structs',
1913          but in this case the array element bitsize is also zero,
1914          so nothing is gained.
1915          And we used to check the TYPE_LENGTH of the target type against
1916          the supplied array element bitsize.
1917          gcc causes a mismatch for `pointer to array of object',
1918          since the sdb directives it uses do not have a way of
1919          specifying the bitsize, but it does no harm (the
1920          TYPE_LENGTH should be correct) and we should be able to
1921          ignore the erroneous bitsize from the auxiliary entry safely.
1922          dbx seems to ignore it too.  */
1923
1924       /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem.  */
1925       if (TYPE_LENGTH (*tpp) == 0)
1926         TYPE_TARGET_STUB (t) = 1;
1927
1928       *tpp = t;
1929       return 4 + off;
1930
1931     case tqVol:
1932       /* Volatile -- currently ignored */
1933       return 0;
1934
1935     case tqConst:
1936       /* Const -- currently ignored */
1937       return 0;
1938
1939     default:
1940       complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
1941       return 0;
1942     }
1943 }
1944
1945
1946 /* Parse a procedure descriptor record PR.  Note that the procedure is
1947    parsed _after_ the local symbols, now we just insert the extra
1948    information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1949    already been placed in the procedure's main block.  Note also that
1950    images that have been partially stripped (ld -x) have been deprived
1951    of local symbols, and we have to cope with them here.  FIRST_OFF is
1952    the offset of the first procedure for this FDR; we adjust the
1953    address by this amount, but I don't know why.  SEARCH_SYMTAB is the symtab
1954    to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1955    in question, or NULL to use top_stack->cur_block.  */
1956
1957 static void
1958 parse_procedure (PDR *pr, struct compunit_symtab *search_symtab,
1959                  struct partial_symtab *pst)
1960 {
1961   struct symbol *s, *i;
1962   const struct block *b;
1963   char *sh_name;
1964
1965   /* Simple rule to find files linked "-x".  */
1966   if (cur_fdr->rss == -1)
1967     {
1968       if (pr->isym == -1)
1969         {
1970           /* Static procedure at address pr->adr.  Sigh.  */
1971           /* FIXME-32x64.  assuming pr->adr fits in long.  */
1972           complaint (&symfile_complaints,
1973                      _("can't handle PDR for static proc at 0x%lx"),
1974                      (unsigned long) pr->adr);
1975           return;
1976         }
1977       else
1978         {
1979           /* external */
1980           EXTR she;
1981
1982           (*debug_swap->swap_ext_in) (cur_bfd,
1983                                       ((char *) debug_info->external_ext
1984                                        + (pr->isym
1985                                           * debug_swap->external_ext_size)),
1986                                       &she);
1987           sh_name = debug_info->ssext + she.asym.iss;
1988         }
1989     }
1990   else
1991     {
1992       /* Full symbols */
1993       SYMR sh;
1994
1995       (*debug_swap->swap_sym_in) (cur_bfd,
1996                                   ((char *) debug_info->external_sym
1997                                    + ((cur_fdr->isymBase + pr->isym)
1998                                       * debug_swap->external_sym_size)),
1999                                   &sh);
2000       sh_name = debug_info->ss + cur_fdr->issBase + sh.iss;
2001     }
2002
2003   if (search_symtab != NULL)
2004     {
2005 #if 0
2006       /* This loses both in the case mentioned (want a static, find a global),
2007          but also if we are looking up a non-mangled name which happens to
2008          match the name of a mangled function.  */
2009       /* We have to save the cur_fdr across the call to lookup_symbol.
2010          If the pdr is for a static function and if a global function with
2011          the same name exists, lookup_symbol will eventually read in the symtab
2012          for the global function and clobber cur_fdr.  */
2013       FDR *save_cur_fdr = cur_fdr;
2014
2015       s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
2016       cur_fdr = save_cur_fdr;
2017 #else
2018       s = mylookup_symbol
2019         (sh_name,
2020          BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (search_symtab),
2021                             STATIC_BLOCK),
2022          VAR_DOMAIN,
2023          LOC_BLOCK);
2024 #endif
2025     }
2026   else
2027     s = mylookup_symbol (sh_name, top_stack->cur_block,
2028                          VAR_DOMAIN, LOC_BLOCK);
2029
2030   if (s != 0)
2031     {
2032       b = SYMBOL_BLOCK_VALUE (s);
2033     }
2034   else
2035     {
2036       complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
2037 #if 1
2038       return;
2039 #else
2040 /* FIXME -- delete.  We can't do symbol allocation now; it's all done.  */
2041       s = new_symbol (sh_name);
2042       SYMBOL_DOMAIN (s) = VAR_DOMAIN;
2043       SYMBOL_CLASS (s) = LOC_BLOCK;
2044       /* Donno its type, hope int is ok.  */
2045       SYMBOL_TYPE (s)
2046         = lookup_function_type (objfile_type (pst->objfile)->builtin_int);
2047       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
2048       /* Won't have symbols for this one.  */
2049       b = new_block (2);
2050       SYMBOL_BLOCK_VALUE (s) = b;
2051       BLOCK_FUNCTION (b) = s;
2052       BLOCK_START (b) = pr->adr;
2053       /* BOUND used to be the end of procedure's text, but the
2054          argument is no longer passed in.  */
2055       BLOCK_END (b) = bound;
2056       BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
2057       add_block (b, top_stack->cur_st);
2058 #endif
2059     }
2060
2061   i = mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST);
2062
2063   if (i)
2064     {
2065       struct mdebug_extra_func_info *e;
2066       
2067       e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i);
2068       e->pdr = *pr;
2069
2070       /* GDB expects the absolute function start address for the
2071          procedure descriptor in e->pdr.adr.
2072          As the address in the procedure descriptor is usually relative,
2073          we would have to relocate e->pdr.adr with cur_fdr->adr and
2074          ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
2075          Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2076          in shared libraries on some systems, and on other systems
2077          e->pdr.adr is sometimes offset by a bogus value.
2078          To work around these problems, we replace e->pdr.adr with
2079          the start address of the function.  */
2080       e->pdr.adr = BLOCK_START (b);
2081     }
2082
2083   /* It would be reasonable that functions that have been compiled
2084      without debugging info have a btNil type for their return value,
2085      and functions that are void and are compiled with debugging info
2086      have btVoid.
2087      gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2088      to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2089      case right.
2090      The glevel field in cur_fdr could be used to determine the presence
2091      of debugging info, but GCC doesn't always pass the -g switch settings
2092      to the assembler and GAS doesn't set the glevel field from the -g switch
2093      settings.
2094      To work around these problems, the return value type of a TYPE_CODE_VOID
2095      function is adjusted accordingly if no debugging info was found in the
2096      compilation unit.  */
2097
2098   if (processing_gcc_compilation == 0
2099       && found_ecoff_debugging_info == 0
2100       && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
2101     SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->nodebug_text_symbol;
2102 }
2103
2104 /* Parse the external symbol ES.  Just call parse_symbol() after
2105    making sure we know where the aux are for it.
2106    BIGEND says whether aux entries are big-endian or little-endian.
2107
2108    This routine clobbers top_stack->cur_block and ->cur_st.  */
2109
2110 static void parse_external (EXTR *, int, struct section_offsets *,
2111                             struct objfile *);
2112
2113 static void
2114 parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
2115                 struct objfile *objfile)
2116 {
2117   union aux_ext *ax;
2118
2119   if (es->ifd != ifdNil)
2120     {
2121       cur_fd = es->ifd;
2122       cur_fdr = debug_info->fdr + cur_fd;
2123       ax = debug_info->external_aux + cur_fdr->iauxBase;
2124     }
2125   else
2126     {
2127       cur_fdr = debug_info->fdr;
2128       ax = 0;
2129     }
2130
2131   /* Reading .o files */
2132   if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil)
2133     {
2134       char *what;
2135       switch (es->asym.st)
2136         {
2137         case stNil:
2138           /* These are generated for static symbols in .o files,
2139              ignore them.  */
2140           return;
2141         case stStaticProc:
2142         case stProc:
2143           what = "procedure";
2144           n_undef_procs++;
2145           break;
2146         case stGlobal:
2147           what = "variable";
2148           n_undef_vars++;
2149           break;
2150         case stLabel:
2151           what = "label";
2152           n_undef_labels++;
2153           break;
2154         default:
2155           what = "symbol";
2156           break;
2157         }
2158       n_undef_symbols++;
2159       /* FIXME:  Turn this into a complaint?  */
2160       if (info_verbose)
2161         printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
2162                          what, debug_info->ssext + es->asym.iss,
2163                          fdr_name (cur_fdr));
2164       return;
2165     }
2166
2167   switch (es->asym.st)
2168     {
2169     case stProc:
2170     case stStaticProc:
2171       /* There is no need to parse the external procedure symbols.
2172          If they are from objects compiled without -g, their index will
2173          be indexNil, and the symbol definition from the minimal symbol
2174          is preferrable (yielding a function returning int instead of int).
2175          If the index points to a local procedure symbol, the local
2176          symbol already provides the correct type.
2177          Note that the index of the external procedure symbol points
2178          to the local procedure symbol in the local symbol table, and
2179          _not_ to the auxiliary symbol info.  */
2180       break;
2181     case stGlobal:
2182     case stLabel:
2183       /* Global common symbols are resolved by the runtime loader,
2184          ignore them.  */
2185       if (SC_IS_COMMON (es->asym.sc))
2186         break;
2187
2188       /* Note that the case of a symbol with indexNil must be handled
2189          anyways by parse_symbol().  */
2190       parse_symbol (&es->asym, ax, (char *) NULL,
2191                     bigend, section_offsets, objfile);
2192       break;
2193     default:
2194       break;
2195     }
2196 }
2197
2198 /* Parse the line number info for file descriptor FH into
2199    GDB's linetable LT.  MIPS' encoding requires a little bit
2200    of magic to get things out.  Note also that MIPS' line
2201    numbers can go back and forth, apparently we can live
2202    with that and do not need to reorder our linetables.  */
2203
2204 static void parse_lines (FDR *, PDR *, struct linetable *, int,
2205                          struct partial_symtab *, CORE_ADDR);
2206
2207 static void
2208 parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
2209              struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr)
2210 {
2211   unsigned char *base;
2212   int j, k;
2213   int delta, count, lineno = 0;
2214
2215   if (fh->cbLine == 0)
2216     return;
2217
2218   /* Scan by procedure descriptors.  */
2219   k = 0;
2220   for (j = 0; j < fh->cpd; j++, pr++)
2221     {
2222       CORE_ADDR l;
2223       CORE_ADDR adr;
2224       unsigned char *halt;
2225
2226       /* No code for this one.  */
2227       if (pr->iline == ilineNil ||
2228           pr->lnLow == -1 || pr->lnHigh == -1)
2229         continue;
2230
2231       /* Determine start and end address of compressed line bytes for
2232          this procedure.  */
2233       base = debug_info->line + fh->cbLineOffset;
2234       if (j != (fh->cpd - 1))
2235         halt = base + pr[1].cbLineOffset;
2236       else
2237         halt = base + fh->cbLine;
2238       base += pr->cbLineOffset;
2239
2240       adr = pst->textlow + pr->adr - lowest_pdr_addr;
2241
2242       l = adr >> 2;             /* in words */
2243       for (lineno = pr->lnLow; base < halt;)
2244         {
2245           count = *base & 0x0f;
2246           delta = *base++ >> 4;
2247           if (delta >= 8)
2248             delta -= 16;
2249           if (delta == -8)
2250             {
2251               delta = (base[0] << 8) | base[1];
2252               if (delta >= 0x8000)
2253                 delta -= 0x10000;
2254               base += 2;
2255             }
2256           lineno += delta;      /* first delta is 0 */
2257
2258           /* Complain if the line table overflows.  Could happen
2259              with corrupt binaries.  */
2260           if (lt->nitems >= maxlines)
2261             {
2262               complaint (&symfile_complaints,
2263                          _("guessed size of linetable for %s incorrectly"),
2264                          fdr_name (fh));
2265               break;
2266             }
2267           k = add_line (lt, lineno, l, k);
2268           l += count + 1;
2269         }
2270     }
2271 }
2272 \f
2273 static void
2274 function_outside_compilation_unit_complaint (const char *arg1)
2275 {
2276   complaint (&symfile_complaints,
2277              _("function `%s' appears to be defined "
2278                "outside of all compilation units"),
2279              arg1);
2280 }
2281
2282 /* Use the STORAGE_CLASS to compute which section the given symbol
2283    belongs to, and then records this new minimal symbol.  */
2284
2285 static void
2286 record_minimal_symbol (const char *name, const CORE_ADDR address,
2287                        enum minimal_symbol_type ms_type, int storage_class,
2288                        struct objfile *objfile)
2289 {
2290   int section;
2291
2292   switch (storage_class)
2293     {
2294       case scText:
2295         section = SECT_OFF_TEXT (objfile);
2296         break;
2297       case scData:
2298         section = SECT_OFF_DATA (objfile);
2299         break;
2300       case scBss:
2301         section = SECT_OFF_BSS (objfile);
2302         break;
2303       case scSData:
2304         section = get_section_index (objfile, ".sdata");
2305         break;
2306       case scSBss:
2307         section = get_section_index (objfile, ".sbss");
2308         break;
2309       case scRData:
2310         section = get_section_index (objfile, ".rdata");
2311         break;
2312       case scInit:
2313         section = get_section_index (objfile, ".init");
2314         break;
2315       case scXData:
2316         section = get_section_index (objfile, ".xdata");
2317         break;
2318       case scPData:
2319         section = get_section_index (objfile, ".pdata");
2320         break;
2321       case scFini:
2322         section = get_section_index (objfile, ".fini");
2323         break;
2324       case scRConst:
2325         section = get_section_index (objfile, ".rconst");
2326         break;
2327 #ifdef scTlsData
2328       case scTlsData:
2329         section = get_section_index (objfile, ".tlsdata");
2330         break;
2331 #endif
2332 #ifdef scTlsBss
2333       case scTlsBss:
2334         section = get_section_index (objfile, ".tlsbss");
2335         break;
2336 #endif
2337       default:
2338         /* This kind of symbol is not associated to a section.  */
2339         section = -1;
2340     }
2341
2342   prim_record_minimal_symbol_and_info (name, address, ms_type,
2343                                        section, objfile);
2344 }
2345
2346 /* Master parsing procedure for first-pass reading of file symbols
2347    into a partial_symtab.  */
2348
2349 static void
2350 parse_partial_symbols (struct objfile *objfile)
2351 {
2352   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2353   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
2354   const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
2355   const bfd_size_type external_ext_size = debug_swap->external_ext_size;
2356   void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in;
2357   void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
2358   void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in;
2359   int f_idx, s_idx;
2360   HDRR *hdr = &debug_info->symbolic_header;
2361   /* Running pointers */
2362   FDR *fh;
2363   char *ext_out;
2364   char *ext_out_end;
2365   EXTR *ext_block;
2366   EXTR *ext_in;
2367   EXTR *ext_in_end;
2368   SYMR sh;
2369   struct partial_symtab *pst;
2370   int textlow_not_set = 1;
2371   int past_first_source_file = 0;
2372
2373   /* List of current psymtab's include files.  */
2374   const char **psymtab_include_list;
2375   int includes_allocated;
2376   int includes_used;
2377   EXTR *extern_tab;
2378   struct pst_map *fdr_to_pst;
2379   /* Index within current psymtab dependency list.  */
2380   struct partial_symtab **dependency_list;
2381   int dependencies_used, dependencies_allocated;
2382   struct cleanup *old_chain;
2383   char *name;
2384   enum language prev_language;
2385   asection *text_sect;
2386   int relocatable = 0;
2387
2388   /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2389      the shared libraries are prelinked at a high memory address.
2390      We have to adjust the start address of the object file for this case,
2391      by setting it to the start address of the first procedure in the file.
2392      But we should do no adjustments if we are debugging a .o file, where
2393      the text section (and fh->adr) really starts at zero.  */
2394   text_sect = bfd_get_section_by_name (cur_bfd, ".text");
2395   if (text_sect != NULL
2396       && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
2397     relocatable = 1;
2398
2399   extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack,
2400                                        sizeof (EXTR) * hdr->iextMax);
2401
2402   includes_allocated = 30;
2403   includes_used = 0;
2404   psymtab_include_list = (const char **) alloca (includes_allocated *
2405                                                  sizeof (const char *));
2406   next_symbol_text_func = mdebug_next_symbol_text;
2407
2408   dependencies_allocated = 30;
2409   dependencies_used = 0;
2410   dependency_list =
2411     (struct partial_symtab **) alloca (dependencies_allocated *
2412                                        sizeof (struct partial_symtab *));
2413
2414   set_last_source_file (NULL);
2415
2416   /*
2417    * Big plan:
2418    *
2419    * Only parse the Local and External symbols, and the Relative FDR.
2420    * Fixup enough of the loader symtab to be able to use it.
2421    * Allocate space only for the file's portions we need to
2422    * look at.  (XXX)
2423    */
2424
2425   max_gdbinfo = 0;
2426   max_glevel = MIN_GLEVEL;
2427
2428   /* Allocate the map FDR -> PST.
2429      Minor hack: -O3 images might claim some global data belongs
2430      to FDR -1.  We`ll go along with that.  */
2431   fdr_to_pst = XCNEWVEC (struct pst_map, hdr->ifdMax + 1);
2432   old_chain = make_cleanup (xfree, fdr_to_pst);
2433   fdr_to_pst++;
2434   {
2435     struct partial_symtab *pst = new_psymtab ("", objfile);
2436
2437     fdr_to_pst[-1].pst = pst;
2438     FDR_IDX (pst) = -1;
2439   }
2440
2441   /* Allocate the global pending list.  */
2442   pending_list =
2443     ((struct mdebug_pending **)
2444      obstack_alloc (&objfile->objfile_obstack,
2445                     hdr->ifdMax * sizeof (struct mdebug_pending *)));
2446   memset (pending_list, 0,
2447           hdr->ifdMax * sizeof (struct mdebug_pending *));
2448
2449   /* Pass 0 over external syms: swap them in.  */
2450   ext_block = XNEWVEC (EXTR, hdr->iextMax);
2451   make_cleanup (xfree, ext_block);
2452
2453   ext_out = (char *) debug_info->external_ext;
2454   ext_out_end = ext_out + hdr->iextMax * external_ext_size;
2455   ext_in = ext_block;
2456   for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
2457     (*swap_ext_in) (cur_bfd, ext_out, ext_in);
2458
2459   /* Pass 1 over external syms: Presize and partition the list.  */
2460   ext_in = ext_block;
2461   ext_in_end = ext_in + hdr->iextMax;
2462   for (; ext_in < ext_in_end; ext_in++)
2463     {
2464       /* See calls to complain below.  */
2465       if (ext_in->ifd >= -1
2466           && ext_in->ifd < hdr->ifdMax
2467           && ext_in->asym.iss >= 0
2468           && ext_in->asym.iss < hdr->issExtMax)
2469         fdr_to_pst[ext_in->ifd].n_globals++;
2470     }
2471
2472   /* Pass 1.5 over files:  partition out global symbol space.  */
2473   s_idx = 0;
2474   for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++)
2475     {
2476       fdr_to_pst[f_idx].globals_offset = s_idx;
2477       s_idx += fdr_to_pst[f_idx].n_globals;
2478       fdr_to_pst[f_idx].n_globals = 0;
2479     }
2480
2481   /* ECOFF in ELF:
2482
2483      For ECOFF in ELF, we skip the creation of the minimal symbols.
2484      The ECOFF symbols should be a subset of the Elf symbols, and the 
2485      section information of the elf symbols will be more accurate.
2486      FIXME!  What about Irix 5's native linker?
2487
2488      By default, Elf sections which don't exist in ECOFF 
2489      get put in ECOFF's absolute section by the gnu linker.
2490      Since absolute sections don't get relocated, we 
2491      end up calculating an address different from that of 
2492      the symbol's minimal symbol (created earlier from the
2493      Elf symtab).
2494
2495      To fix this, either :
2496      1) don't create the duplicate symbol
2497      (assumes ECOFF symtab is a subset of the ELF symtab;
2498      assumes no side-effects result from ignoring ECOFF symbol)
2499      2) create it, only if lookup for existing symbol in ELF's minimal 
2500      symbols fails
2501      (inefficient; 
2502      assumes no side-effects result from ignoring ECOFF symbol)
2503      3) create it, but lookup ELF's minimal symbol and use it's section
2504      during relocation, then modify "uniqify" phase to merge and 
2505      eliminate the duplicate symbol
2506      (highly inefficient)
2507
2508      I've implemented #1 here...
2509      Skip the creation of the minimal symbols based on the ECOFF 
2510      symbol table.  */
2511
2512   /* Pass 2 over external syms: fill in external symbols.  */
2513   ext_in = ext_block;
2514   ext_in_end = ext_in + hdr->iextMax;
2515   for (; ext_in < ext_in_end; ext_in++)
2516     {
2517       enum minimal_symbol_type ms_type = mst_text;
2518       CORE_ADDR svalue = ext_in->asym.value;
2519
2520       /* The Irix 5 native tools seem to sometimes generate bogus
2521          external symbols.  */
2522       if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
2523         {
2524           complaint (&symfile_complaints,
2525                      _("bad ifd for external symbol: %d (max %ld)"),
2526                      ext_in->ifd, hdr->ifdMax);
2527           continue;
2528         }
2529       if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
2530         {
2531           complaint (&symfile_complaints,
2532                      _("bad iss for external symbol: %ld (max %ld)"),
2533                      ext_in->asym.iss, hdr->issExtMax);
2534           continue;
2535         }
2536
2537       extern_tab[fdr_to_pst[ext_in->ifd].globals_offset
2538                  + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in;
2539
2540
2541       if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil)
2542         continue;
2543
2544
2545       /* Pass 3 over files, over local syms: fill in static symbols.  */
2546       name = debug_info->ssext + ext_in->asym.iss;
2547
2548       /* Process ECOFF Symbol Types and Storage Classes.  */
2549       switch (ext_in->asym.st)
2550         {
2551         case stProc:
2552           /* Beginnning of Procedure */
2553           break;
2554         case stStaticProc:
2555           /* Load time only static procs */
2556           ms_type = mst_file_text;
2557           break;
2558         case stGlobal:
2559           /* External symbol */
2560           if (SC_IS_COMMON (ext_in->asym.sc))
2561             {
2562               /* The value of a common symbol is its size, not its address.
2563                  Ignore it.  */
2564               continue;
2565             }
2566           else if (SC_IS_DATA (ext_in->asym.sc))
2567             {
2568               ms_type = mst_data;
2569             }
2570           else if (SC_IS_BSS (ext_in->asym.sc))
2571             {
2572               ms_type = mst_bss;
2573             }
2574           else if (SC_IS_SBSS (ext_in->asym.sc))
2575             {
2576               ms_type = mst_bss;
2577             }
2578           else
2579             ms_type = mst_abs;
2580           break;
2581         case stLabel:
2582           /* Label */
2583
2584           /* On certain platforms, some extra label symbols can be
2585              generated by the linker.  One possible usage for this kind
2586              of symbols is to represent the address of the begining of a
2587              given section.  For instance, on Tru64 5.1, the address of
2588              the _ftext label is the start address of the .text section.
2589
2590              The storage class of these symbols is usually directly
2591              related to the section to which the symbol refers.  For
2592              instance, on Tru64 5.1, the storage class for the _fdata
2593              label is scData, refering to the .data section.
2594
2595              It is actually possible that the section associated to the
2596              storage class of the label does not exist.  On True64 5.1
2597              for instance, the libm.so shared library does not contain
2598              any .data section, although it contains a _fpdata label
2599              which storage class is scData...  Since these symbols are
2600              usually useless for the debugger user anyway, we just
2601              discard these symbols.  */
2602           
2603           if (SC_IS_TEXT (ext_in->asym.sc))
2604             {
2605               if (objfile->sect_index_text == -1)
2606                 continue;
2607                 
2608               ms_type = mst_file_text;
2609             }
2610           else if (SC_IS_DATA (ext_in->asym.sc))
2611             {
2612               if (objfile->sect_index_data == -1)
2613                 continue;
2614
2615               ms_type = mst_file_data;
2616             }
2617           else if (SC_IS_BSS (ext_in->asym.sc))
2618             {
2619               if (objfile->sect_index_bss == -1)
2620                 continue;
2621
2622               ms_type = mst_file_bss;
2623             }
2624           else if (SC_IS_SBSS (ext_in->asym.sc))
2625             {
2626               const int sbss_sect_index = get_section_index (objfile, ".sbss");
2627
2628               if (sbss_sect_index == -1)
2629                 continue;
2630
2631               ms_type = mst_file_bss;
2632             }
2633           else
2634             ms_type = mst_abs;
2635           break;
2636         case stLocal:
2637         case stNil:
2638           /* The alpha has the section start addresses in stLocal symbols
2639              whose name starts with a `.'.  Skip those but complain for all
2640              other stLocal symbols.
2641              Irix6 puts the section start addresses in stNil symbols, skip
2642              those too.  */
2643           if (name[0] == '.')
2644             continue;
2645           /* Fall through.  */
2646         default:
2647           ms_type = mst_unknown;
2648           unknown_ext_complaint (name);
2649         }
2650       if (!ECOFF_IN_ELF (cur_bfd))
2651         record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc,
2652                                objfile);
2653     }
2654
2655   /* Pass 3 over files, over local syms: fill in static symbols.  */
2656   for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
2657     {
2658       struct partial_symtab *save_pst;
2659       EXTR *ext_ptr;
2660       CORE_ADDR textlow;
2661
2662       cur_fdr = fh = debug_info->fdr + f_idx;
2663
2664       if (fh->csym == 0)
2665         {
2666           fdr_to_pst[f_idx].pst = NULL;
2667           continue;
2668         }
2669
2670       /* Determine the start address for this object file from the
2671          file header and relocate it, except for Irix 5.2 zero fh->adr.  */
2672       if (fh->cpd)
2673         {
2674           textlow = fh->adr;
2675           if (relocatable || textlow != 0)
2676             textlow += ANOFFSET (objfile->section_offsets,
2677                                  SECT_OFF_TEXT (objfile));
2678         }
2679       else
2680         textlow = 0;
2681       pst = start_psymtab_common (objfile,
2682                                   fdr_name (fh),
2683                                   textlow,
2684                                   objfile->global_psymbols.next,
2685                                   objfile->static_psymbols.next);
2686       pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
2687                                                 sizeof (struct symloc));
2688       memset (pst->read_symtab_private, 0, sizeof (struct symloc));
2689
2690       save_pst = pst;
2691       FDR_IDX (pst) = f_idx;
2692       CUR_BFD (pst) = cur_bfd;
2693       DEBUG_SWAP (pst) = debug_swap;
2694       DEBUG_INFO (pst) = debug_info;
2695       PENDING_LIST (pst) = pending_list;
2696
2697       /* The way to turn this into a symtab is to call...  */
2698       pst->read_symtab = mdebug_read_symtab;
2699
2700       /* Set up language for the pst.
2701          The language from the FDR is used if it is unambigious (e.g. cfront
2702          with native cc and g++ will set the language to C).
2703          Otherwise we have to deduce the language from the filename.
2704          Native ecoff has every header file in a separate FDR, so
2705          deduce_language_from_filename will return language_unknown for
2706          a header file, which is not what we want.
2707          But the FDRs for the header files are after the FDR for the source
2708          file, so we can assign the language of the source file to the
2709          following header files.  Then we save the language in the private
2710          pst data so that we can reuse it when building symtabs.  */
2711       prev_language = psymtab_language;
2712
2713       switch (fh->lang)
2714         {
2715         case langCplusplusV2:
2716           psymtab_language = language_cplus;
2717           break;
2718         default:
2719           psymtab_language = deduce_language_from_filename (fdr_name (fh));
2720           break;
2721         }
2722       if (psymtab_language == language_unknown)
2723         psymtab_language = prev_language;
2724       PST_PRIVATE (pst)->pst_language = psymtab_language;
2725
2726       pst->texthigh = pst->textlow;
2727
2728       /* For stabs-in-ecoff files, the second symbol must be @stab.
2729          This symbol is emitted by mips-tfile to signal that the
2730          current object file uses encapsulated stabs instead of mips
2731          ecoff for local symbols.  (It is the second symbol because
2732          the first symbol is the stFile used to signal the start of a
2733          file).  */
2734       processing_gcc_compilation = 0;
2735       if (fh->csym >= 2)
2736         {
2737           (*swap_sym_in) (cur_bfd,
2738                           ((char *) debug_info->external_sym
2739                            + (fh->isymBase + 1) * external_sym_size),
2740                           &sh);
2741           if (strcmp (debug_info->ss + fh->issBase + sh.iss,
2742                       stabs_symbol) == 0)
2743             processing_gcc_compilation = 2;
2744         }
2745
2746       if (processing_gcc_compilation != 0)
2747         {
2748           for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
2749             {
2750               int type_code;
2751               const char *namestring;
2752
2753               (*swap_sym_in) (cur_bfd,
2754                               (((char *) debug_info->external_sym)
2755                             + (fh->isymBase + cur_sdx) * external_sym_size),
2756                               &sh);
2757               type_code = ECOFF_UNMARK_STAB (sh.index);
2758               if (!ECOFF_IS_STAB (&sh))
2759                 {
2760                   if (sh.st == stProc || sh.st == stStaticProc)
2761                     {
2762                       CORE_ADDR procaddr;
2763                       long isym;
2764
2765                       if (sh.st == stStaticProc)
2766                         {
2767                           namestring = debug_info->ss + fh->issBase + sh.iss;
2768                           record_minimal_symbol (namestring, sh.value,
2769                                                  mst_file_text, sh.sc,
2770                                                  objfile);
2771                         }
2772                       sh.value += ANOFFSET (objfile->section_offsets,
2773                                             SECT_OFF_TEXT (objfile));
2774                       procaddr = sh.value;
2775
2776                       isym = AUX_GET_ISYM (fh->fBigendian,
2777                                            (debug_info->external_aux
2778                                             + fh->iauxBase
2779                                             + sh.index));
2780                       (*swap_sym_in) (cur_bfd,
2781                                       ((char *) debug_info->external_sym
2782                                        + ((fh->isymBase + isym - 1)
2783                                           * external_sym_size)),
2784                                       &sh);
2785                       if (sh.st == stEnd)
2786                         {
2787                           CORE_ADDR high = procaddr + sh.value;
2788
2789                           /* Kludge for Irix 5.2 zero fh->adr.  */
2790                           if (!relocatable
2791                           && (pst->textlow == 0 || procaddr < pst->textlow))
2792                             pst->textlow = procaddr;
2793                           if (high > pst->texthigh)
2794                             pst->texthigh = high;
2795                         }
2796                     }
2797                   else if (sh.st == stStatic)
2798                     {
2799                       switch (sh.sc)
2800                         {
2801                         case scUndefined:
2802                         case scSUndefined:
2803                         case scNil:
2804                         case scAbs:
2805                           break;
2806
2807                         case scData:
2808                         case scSData:
2809                         case scRData:
2810                         case scPData:
2811                         case scXData:
2812                           namestring = debug_info->ss + fh->issBase + sh.iss;
2813                           record_minimal_symbol (namestring, sh.value,
2814                                                  mst_file_data, sh.sc,
2815                                                  objfile);
2816                           sh.value += ANOFFSET (objfile->section_offsets,
2817                                                 SECT_OFF_DATA (objfile));
2818                           break;
2819
2820                         default:
2821                           /* FIXME!  Shouldn't this use cases for bss, 
2822                              then have the default be abs?  */
2823                           namestring = debug_info->ss + fh->issBase + sh.iss;
2824                           record_minimal_symbol (namestring, sh.value,
2825                                                  mst_file_bss, sh.sc,
2826                                                  objfile);
2827                           sh.value += ANOFFSET (objfile->section_offsets,
2828                                                 SECT_OFF_BSS (objfile));
2829                           break;
2830                         }
2831                     }
2832                   continue;
2833                 }
2834               /* Handle stabs continuation.  */
2835               {
2836                 char *stabstring = debug_info->ss + fh->issBase + sh.iss;
2837                 int len = strlen (stabstring);
2838
2839                 while (stabstring[len - 1] == '\\')
2840                   {
2841                     SYMR sh2;
2842                     char *stabstring1 = stabstring;
2843                     char *stabstring2;
2844                     int len2;
2845
2846                     /* Ignore continuation char from 1st string.  */
2847                     len--;
2848
2849                     /* Read next stabstring.  */
2850                     cur_sdx++;
2851                     (*swap_sym_in) (cur_bfd,
2852                                     (((char *) debug_info->external_sym)
2853                                      + (fh->isymBase + cur_sdx)
2854                                      * external_sym_size),
2855                                     &sh2);
2856                     stabstring2 = debug_info->ss + fh->issBase + sh2.iss;
2857                     len2 = strlen (stabstring2);
2858
2859                     /* Concatinate stabstring2 with stabstring1.  */
2860                     if (stabstring
2861                      && stabstring != debug_info->ss + fh->issBase + sh.iss)
2862                       stabstring
2863                         = (char *) xrealloc (stabstring, len + len2 + 1);
2864                     else
2865                       {
2866                         stabstring = (char *) xmalloc (len + len2 + 1);
2867                         strcpy (stabstring, stabstring1);
2868                       }
2869                     strcpy (stabstring + len, stabstring2);
2870                     len += len2;
2871                   }
2872
2873                 switch (type_code)
2874                   {
2875                     char *p;
2876
2877                     /* Standard, external, non-debugger, symbols.  */
2878
2879                   case N_TEXT | N_EXT:
2880                   case N_NBTEXT | N_EXT:
2881                     sh.value += ANOFFSET (objfile->section_offsets,
2882                                           SECT_OFF_TEXT (objfile));
2883                     goto record_it;
2884
2885                   case N_DATA | N_EXT:
2886                   case N_NBDATA | N_EXT:
2887                     sh.value += ANOFFSET (objfile->section_offsets,
2888                                           SECT_OFF_DATA (objfile));
2889                     goto record_it;
2890
2891                   case N_BSS:
2892                   case N_BSS | N_EXT:
2893                   case N_NBBSS | N_EXT:
2894                   case N_SETV | N_EXT:          /* FIXME, is this in BSS?  */
2895                     sh.value += ANOFFSET (objfile->section_offsets,
2896                                           SECT_OFF_BSS (objfile));
2897                     goto record_it;
2898
2899                   case N_ABS | N_EXT:
2900                   record_it:
2901                     continue;
2902
2903                   /* Standard, local, non-debugger, symbols.  */
2904
2905                   case N_NBTEXT:
2906
2907                     /* We need to be able to deal with both N_FN or
2908                        N_TEXT, because we have no way of knowing
2909                        whether the sys-supplied ld or GNU ld was used
2910                        to make the executable.  Sequents throw in
2911                        another wrinkle -- they renumbered N_FN.  */
2912
2913                   case N_FN:
2914                   case N_FN_SEQ:
2915                   case N_TEXT:
2916                     continue;
2917
2918                   case N_DATA:
2919                     sh.value += ANOFFSET (objfile->section_offsets,
2920                                           SECT_OFF_DATA (objfile));
2921                     goto record_it;
2922
2923                   case N_UNDF | N_EXT:
2924                     continue;           /* Just undefined, not COMMON.  */
2925
2926                   case N_UNDF:
2927                     continue;
2928
2929                     /* Lots of symbol types we can just ignore.  */
2930
2931                   case N_ABS:
2932                   case N_NBDATA:
2933                   case N_NBBSS:
2934                     continue;
2935
2936                     /* Keep going . . .  */
2937
2938                     /*
2939                      * Special symbol types for GNU
2940                      */
2941                   case N_INDR:
2942                   case N_INDR | N_EXT:
2943                   case N_SETA:
2944                   case N_SETA | N_EXT:
2945                   case N_SETT:
2946                   case N_SETT | N_EXT:
2947                   case N_SETD:
2948                   case N_SETD | N_EXT:
2949                   case N_SETB:
2950                   case N_SETB | N_EXT:
2951                   case N_SETV:
2952                     continue;
2953
2954                     /*
2955                      * Debugger symbols
2956                      */
2957
2958                   case N_SO:
2959                     {
2960                       CORE_ADDR valu;
2961                       static int prev_so_symnum = -10;
2962                       static int first_so_symnum;
2963                       const char *p;
2964                       int prev_textlow_not_set;
2965
2966                       valu = sh.value + ANOFFSET (objfile->section_offsets,
2967                                                   SECT_OFF_TEXT (objfile));
2968
2969                       prev_textlow_not_set = textlow_not_set;
2970
2971                       /* A zero value is probably an indication for the
2972                          SunPRO 3.0 compiler.  dbx_end_psymtab explicitly tests
2973                          for zero, so don't relocate it.  */
2974
2975                       if (sh.value == 0
2976                           && gdbarch_sofun_address_maybe_missing (gdbarch))
2977                         {
2978                           textlow_not_set = 1;
2979                           valu = 0;
2980                         }
2981                       else
2982                         textlow_not_set = 0;
2983
2984                       past_first_source_file = 1;
2985
2986                       if (prev_so_symnum != symnum - 1)
2987                         {               /* Here if prev stab wasn't N_SO.  */
2988                           first_so_symnum = symnum;
2989
2990                           if (pst)
2991                             {
2992                               pst = (struct partial_symtab *) 0;
2993                               includes_used = 0;
2994                               dependencies_used = 0;
2995                             }
2996                         }
2997
2998                       prev_so_symnum = symnum;
2999
3000                       /* End the current partial symtab and start a
3001                          new one.  */
3002
3003                       /* SET_NAMESTRING ();*/
3004                       namestring = stabstring;
3005
3006                       /* Null name means end of .o file.  Don't start a new
3007                          one.  */
3008                       if (*namestring == '\000')
3009                         continue;
3010
3011                       /* Some compilers (including gcc) emit a pair of
3012                          initial N_SOs.  The first one is a directory name;
3013                          the second the file name.  If pst exists, is
3014                          empty, and has a filename ending in '/', we assume
3015                          the previous N_SO was a directory name.  */
3016                       p = lbasename (namestring);
3017                       if (p != namestring && *p == '\000')
3018                         continue;               /* Simply ignore directory
3019                                                    name SOs.  */
3020
3021                       /* Some other compilers (C++ ones in particular) emit
3022                          useless SOs for non-existant .c files.  We ignore
3023                          all subsequent SOs that immediately follow the
3024                          first.  */
3025
3026                       if (!pst)
3027                         pst = save_pst;
3028                       continue;
3029                     }
3030
3031                   case N_BINCL:
3032                     continue;
3033
3034                   case N_SOL:
3035                     {
3036                       enum language tmp_language;
3037
3038                       /* Mark down an include file in the current psymtab.  */
3039
3040                       /* SET_NAMESTRING (); */
3041                       namestring = stabstring;
3042
3043                       tmp_language
3044                         = deduce_language_from_filename (namestring);
3045
3046                       /* Only change the psymtab's language if we've
3047                          learned something useful (eg. tmp_language is not
3048                          language_unknown).  In addition, to match what
3049                          start_subfile does, never change from C++ to
3050                          C.  */
3051                       if (tmp_language != language_unknown
3052                           && (tmp_language != language_c
3053                               || psymtab_language != language_cplus))
3054                         psymtab_language = tmp_language;
3055
3056                       /* In C++, one may expect the same filename to come
3057                          round many times, when code is coming alternately
3058                          from the main file and from inline functions in
3059                          other files.  So I check to see if this is a file
3060                          we've seen before -- either the main source file,
3061                          or a previously included file.
3062
3063                          This seems to be a lot of time to be spending on
3064                          N_SOL, but things like "break c-exp.y:435" need to
3065                          work (I suppose the psymtab_include_list could be
3066                          hashed or put in a binary tree, if profiling shows
3067                          this is a major hog).  */
3068                       if (pst && filename_cmp (namestring, pst->filename) == 0)
3069                         continue;
3070
3071                       {
3072                         int i;
3073
3074                         for (i = 0; i < includes_used; i++)
3075                           if (filename_cmp (namestring,
3076                                             psymtab_include_list[i]) == 0)
3077                             {
3078                               i = -1;
3079                               break;
3080                             }
3081                         if (i == -1)
3082                           continue;
3083                       }
3084
3085                       psymtab_include_list[includes_used++] = namestring;
3086                       if (includes_used >= includes_allocated)
3087                         {
3088                           const char **orig = psymtab_include_list;
3089
3090                           psymtab_include_list = (const char **)
3091                             alloca ((includes_allocated *= 2) *
3092                                     sizeof (const char *));
3093                           memcpy (psymtab_include_list, orig,
3094                                   includes_used * sizeof (const char *));
3095                         }
3096                       continue;
3097                     }
3098                   case N_LSYM:      /* Typedef or automatic variable.  */
3099                   case N_STSYM:     /* Data seg var -- static  */
3100                   case N_LCSYM:     /* BSS      "  */
3101                   case N_ROSYM:     /* Read-only data seg var -- static.  */
3102                   case N_NBSTS:     /* Gould nobase.  */
3103                   case N_NBLCS:     /* symbols.  */
3104                   case N_FUN:
3105                   case N_GSYM:      /* Global (extern) variable; can be
3106                                        data or bss (sigh FIXME).  */
3107
3108                     /* Following may probably be ignored; I'll leave them here
3109                        for now (until I do Pascal and Modula 2 extensions).  */
3110
3111                   case N_PC:        /* I may or may not need this; I
3112                                        suspect not.  */
3113                   case N_M2C:       /* I suspect that I can ignore this
3114                                        here.  */
3115                   case N_SCOPE:     /* Same.  */
3116
3117                     /*    SET_NAMESTRING (); */
3118                     namestring = stabstring;
3119                     p = (char *) strchr (namestring, ':');
3120                     if (!p)
3121                       continue;     /* Not a debugging symbol.  */
3122
3123
3124
3125                     /* Main processing section for debugging symbols which
3126                        the initial read through the symbol tables needs to
3127                        worry about.  If we reach this point, the symbol
3128                        which we are considering is definitely one we are
3129                        interested in.  p must also contain the (valid)
3130                        index into the namestring which indicates the
3131                        debugging type symbol.  */
3132
3133                     switch (p[1])
3134                       {
3135                       case 'S':
3136                         sh.value += ANOFFSET (objfile->section_offsets,
3137                                               SECT_OFF_DATA (objfile));
3138
3139                         if (gdbarch_static_transform_name_p (gdbarch))
3140                           namestring = gdbarch_static_transform_name
3141                                          (gdbarch, namestring);
3142
3143                         add_psymbol_to_list (namestring, p - namestring, 1,
3144                                              VAR_DOMAIN, LOC_STATIC,
3145                                              &objfile->static_psymbols,
3146                                              sh.value,
3147                                              psymtab_language, objfile);
3148                         continue;
3149                       case 'G':
3150                         sh.value += ANOFFSET (objfile->section_offsets,
3151                                               SECT_OFF_DATA (objfile));
3152                         /* The addresses in these entries are reported
3153                            to be wrong.  See the code that reads 'G's
3154                            for symtabs.  */
3155                         add_psymbol_to_list (namestring, p - namestring, 1,
3156                                              VAR_DOMAIN, LOC_STATIC,
3157                                              &objfile->global_psymbols,
3158                                              sh.value,
3159                                              psymtab_language, objfile);
3160                         continue;
3161
3162                       case 'T':
3163                         /* When a 'T' entry is defining an anonymous enum, it
3164                            may have a name which is the empty string, or a
3165                            single space.  Since they're not really defining a
3166                            symbol, those shouldn't go in the partial symbol
3167                            table.  We do pick up the elements of such enums at
3168                            'check_enum:', below.  */
3169                         if (p >= namestring + 2
3170                             || (p == namestring + 1
3171                                 && namestring[0] != ' '))
3172                           {
3173                             add_psymbol_to_list (namestring, p - namestring, 1,
3174                                                  STRUCT_DOMAIN, LOC_TYPEDEF,
3175                                                  &objfile->static_psymbols,
3176                                                  0, psymtab_language, objfile);
3177                             if (p[2] == 't')
3178                               {
3179                                 /* Also a typedef with the same name.  */
3180                                 add_psymbol_to_list (namestring,
3181                                                      p - namestring, 1,
3182                                                      VAR_DOMAIN, LOC_TYPEDEF,
3183                                                      &objfile->static_psymbols,
3184                                                      0, psymtab_language,
3185                                                      objfile);
3186                                 p += 1;
3187                               }
3188                           }
3189                         goto check_enum;
3190                       case 't':
3191                         if (p != namestring)    /* a name is there, not
3192                                                    just :T...  */
3193                           {
3194                             add_psymbol_to_list (namestring, p - namestring, 1,
3195                                                  VAR_DOMAIN, LOC_TYPEDEF,
3196                                                  &objfile->static_psymbols,
3197                                                  0, psymtab_language, objfile);
3198                           }
3199                       check_enum:
3200                         /* If this is an enumerated type, we need to add
3201                            all the enum constants to the partial symbol
3202                            table.  This does not cover enums without names,
3203                            e.g. "enum {a, b} c;" in C, but fortunately
3204                            those are rare.  There is no way for GDB to find
3205                            those from the enum type without spending too
3206                            much time on it.  Thus to solve this problem,
3207                            the compiler needs to put out the enum in a
3208                            nameless type.  GCC2 does this.  */
3209
3210                         /* We are looking for something of the form
3211                            <name> ":" ("t" | "T") [<number> "="] "e"
3212                            {<constant> ":" <value> ","} ";".  */
3213
3214                         /* Skip over the colon and the 't' or 'T'.  */
3215                         p += 2;
3216                         /* This type may be given a number.  Also, numbers
3217                            can come in pairs like (0,26).  Skip over it.  */
3218                         while ((*p >= '0' && *p <= '9')
3219                                || *p == '(' || *p == ',' || *p == ')'
3220                                || *p == '=')
3221                           p++;
3222
3223                         if (*p++ == 'e')
3224                           {
3225                             /* The aix4 compiler emits extra crud before
3226                                the members.  */
3227                             if (*p == '-')
3228                               {
3229                                 /* Skip over the type (?).  */
3230                                 while (*p != ':')
3231                                   p++;
3232
3233                                 /* Skip over the colon.  */
3234                                 p++;
3235                               }
3236
3237                             /* We have found an enumerated type.  */
3238                             /* According to comments in read_enum_type
3239                                a comma could end it instead of a semicolon.
3240                                I don't know where that happens.
3241                                Accept either.  */
3242                             while (*p && *p != ';' && *p != ',')
3243                               {
3244                                 char *q;
3245
3246                                 /* Check for and handle cretinous dbx
3247                                    symbol name continuation!  */
3248                                 if (*p == '\\' || (*p == '?' && p[1] == '\0'))
3249                                   p = next_symbol_text (objfile);
3250
3251                                 /* Point to the character after the name
3252                                    of the enum constant.  */
3253                                 for (q = p; *q && *q != ':'; q++)
3254                                   ;
3255                                 /* Note that the value doesn't matter for
3256                                    enum constants in psymtabs, just in
3257                                    symtabs.  */
3258                                 add_psymbol_to_list (p, q - p, 1,
3259                                                      VAR_DOMAIN, LOC_CONST,
3260                                                      &objfile->static_psymbols,
3261                                                      0, psymtab_language,
3262                                                      objfile);
3263                                 /* Point past the name.  */
3264                                 p = q;
3265                                 /* Skip over the value.  */
3266                                 while (*p && *p != ',')
3267                                   p++;
3268                                 /* Advance past the comma.  */
3269                                 if (*p)
3270                                   p++;
3271                               }
3272                           }
3273                         continue;
3274                       case 'c':
3275                         /* Constant, e.g. from "const" in Pascal.  */
3276                         add_psymbol_to_list (namestring, p - namestring, 1,
3277                                              VAR_DOMAIN, LOC_CONST,
3278                                              &objfile->static_psymbols,
3279                                              0, psymtab_language, objfile);
3280                         continue;
3281
3282                       case 'f':
3283                         if (! pst)
3284                           {
3285                             int name_len = p - namestring;
3286                             char *name = (char *) xmalloc (name_len + 1);
3287
3288                             memcpy (name, namestring, name_len);
3289                             name[name_len] = '\0';
3290                             function_outside_compilation_unit_complaint (name);
3291                             xfree (name);
3292                           }
3293                         sh.value += ANOFFSET (objfile->section_offsets,
3294                                               SECT_OFF_TEXT (objfile));
3295                         add_psymbol_to_list (namestring, p - namestring, 1,
3296                                              VAR_DOMAIN, LOC_BLOCK,
3297                                              &objfile->static_psymbols,
3298                                              sh.value,
3299                                              psymtab_language, objfile);
3300                         continue;
3301
3302                         /* Global functions were ignored here, but now they
3303                            are put into the global psymtab like one would
3304                            expect.  They're also in the minimal symbol
3305                            table.  */
3306                       case 'F':
3307                         if (! pst)
3308                           {
3309                             int name_len = p - namestring;
3310                             char *name = (char *) xmalloc (name_len + 1);
3311
3312                             memcpy (name, namestring, name_len);
3313                             name[name_len] = '\0';
3314                             function_outside_compilation_unit_complaint (name);
3315                             xfree (name);
3316                           }
3317                         sh.value += ANOFFSET (objfile->section_offsets,
3318                                               SECT_OFF_TEXT (objfile));
3319                         add_psymbol_to_list (namestring, p - namestring, 1,
3320                                              VAR_DOMAIN, LOC_BLOCK,
3321                                              &objfile->global_psymbols,
3322                                              sh.value,
3323                                              psymtab_language, objfile);
3324                         continue;
3325
3326                         /* Two things show up here (hopefully); static
3327                            symbols of local scope (static used inside
3328                            braces) or extensions of structure symbols.  We
3329                            can ignore both.  */
3330                       case 'V':
3331                       case '(':
3332                       case '0':
3333                       case '1':
3334                       case '2':
3335                       case '3':
3336                       case '4':
3337                       case '5':
3338                       case '6':
3339                       case '7':
3340                       case '8':
3341                       case '9':
3342                       case '-':
3343                       case '#':         /* For symbol identification (used
3344                                            in live ranges).  */
3345                         continue;
3346
3347                       case ':':
3348                         /* It is a C++ nested symbol.  We don't need to
3349                            record it (I don't think); if we try to look up
3350                            foo::bar::baz, then symbols for the symtab
3351                            containing foo should get read in, I think.  */
3352                         /* Someone says sun cc puts out symbols like
3353                            /foo/baz/maclib::/usr/local/bin/maclib,
3354                            which would get here with a symbol type of ':'.  */
3355                         continue;
3356
3357                       default:
3358                         /* Unexpected symbol descriptor.  The second and
3359                            subsequent stabs of a continued stab can show up
3360                            here.  The question is whether they ever can
3361                            mimic a normal stab--it would be nice if not,
3362                            since we certainly don't want to spend the time
3363                            searching to the end of every string looking for
3364                            a backslash.  */
3365
3366                         complaint (&symfile_complaints,
3367                                    _("unknown symbol descriptor `%c'"), p[1]);
3368
3369                         /* Ignore it; perhaps it is an extension that we don't
3370                            know about.  */
3371                         continue;
3372                       }
3373
3374                   case N_EXCL:
3375                     continue;
3376
3377                   case N_ENDM:
3378                     /* Solaris 2 end of module, finish current partial
3379                        symbol table.  dbx_end_psymtab will set
3380                        pst->texthigh to the proper value, which is
3381                        necessary if a module compiled without
3382                        debugging info follows this module.  */
3383                     if (pst
3384                         && gdbarch_sofun_address_maybe_missing (gdbarch))
3385                       {
3386                         pst = (struct partial_symtab *) 0;
3387                         includes_used = 0;
3388                         dependencies_used = 0;
3389                       }
3390                     continue;
3391
3392                   case N_RBRAC:
3393                     if (sh.value > save_pst->texthigh)
3394                       save_pst->texthigh = sh.value;
3395                     continue;
3396                   case N_EINCL:
3397                   case N_DSLINE:
3398                   case N_BSLINE:
3399                   case N_SSYM:          /* Claim: Structure or union
3400                                            element.  Hopefully, I can
3401                                            ignore this.  */
3402                   case N_ENTRY:         /* Alternate entry point; can
3403                                            ignore.  */
3404                   case N_MAIN:          /* Can definitely ignore this.   */
3405                   case N_CATCH:         /* These are GNU C++ extensions.  */
3406                   case N_EHDECL:        /* that can safely be ignored here.  */
3407                   case N_LENG:
3408                   case N_BCOMM:
3409                   case N_ECOMM:
3410                   case N_ECOML:
3411                   case N_FNAME:
3412                   case N_SLINE:
3413                   case N_RSYM:
3414                   case N_PSYM:
3415                   case N_LBRAC:
3416                   case N_NSYMS:         /* Ultrix 4.0: symbol count */
3417                   case N_DEFD:                  /* GNU Modula-2 */
3418                   case N_ALIAS:         /* SunPro F77: alias name, ignore
3419                                            for now.  */
3420
3421                   case N_OBJ:           /* Useless types from Solaris.  */
3422                   case N_OPT:
3423                     /* These symbols aren't interesting; don't worry about
3424                        them.  */
3425
3426                     continue;
3427
3428                   default:
3429                     /* If we haven't found it yet, ignore it.  It's
3430                        probably some new type we don't know about yet.  */
3431                     complaint (&symfile_complaints,
3432                                _("unknown symbol type %s"),
3433                                hex_string (type_code)); /* CUR_SYMBOL_TYPE */
3434                     continue;
3435                   }
3436                 if (stabstring
3437                     && stabstring != debug_info->ss + fh->issBase + sh.iss)
3438                   xfree (stabstring);
3439               }
3440               /* end - Handle continuation */
3441             }
3442         }
3443       else
3444         {
3445           for (cur_sdx = 0; cur_sdx < fh->csym;)
3446             {
3447               char *name;
3448               enum address_class theclass;
3449               CORE_ADDR minsym_value;
3450
3451               (*swap_sym_in) (cur_bfd,
3452                               ((char *) debug_info->external_sym
3453                                + ((fh->isymBase + cur_sdx)
3454                                   * external_sym_size)),
3455                               &sh);
3456
3457               if (ECOFF_IS_STAB (&sh))
3458                 {
3459                   cur_sdx++;
3460                   continue;
3461                 }
3462
3463               /* Non absolute static symbols go into the minimal table.  */
3464               if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil
3465                   || (sh.index == indexNil
3466                       && (sh.st != stStatic || sh.sc == scAbs)))
3467                 {
3468                   /* FIXME, premature?  */
3469                   cur_sdx++;
3470                   continue;
3471                 }
3472
3473               name = debug_info->ss + fh->issBase + sh.iss;
3474
3475               minsym_value = sh.value;
3476
3477               switch (sh.sc)
3478                 {
3479                 case scText:
3480                 case scRConst:
3481                   /* The value of a stEnd symbol is the displacement from the
3482                      corresponding start symbol value, do not relocate it.  */
3483                   if (sh.st != stEnd)
3484                     sh.value += ANOFFSET (objfile->section_offsets,
3485                                           SECT_OFF_TEXT (objfile));
3486                   break;
3487                 case scData:
3488                 case scSData:
3489                 case scRData:
3490                 case scPData:
3491                 case scXData:
3492                   sh.value += ANOFFSET (objfile->section_offsets,
3493                                         SECT_OFF_DATA (objfile));
3494                   break;
3495                 case scBss:
3496                 case scSBss:
3497                   sh.value += ANOFFSET (objfile->section_offsets,
3498                                         SECT_OFF_BSS (objfile));
3499                   break;
3500                 }
3501
3502               switch (sh.st)
3503                 {
3504                   CORE_ADDR high;
3505                   CORE_ADDR procaddr;
3506                   int new_sdx;
3507
3508                 case stStaticProc:
3509                   prim_record_minimal_symbol_and_info (name, minsym_value,
3510                                                        mst_file_text,
3511                                                        SECT_OFF_TEXT (objfile),
3512                                                        objfile);
3513
3514                   /* FALLTHROUGH */
3515
3516                 case stProc:
3517                   /* Ignore all parameter symbol records.  */
3518                   if (sh.index >= hdr->iauxMax)
3519                     {
3520                       /* Should not happen, but does when cross-compiling
3521                          with the MIPS compiler.  FIXME -- pull later.  */
3522                       index_complaint (name);
3523                       new_sdx = cur_sdx + 1;    /* Don't skip at all.  */
3524                     }
3525                   else
3526                     new_sdx = AUX_GET_ISYM (fh->fBigendian,
3527                                             (debug_info->external_aux
3528                                              + fh->iauxBase
3529                                              + sh.index));
3530
3531                   if (new_sdx <= cur_sdx)
3532                     {
3533                       /* This should not happen either... FIXME.  */
3534                       complaint (&symfile_complaints,
3535                                  _("bad proc end in aux found from symbol %s"),
3536                                  name);
3537                       new_sdx = cur_sdx + 1;    /* Don't skip backward.  */
3538                     }
3539
3540                   /* For stProc symbol records, we need to check the
3541                      storage class as well, as only (stProc, scText)
3542                      entries represent "real" procedures - See the
3543                      Compaq document titled "Object File / Symbol Table
3544                      Format Specification" for more information.  If the
3545                      storage class is not scText, we discard the whole
3546                      block of symbol records for this stProc.  */
3547                   if (sh.st == stProc && sh.sc != scText)
3548                     goto skip;
3549
3550                   /* Usually there is a local and a global stProc symbol
3551                      for a function.  This means that the function name
3552                      has already been entered into the mimimal symbol table
3553                      while processing the global symbols in pass 2 above.
3554                      One notable exception is the PROGRAM name from
3555                      f77 compiled executables, it is only put out as
3556                      local stProc symbol, and a global MAIN__ stProc symbol
3557                      points to it.  It doesn't matter though, as gdb is
3558                      still able to find the PROGRAM name via the partial
3559                      symbol table, and the MAIN__ symbol via the minimal
3560                      symbol table.  */
3561                   if (sh.st == stProc)
3562                     add_psymbol_to_list (name, strlen (name), 1,
3563                                          VAR_DOMAIN, LOC_BLOCK,
3564                                          &objfile->global_psymbols,
3565                                          sh.value, psymtab_language, objfile);
3566                   else
3567                     add_psymbol_to_list (name, strlen (name), 1,
3568                                          VAR_DOMAIN, LOC_BLOCK,
3569                                          &objfile->static_psymbols,
3570                                          sh.value, psymtab_language, objfile);
3571
3572                   procaddr = sh.value;
3573
3574                   cur_sdx = new_sdx;
3575                   (*swap_sym_in) (cur_bfd,
3576                                   ((char *) debug_info->external_sym
3577                                    + ((fh->isymBase + cur_sdx - 1)
3578                                       * external_sym_size)),
3579                                   &sh);
3580                   if (sh.st != stEnd)
3581                     continue;
3582
3583                   /* Kludge for Irix 5.2 zero fh->adr.  */
3584                   if (!relocatable
3585                       && (pst->textlow == 0 || procaddr < pst->textlow))
3586                     pst->textlow = procaddr;
3587
3588                   high = procaddr + sh.value;
3589                   if (high > pst->texthigh)
3590                     pst->texthigh = high;
3591                   continue;
3592
3593                 case stStatic:  /* Variable */
3594                   if (SC_IS_DATA (sh.sc))
3595                     prim_record_minimal_symbol_and_info (name, minsym_value,
3596                                                          mst_file_data,
3597                                                          SECT_OFF_DATA (objfile),
3598                                                          objfile);
3599                   else
3600                     prim_record_minimal_symbol_and_info (name, minsym_value,
3601                                                          mst_file_bss,
3602                                                          SECT_OFF_BSS (objfile),
3603                                                          objfile);
3604                   theclass = LOC_STATIC;
3605                   break;
3606
3607                 case stIndirect:        /* Irix5 forward declaration */
3608                   /* Skip forward declarations from Irix5 cc.  */
3609                   goto skip;
3610
3611                 case stTypedef: /* Typedef */
3612                   /* Skip typedefs for forward declarations and opaque
3613                      structs from alpha and mips cc.  */
3614                   if (sh.iss == 0 || has_opaque_xref (fh, &sh))
3615                     goto skip;
3616                   theclass = LOC_TYPEDEF;
3617                   break;
3618
3619                 case stConstant:        /* Constant decl */
3620                   theclass = LOC_CONST;
3621                   break;
3622
3623                 case stUnion:
3624                 case stStruct:
3625                 case stEnum:
3626                 case stBlock:   /* { }, str, un, enum */
3627                   /* Do not create a partial symbol for cc unnamed aggregates
3628                      and gcc empty aggregates.  */
3629                   if ((sh.sc == scInfo
3630                        || SC_IS_COMMON (sh.sc))
3631                       && sh.iss != 0
3632                       && sh.index != cur_sdx + 2)
3633                     {
3634                       add_psymbol_to_list (name, strlen (name), 1,
3635                                            STRUCT_DOMAIN, LOC_TYPEDEF,
3636                                            &objfile->static_psymbols,
3637                                            0, psymtab_language, objfile);
3638                     }
3639                   handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
3640
3641                   /* Skip over the block.  */
3642                   new_sdx = sh.index;
3643                   if (new_sdx <= cur_sdx)
3644                     {
3645                       /* This happens with the Ultrix kernel.  */
3646                       complaint (&symfile_complaints,
3647                                  _("bad aux index at block symbol %s"), name);
3648                       new_sdx = cur_sdx + 1;    /* Don't skip backward.  */
3649                     }
3650                   cur_sdx = new_sdx;
3651                   continue;
3652
3653                 case stFile:    /* File headers */
3654                 case stLabel:   /* Labels */
3655                 case stEnd:     /* Ends of files */
3656                   goto skip;
3657
3658                 case stLocal:   /* Local variables */
3659                   /* Normally these are skipped because we skip over
3660                      all blocks we see.  However, these can occur
3661                      as visible symbols in a .h file that contains code.  */
3662                   goto skip;
3663
3664                 default:
3665                   /* Both complaints are valid:  one gives symbol name,
3666                      the other the offending symbol type.  */
3667                   complaint (&symfile_complaints, _("unknown local symbol %s"),
3668                              name);
3669                   complaint (&symfile_complaints, _("with type %d"), sh.st);
3670                   cur_sdx++;
3671                   continue;
3672                 }
3673               /* Use this gdb symbol.  */
3674               add_psymbol_to_list (name, strlen (name), 1,
3675                                    VAR_DOMAIN, theclass,
3676                                    &objfile->static_psymbols,
3677                                    sh.value, psymtab_language, objfile);
3678             skip:
3679               cur_sdx++;        /* Go to next file symbol.  */
3680             }
3681
3682           /* Now do enter the external symbols.  */
3683           ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset];
3684           cur_sdx = fdr_to_pst[f_idx].n_globals;
3685           PST_PRIVATE (save_pst)->extern_count = cur_sdx;
3686           PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
3687           for (; --cur_sdx >= 0; ext_ptr++)
3688             {
3689               enum address_class theclass;
3690               SYMR *psh;
3691               char *name;
3692               CORE_ADDR svalue;
3693
3694               if (ext_ptr->ifd != f_idx)
3695                 internal_error (__FILE__, __LINE__,
3696                                 _("failed internal consistency check"));
3697               psh = &ext_ptr->asym;
3698
3699               /* Do not add undefined symbols to the partial symbol table.  */
3700               if (SC_IS_UNDEF (psh->sc) || psh->sc == scNil)
3701                 continue;
3702
3703               svalue = psh->value;
3704               switch (psh->sc)
3705                 {
3706                 case scText:
3707                 case scRConst:
3708                   svalue += ANOFFSET (objfile->section_offsets,
3709                                       SECT_OFF_TEXT (objfile));
3710                   break;
3711                 case scData:
3712                 case scSData:
3713                 case scRData:
3714                 case scPData:
3715                 case scXData:
3716                   svalue += ANOFFSET (objfile->section_offsets,
3717                                       SECT_OFF_DATA (objfile));
3718                   break;
3719                 case scBss:
3720                 case scSBss:
3721                   svalue += ANOFFSET (objfile->section_offsets,
3722                                       SECT_OFF_BSS (objfile));
3723                   break;
3724                 }
3725
3726               switch (psh->st)
3727                 {
3728                 case stNil:
3729                   /* These are generated for static symbols in .o files,
3730                      ignore them.  */
3731                   continue;
3732                 case stProc:
3733                 case stStaticProc:
3734                   /* External procedure symbols have been entered
3735                      into the minimal symbol table in pass 2 above.
3736                      Ignore them, as parse_external will ignore them too.  */
3737                   continue;
3738                 case stLabel:
3739                   theclass = LOC_LABEL;
3740                   break;
3741                 default:
3742                   unknown_ext_complaint (debug_info->ssext + psh->iss);
3743                   /* Fall through, pretend it's global.  */
3744                 case stGlobal:
3745                   /* Global common symbols are resolved by the runtime loader,
3746                      ignore them.  */
3747                   if (SC_IS_COMMON (psh->sc))
3748                     continue;
3749
3750                   theclass = LOC_STATIC;
3751                   break;
3752                 }
3753               name = debug_info->ssext + psh->iss;
3754               add_psymbol_to_list (name, strlen (name), 1,
3755                                    VAR_DOMAIN, theclass,
3756                                    &objfile->global_psymbols,
3757                                    svalue, psymtab_language, objfile);
3758             }
3759         }
3760
3761       /* Link pst to FDR.  dbx_end_psymtab returns NULL if the psymtab was
3762          empty and put on the free list.  */
3763       fdr_to_pst[f_idx].pst
3764         = dbx_end_psymtab (objfile, save_pst,
3765                            psymtab_include_list, includes_used,
3766                            -1, save_pst->texthigh,
3767                            dependency_list, dependencies_used,
3768                            textlow_not_set);
3769       includes_used = 0;
3770       dependencies_used = 0;
3771
3772       /* The objfile has its functions reordered if this partial symbol
3773          table overlaps any other partial symbol table.
3774          We cannot assume a reordered objfile if a partial symbol table
3775          is contained within another partial symbol table, as partial symbol
3776          tables for include files with executable code are contained
3777          within the partial symbol table for the including source file,
3778          and we do not want to flag the objfile reordered for these cases.
3779
3780          This strategy works well for Irix-5.2 shared libraries, but we
3781          might have to use a more elaborate (and slower) algorithm for
3782          other cases.  */
3783       save_pst = fdr_to_pst[f_idx].pst;
3784       if (save_pst != NULL
3785           && save_pst->textlow != 0
3786           && !(objfile->flags & OBJF_REORDERED))
3787         {
3788           ALL_OBJFILE_PSYMTABS (objfile, pst)
3789           {
3790             if (save_pst != pst
3791                 && save_pst->textlow >= pst->textlow
3792                 && save_pst->textlow < pst->texthigh
3793                 && save_pst->texthigh > pst->texthigh)
3794               {
3795                 objfile->flags |= OBJF_REORDERED;
3796                 break;
3797               }
3798           }
3799         }
3800     }
3801
3802   /* Now scan the FDRs for dependencies.  */
3803   for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
3804     {
3805       fh = f_idx + debug_info->fdr;
3806       pst = fdr_to_pst[f_idx].pst;
3807
3808       if (pst == (struct partial_symtab *) NULL)
3809         continue;
3810
3811       /* This should catch stabs-in-ecoff.  */
3812       if (fh->crfd <= 1)
3813         continue;
3814
3815       /* Skip the first file indirect entry as it is a self dependency for
3816          source files or a reverse .h -> .c dependency for header files.  */
3817       pst->number_of_dependencies = 0;
3818       pst->dependencies =
3819         ((struct partial_symtab **)
3820          obstack_alloc (&objfile->objfile_obstack,
3821                         ((fh->crfd - 1)
3822                          * sizeof (struct partial_symtab *))));
3823       for (s_idx = 1; s_idx < fh->crfd; s_idx++)
3824         {
3825           RFDT rh;
3826
3827           (*swap_rfd_in) (cur_bfd,
3828                           ((char *) debug_info->external_rfd
3829                            + (fh->rfdBase + s_idx) * external_rfd_size),
3830                           &rh);
3831           if (rh < 0 || rh >= hdr->ifdMax)
3832             {
3833               complaint (&symfile_complaints, _("bad file number %ld"), rh);
3834               continue;
3835             }
3836
3837           /* Skip self dependencies of header files.  */
3838           if (rh == f_idx)
3839             continue;
3840
3841           /* Do not add to dependeny list if psymtab was empty.  */
3842           if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL)
3843             continue;
3844           pst->dependencies[pst->number_of_dependencies++]
3845             = fdr_to_pst[rh].pst;
3846         }
3847     }
3848
3849   /* Remove the dummy psymtab created for -O3 images above, if it is
3850      still empty, to enable the detection of stripped executables.  */
3851   if (objfile->psymtabs->next == NULL
3852       && objfile->psymtabs->number_of_dependencies == 0
3853       && objfile->psymtabs->n_global_syms == 0
3854       && objfile->psymtabs->n_static_syms == 0)
3855     objfile->psymtabs = NULL;
3856   do_cleanups (old_chain);
3857 }
3858
3859 /* If the current psymbol has an enumerated type, we need to add
3860    all the enum constants to the partial symbol table.  */
3861
3862 static void
3863 handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
3864                             CORE_ADDR svalue)
3865 {
3866   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
3867   void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
3868   char *ext_sym = ((char *) debug_info->external_sym
3869                    + ((fh->isymBase + cur_sdx + 1) * external_sym_size));
3870   SYMR sh;
3871   TIR tir;
3872
3873   switch (stype)
3874     {
3875     case stEnum:
3876       break;
3877
3878     case stBlock:
3879       /* It is an enumerated type if the next symbol entry is a stMember
3880          and its auxiliary index is indexNil or its auxiliary entry
3881          is a plain btNil or btVoid.
3882          Alpha cc -migrate enums are recognized by a zero index and
3883          a zero symbol value.
3884          DU 4.0 cc enums are recognized by a member type of btEnum without
3885          qualifiers and a zero symbol value.  */
3886       (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3887       if (sh.st != stMember)
3888         return;
3889
3890       if (sh.index == indexNil
3891           || (sh.index == 0 && svalue == 0))
3892         break;
3893       (*debug_swap->swap_tir_in) (fh->fBigendian,
3894                                   &(debug_info->external_aux
3895                                     + fh->iauxBase + sh.index)->a_ti,
3896                                   &tir);
3897       if ((tir.bt != btNil
3898            && tir.bt != btVoid
3899            && (tir.bt != btEnum || svalue != 0))
3900           || tir.tq0 != tqNil)
3901         return;
3902       break;
3903
3904     default:
3905       return;
3906     }
3907
3908   for (;;)
3909     {
3910       char *name;
3911
3912       (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3913       if (sh.st != stMember)
3914         break;
3915       name = debug_info->ss + cur_fdr->issBase + sh.iss;
3916
3917       /* Note that the value doesn't matter for enum constants
3918          in psymtabs, just in symtabs.  */
3919       add_psymbol_to_list (name, strlen (name), 1,
3920                            VAR_DOMAIN, LOC_CONST,
3921                            &objfile->static_psymbols,
3922                            0, psymtab_language, objfile);
3923       ext_sym += external_sym_size;
3924     }
3925 }
3926
3927 /* Get the next symbol.  OBJFILE is unused.  */
3928
3929 static char *
3930 mdebug_next_symbol_text (struct objfile *objfile)
3931 {
3932   SYMR sh;
3933
3934   cur_sdx++;
3935   (*debug_swap->swap_sym_in) (cur_bfd,
3936                               ((char *) debug_info->external_sym
3937                                + ((cur_fdr->isymBase + cur_sdx)
3938                                   * debug_swap->external_sym_size)),
3939                               &sh);
3940   return debug_info->ss + cur_fdr->issBase + sh.iss;
3941 }
3942
3943 /* Ancillary function to psymtab_to_symtab().  Does all the work
3944    for turning the partial symtab PST into a symtab, recurring
3945    first on all dependent psymtabs.  The argument FILENAME is
3946    only passed so we can see in debug stack traces what file
3947    is being read.
3948
3949    This function has a split personality, based on whether the
3950    symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3951    The flow of control and even the memory allocation differs.  FIXME.  */
3952
3953 static void
3954 psymtab_to_symtab_1 (struct objfile *objfile,
3955                      struct partial_symtab *pst, const char *filename)
3956 {
3957   bfd_size_type external_sym_size;
3958   bfd_size_type external_pdr_size;
3959   void (*swap_sym_in) (bfd *, void *, SYMR *);
3960   void (*swap_pdr_in) (bfd *, void *, PDR *);
3961   int i;
3962   struct compunit_symtab *cust = NULL;
3963   FDR *fh;
3964   struct linetable *lines;
3965   CORE_ADDR lowest_pdr_addr = 0;
3966   int last_symtab_ended = 0;
3967   struct section_offsets *section_offsets = objfile->section_offsets;
3968
3969   if (pst->readin)
3970     return;
3971   pst->readin = 1;
3972
3973   /* Read in all partial symbtabs on which this one is dependent.
3974      NOTE that we do have circular dependencies, sigh.  We solved
3975      that by setting pst->readin before this point.  */
3976
3977   for (i = 0; i < pst->number_of_dependencies; i++)
3978     if (!pst->dependencies[i]->readin)
3979       {
3980         /* Inform about additional files to be read in.  */
3981         if (info_verbose)
3982           {
3983             fputs_filtered (" ", gdb_stdout);
3984             wrap_here ("");
3985             fputs_filtered ("and ", gdb_stdout);
3986             wrap_here ("");
3987             printf_filtered ("%s...",
3988                              pst->dependencies[i]->filename);
3989             wrap_here ("");     /* Flush output */
3990             gdb_flush (gdb_stdout);
3991           }
3992         /* We only pass the filename for debug purposes.  */
3993         psymtab_to_symtab_1 (objfile, pst->dependencies[i],
3994                              pst->dependencies[i]->filename);
3995       }
3996
3997   /* Do nothing if this is a dummy psymtab.  */
3998
3999   if (pst->n_global_syms == 0 && pst->n_static_syms == 0
4000       && pst->textlow == 0 && pst->texthigh == 0)
4001     return;
4002
4003   /* Now read the symbols for this symtab.  */
4004
4005   cur_bfd = CUR_BFD (pst);
4006   debug_swap = DEBUG_SWAP (pst);
4007   debug_info = DEBUG_INFO (pst);
4008   pending_list = PENDING_LIST (pst);
4009   external_sym_size = debug_swap->external_sym_size;
4010   external_pdr_size = debug_swap->external_pdr_size;
4011   swap_sym_in = debug_swap->swap_sym_in;
4012   swap_pdr_in = debug_swap->swap_pdr_in;
4013   mdebugread_objfile = objfile;
4014   cur_fd = FDR_IDX (pst);
4015   fh = ((cur_fd == -1)
4016         ? (FDR *) NULL
4017         : debug_info->fdr + cur_fd);
4018   cur_fdr = fh;
4019
4020   /* See comment in parse_partial_symbols about the @stabs sentinel.  */
4021   processing_gcc_compilation = 0;
4022   if (fh != (FDR *) NULL && fh->csym >= 2)
4023     {
4024       SYMR sh;
4025
4026       (*swap_sym_in) (cur_bfd,
4027                       ((char *) debug_info->external_sym
4028                        + (fh->isymBase + 1) * external_sym_size),
4029                       &sh);
4030       if (strcmp (debug_info->ss + fh->issBase + sh.iss,
4031                   stabs_symbol) == 0)
4032         {
4033           /* We indicate that this is a GCC compilation so that certain
4034              features will be enabled in stabsread/dbxread.  */
4035           processing_gcc_compilation = 2;
4036         }
4037     }
4038
4039   if (processing_gcc_compilation != 0)
4040     {
4041       struct gdbarch *gdbarch = get_objfile_arch (objfile);
4042
4043       /* This symbol table contains stabs-in-ecoff entries.  */
4044
4045       /* Parse local symbols first.  */
4046
4047       if (fh->csym <= 2)        /* FIXME, this blows psymtab->symtab ptr.  */
4048         {
4049           mdebugread_objfile = NULL;
4050           return;
4051         }
4052       for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
4053         {
4054           SYMR sh;
4055           char *name;
4056           CORE_ADDR valu;
4057
4058           (*swap_sym_in) (cur_bfd,
4059                           (((char *) debug_info->external_sym)
4060                            + (fh->isymBase + cur_sdx) * external_sym_size),
4061                           &sh);
4062           name = debug_info->ss + fh->issBase + sh.iss;
4063           valu = sh.value;
4064           /* XXX This is a hack.  It will go away!  */
4065           if (ECOFF_IS_STAB (&sh) || (name[0] == '#'))
4066             {
4067               int type_code = ECOFF_UNMARK_STAB (sh.index);
4068
4069               /* We should never get non N_STAB symbols here, but they
4070                  should be harmless, so keep process_one_symbol from
4071                  complaining about them.  */
4072               if (type_code & N_STAB)
4073                 {
4074                   /* If we found a trailing N_SO with no name, process
4075                      it here instead of in process_one_symbol, so we
4076                      can keep a handle to its symtab.  The symtab
4077                      would otherwise be ended twice, once in
4078                      process_one_symbol, and once after this loop.  */
4079                   if (type_code == N_SO
4080                       && get_last_source_file ()
4081                       && previous_stab_code != (unsigned char) N_SO
4082                       && *name == '\000')
4083                     {
4084                       valu += ANOFFSET (section_offsets,
4085                                         SECT_OFF_TEXT (objfile));
4086                       previous_stab_code = N_SO;
4087                       cust = end_symtab (valu, SECT_OFF_TEXT (objfile));
4088                       end_stabs ();
4089                       last_symtab_ended = 1;
4090                     }
4091                   else
4092                     {
4093                       last_symtab_ended = 0;
4094                       process_one_symbol (type_code, 0, valu, name,
4095                                           section_offsets, objfile);
4096                     }
4097                 }
4098               /* Similarly a hack.  */
4099               else if (name[0] == '#')
4100                 {
4101                   process_one_symbol (N_SLINE, 0, valu, name,
4102                                       section_offsets, objfile);
4103                 }
4104               if (type_code == N_FUN)
4105                 {
4106                   /* Make up special symbol to contain
4107                      procedure specific info.  */
4108                   struct mdebug_extra_func_info *e =
4109                     ((struct mdebug_extra_func_info *)
4110                      obstack_alloc (&mdebugread_objfile->objfile_obstack,
4111                                     sizeof (struct mdebug_extra_func_info)));
4112                   struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
4113
4114                   memset (e, 0, sizeof (struct mdebug_extra_func_info));
4115                   SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
4116                   SYMBOL_ACLASS_INDEX (s) = LOC_CONST;
4117                   SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_void;
4118                   SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
4119                   e->pdr.framereg = -1;
4120                   add_symbol_to_list (s, &local_symbols);
4121                 }
4122             }
4123           else if (sh.st == stLabel)
4124             {
4125               if (sh.index == indexNil)
4126                 {
4127                   /* This is what the gcc2_compiled and __gnu_compiled_*
4128                      show up as.  So don't complain.  */
4129                   ;
4130                 }
4131               else
4132                 {
4133                   /* Handle encoded stab line number.  */
4134                   valu += ANOFFSET (section_offsets,
4135                                     SECT_OFF_TEXT (objfile));
4136                   record_line (current_subfile, sh.index,
4137                                gdbarch_addr_bits_remove (gdbarch, valu));
4138                 }
4139             }
4140           else if (sh.st == stProc || sh.st == stStaticProc
4141                    || sh.st == stStatic || sh.st == stEnd)
4142             /* These are generated by gcc-2.x, do not complain.  */
4143             ;
4144           else
4145             complaint (&symfile_complaints,
4146                        _("unknown stabs symbol %s"), name);
4147         }
4148
4149       if (! last_symtab_ended)
4150         {
4151           cust = end_symtab (pst->texthigh, SECT_OFF_TEXT (objfile));
4152           end_stabs ();
4153         }
4154
4155       /* There used to be a call to sort_blocks here, but this should not
4156          be necessary for stabs symtabs.  And as sort_blocks modifies the
4157          start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
4158          it did the wrong thing if the first procedure in a file was
4159          generated via asm statements.  */
4160
4161       /* Fill in procedure info next.  */
4162       if (fh->cpd > 0)
4163         {
4164           PDR *pr_block;
4165           struct cleanup *old_chain;
4166           char *pdr_ptr;
4167           char *pdr_end;
4168           PDR *pdr_in;
4169           PDR *pdr_in_end;
4170
4171           pr_block = XNEWVEC (PDR, fh->cpd);
4172           old_chain = make_cleanup (xfree, pr_block);
4173
4174           pdr_ptr = ((char *) debug_info->external_pdr
4175                      + fh->ipdFirst * external_pdr_size);
4176           pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
4177           pdr_in = pr_block;
4178           for (;
4179                pdr_ptr < pdr_end;
4180                pdr_ptr += external_pdr_size, pdr_in++)
4181             {
4182               (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
4183
4184               /* Determine lowest PDR address, the PDRs are not always
4185                  sorted.  */
4186               if (pdr_in == pr_block)
4187                 lowest_pdr_addr = pdr_in->adr;
4188               else if (pdr_in->adr < lowest_pdr_addr)
4189                 lowest_pdr_addr = pdr_in->adr;
4190             }
4191
4192           pdr_in = pr_block;
4193           pdr_in_end = pdr_in + fh->cpd;
4194           for (; pdr_in < pdr_in_end; pdr_in++)
4195             parse_procedure (pdr_in, cust, pst);
4196
4197           do_cleanups (old_chain);
4198         }
4199     }
4200   else
4201     {
4202       /* This symbol table contains ordinary ecoff entries.  */
4203
4204       int maxlines, size;
4205       EXTR *ext_ptr;
4206
4207       if (fh == 0)
4208         {
4209           maxlines = 0;
4210           cust = new_symtab ("unknown", 0, objfile);
4211         }
4212       else
4213         {
4214           maxlines = 2 * fh->cline;
4215           cust = new_symtab (pst->filename, maxlines, objfile);
4216
4217           /* The proper language was already determined when building
4218              the psymtab, use it.  */
4219           COMPUNIT_FILETABS (cust)->language = PST_PRIVATE (pst)->pst_language;
4220         }
4221
4222       psymtab_language = COMPUNIT_FILETABS (cust)->language;
4223
4224       lines = SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust));
4225
4226       /* Get a new lexical context.  */
4227
4228       push_parse_stack ();
4229       top_stack->cur_st = COMPUNIT_FILETABS (cust);
4230       top_stack->cur_block
4231         = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
4232       BLOCK_START (top_stack->cur_block) = pst->textlow;
4233       BLOCK_END (top_stack->cur_block) = 0;
4234       top_stack->blocktype = stFile;
4235       top_stack->cur_type = 0;
4236       top_stack->procadr = 0;
4237       top_stack->numargs = 0;
4238       found_ecoff_debugging_info = 0;
4239
4240       if (fh)
4241         {
4242           char *sym_ptr;
4243           char *sym_end;
4244
4245           /* Parse local symbols first.  */
4246           sym_ptr = ((char *) debug_info->external_sym
4247                      + fh->isymBase * external_sym_size);
4248           sym_end = sym_ptr + fh->csym * external_sym_size;
4249           while (sym_ptr < sym_end)
4250             {
4251               SYMR sh;
4252               int c;
4253
4254               (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
4255               c = parse_symbol (&sh,
4256                                 debug_info->external_aux + fh->iauxBase,
4257                                 sym_ptr, fh->fBigendian,
4258                                 section_offsets, objfile);
4259               sym_ptr += c * external_sym_size;
4260             }
4261
4262           /* Linenumbers.  At the end, check if we can save memory.
4263              parse_lines has to look ahead an arbitrary number of PDR
4264              structures, so we swap them all first.  */
4265           if (fh->cpd > 0)
4266             {
4267               PDR *pr_block;
4268               struct cleanup *old_chain;
4269               char *pdr_ptr;
4270               char *pdr_end;
4271               PDR *pdr_in;
4272               PDR *pdr_in_end;
4273
4274               pr_block = XNEWVEC (PDR, fh->cpd);
4275
4276               old_chain = make_cleanup (xfree, pr_block);
4277
4278               pdr_ptr = ((char *) debug_info->external_pdr
4279                          + fh->ipdFirst * external_pdr_size);
4280               pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
4281               pdr_in = pr_block;
4282               for (;
4283                    pdr_ptr < pdr_end;
4284                    pdr_ptr += external_pdr_size, pdr_in++)
4285                 {
4286                   (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
4287
4288                   /* Determine lowest PDR address, the PDRs are not always
4289                      sorted.  */
4290                   if (pdr_in == pr_block)
4291                     lowest_pdr_addr = pdr_in->adr;
4292                   else if (pdr_in->adr < lowest_pdr_addr)
4293                     lowest_pdr_addr = pdr_in->adr;
4294                 }
4295
4296               parse_lines (fh, pr_block, lines, maxlines,
4297                            pst, lowest_pdr_addr);
4298               if (lines->nitems < fh->cline)
4299                 lines = shrink_linetable (lines);
4300
4301               /* Fill in procedure info next.  */
4302               pdr_in = pr_block;
4303               pdr_in_end = pdr_in + fh->cpd;
4304               for (; pdr_in < pdr_in_end; pdr_in++)
4305                 parse_procedure (pdr_in, NULL, pst);
4306
4307               do_cleanups (old_chain);
4308             }
4309         }
4310
4311       size = lines->nitems;
4312       if (size > 1)
4313         --size;
4314       SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust))
4315         = ((struct linetable *)
4316            obstack_copy (&mdebugread_objfile->objfile_obstack,
4317                          lines, (sizeof (struct linetable)
4318                                  + size * sizeof (lines->item))));
4319       xfree (lines);
4320
4321       /* .. and our share of externals.
4322          XXX use the global list to speed up things here.  How?
4323          FIXME, Maybe quit once we have found the right number of ext's?  */
4324       top_stack->cur_st = COMPUNIT_FILETABS (cust);
4325       top_stack->cur_block
4326         = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st),
4327                              GLOBAL_BLOCK);
4328       top_stack->blocktype = stFile;
4329
4330       ext_ptr = PST_PRIVATE (pst)->extern_tab;
4331       for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
4332         parse_external (ext_ptr, fh->fBigendian,
4333                         section_offsets, objfile);
4334
4335       /* If there are undefined symbols, tell the user.
4336          The alpha has an undefined symbol for every symbol that is
4337          from a shared library, so tell the user only if verbose is on.  */
4338       if (info_verbose && n_undef_symbols)
4339         {
4340           printf_filtered (_("File %s contains %d unresolved references:"),
4341                            symtab_to_filename_for_display
4342                              (COMPUNIT_FILETABS (cust)),
4343                            n_undef_symbols);
4344           printf_filtered ("\n\t%4d variables\n\t%4d "
4345                            "procedures\n\t%4d labels\n",
4346                            n_undef_vars, n_undef_procs, n_undef_labels);
4347           n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0;
4348
4349         }
4350       pop_parse_stack ();
4351
4352       sort_blocks (COMPUNIT_FILETABS (cust));
4353     }
4354
4355   /* Now link the psymtab and the symtab.  */
4356   pst->compunit_symtab = cust;
4357
4358   mdebugread_objfile = NULL;
4359 }
4360 \f
4361 /* Ancillary parsing procedures.  */
4362
4363 /* Return 1 if the symbol pointed to by SH has a cross reference
4364    to an opaque aggregate type, else 0.  */
4365
4366 static int
4367 has_opaque_xref (FDR *fh, SYMR *sh)
4368 {
4369   TIR tir;
4370   union aux_ext *ax;
4371   RNDXR rn[1];
4372   unsigned int rf;
4373
4374   if (sh->index == indexNil)
4375     return 0;
4376
4377   ax = debug_info->external_aux + fh->iauxBase + sh->index;
4378   (*debug_swap->swap_tir_in) (fh->fBigendian, &ax->a_ti, &tir);
4379   if (tir.bt != btStruct && tir.bt != btUnion && tir.bt != btEnum)
4380     return 0;
4381
4382   ax++;
4383   (*debug_swap->swap_rndx_in) (fh->fBigendian, &ax->a_rndx, rn);
4384   if (rn->rfd == 0xfff)
4385     rf = AUX_GET_ISYM (fh->fBigendian, ax + 1);
4386   else
4387     rf = rn->rfd;
4388   if (rf != -1)
4389     return 0;
4390   return 1;
4391 }
4392
4393 /* Lookup the type at relative index RN.  Return it in TPP
4394    if found and in any event come up with its name PNAME.
4395    BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4396    Return value says how many aux symbols we ate.  */
4397
4398 static int
4399 cross_ref (int fd, union aux_ext *ax, struct type **tpp,
4400            enum type_code type_code,
4401            /* Use to alloc new type if none is found.  */
4402            char **pname, int bigend, char *sym_name)
4403 {
4404   RNDXR rn[1];
4405   unsigned int rf;
4406   int result = 1;
4407   FDR *fh;
4408   char *esh;
4409   SYMR sh;
4410   int xref_fd;
4411   struct mdebug_pending *pend;
4412
4413   *tpp = NULL;
4414
4415   (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
4416
4417   /* Escape index means 'the next one'.  */
4418   if (rn->rfd == 0xfff)
4419     {
4420       result++;
4421       rf = AUX_GET_ISYM (bigend, ax + 1);
4422     }
4423   else
4424     {
4425       rf = rn->rfd;
4426     }
4427
4428   /* mips cc uses a rf of -1 for opaque struct definitions.
4429      Set TYPE_FLAG_STUB for these types so that check_typedef will
4430      resolve them if the struct gets defined in another compilation unit.  */
4431   if (rf == -1)
4432     {
4433       *pname = "<undefined>";
4434       *tpp = init_type (type_code, 0, TYPE_FLAG_STUB,
4435                         (char *) NULL, mdebugread_objfile);
4436       return result;
4437     }
4438
4439   /* mips cc uses an escaped rn->index of 0 for struct return types
4440      of procedures that were compiled without -g.  These will always remain
4441      undefined.  */
4442   if (rn->rfd == 0xfff && rn->index == 0)
4443     {
4444       *pname = "<undefined>";
4445       return result;
4446     }
4447
4448   /* Find the relative file descriptor and the symbol in it.  */
4449   fh = get_rfd (fd, rf);
4450   xref_fd = fh - debug_info->fdr;
4451
4452   if (rn->index >= fh->csym)
4453     {
4454       /* File indirect entry is corrupt.  */
4455       *pname = "<illegal>";
4456       bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4457       return result;
4458     }
4459
4460   /* If we have processed this symbol then we left a forwarding
4461      pointer to the type in the pending list.  If not, we`ll put
4462      it in a list of pending types, to be processed later when
4463      the file will be.  In any event, we collect the name for the
4464      type here.  */
4465
4466   esh = ((char *) debug_info->external_sym
4467          + ((fh->isymBase + rn->index)
4468             * debug_swap->external_sym_size));
4469   (*debug_swap->swap_sym_in) (cur_bfd, esh, &sh);
4470
4471   /* Make sure that this type of cross reference can be handled.  */
4472   if ((sh.sc != scInfo
4473        || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect
4474            && sh.st != stStruct && sh.st != stUnion
4475            && sh.st != stEnum))
4476       && (sh.st != stBlock || !SC_IS_COMMON (sh.sc)))
4477     {
4478       /* File indirect entry is corrupt.  */
4479       *pname = "<illegal>";
4480       bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4481       return result;
4482     }
4483
4484   *pname = debug_info->ss + fh->issBase + sh.iss;
4485
4486   pend = is_pending_symbol (fh, esh);
4487   if (pend)
4488     *tpp = pend->t;
4489   else
4490     {
4491       /* We have not yet seen this type.  */
4492
4493       if ((sh.iss == 0 && sh.st == stTypedef) || sh.st == stIndirect)
4494         {
4495           TIR tir;
4496
4497           /* alpha cc puts out a stTypedef with a sh.iss of zero for
4498              two cases:
4499              a) forward declarations of structs/unions/enums which are not
4500              defined in this compilation unit.
4501              For these the type will be void.  This is a bad design decision
4502              as cross referencing across compilation units is impossible
4503              due to the missing name.
4504              b) forward declarations of structs/unions/enums/typedefs which
4505              are defined later in this file or in another file in the same
4506              compilation unit.  Irix5 cc uses a stIndirect symbol for this.
4507              Simply cross reference those again to get the true type.
4508              The forward references are not entered in the pending list and
4509              in the symbol table.  */
4510
4511           (*debug_swap->swap_tir_in) (bigend,
4512                                       &(debug_info->external_aux
4513                                         + fh->iauxBase + sh.index)->a_ti,
4514                                       &tir);
4515           if (tir.tq0 != tqNil)
4516             complaint (&symfile_complaints,
4517                        _("illegal tq0 in forward typedef for %s"), sym_name);
4518           switch (tir.bt)
4519             {
4520             case btVoid:
4521               *tpp = init_type (type_code, 0, 0, (char *) NULL,
4522                                 mdebugread_objfile);
4523               *pname = "<undefined>";
4524               break;
4525
4526             case btStruct:
4527             case btUnion:
4528             case btEnum:
4529               cross_ref (xref_fd,
4530                          (debug_info->external_aux
4531                           + fh->iauxBase + sh.index + 1),
4532                          tpp, type_code, pname,
4533                          fh->fBigendian, sym_name);
4534               break;
4535
4536             case btTypedef:
4537               /* Follow a forward typedef.  This might recursively
4538                  call cross_ref till we get a non typedef'ed type.
4539                  FIXME: This is not correct behaviour, but gdb currently
4540                  cannot handle typedefs without type copying.  Type
4541                  copying is impossible as we might have mutual forward
4542                  references between two files and the copied type would not
4543                  get filled in when we later parse its definition.  */
4544               *tpp = parse_type (xref_fd,
4545                                  debug_info->external_aux + fh->iauxBase,
4546                                  sh.index,
4547                                  (int *) NULL,
4548                                  fh->fBigendian,
4549                                  debug_info->ss + fh->issBase + sh.iss);
4550               add_pending (fh, esh, *tpp);
4551               break;
4552
4553             default:
4554               complaint (&symfile_complaints,
4555                          _("illegal bt %d in forward typedef for %s"), tir.bt,
4556                          sym_name);
4557               *tpp = init_type (type_code, 0, 0, (char *) NULL,
4558                                 mdebugread_objfile);
4559               break;
4560             }
4561           return result;
4562         }
4563       else if (sh.st == stTypedef)
4564         {
4565           /* Parse the type for a normal typedef.  This might recursively call
4566              cross_ref till we get a non typedef'ed type.
4567              FIXME: This is not correct behaviour, but gdb currently
4568              cannot handle typedefs without type copying.  But type copying is
4569              impossible as we might have mutual forward references between
4570              two files and the copied type would not get filled in when
4571              we later parse its definition.   */
4572           *tpp = parse_type (xref_fd,
4573                              debug_info->external_aux + fh->iauxBase,
4574                              sh.index,
4575                              (int *) NULL,
4576                              fh->fBigendian,
4577                              debug_info->ss + fh->issBase + sh.iss);
4578         }
4579       else
4580         {
4581           /* Cross reference to a struct/union/enum which is defined
4582              in another file in the same compilation unit but that file
4583              has not been parsed yet.
4584              Initialize the type only, it will be filled in when
4585              it's definition is parsed.  */
4586           *tpp = init_type (type_code, 0, 0, (char *) NULL, mdebugread_objfile);
4587         }
4588       add_pending (fh, esh, *tpp);
4589     }
4590
4591   /* We used one auxent normally, two if we got a "next one" rf.  */
4592   return result;
4593 }
4594
4595
4596 /* Quick&dirty lookup procedure, to avoid the MI ones that require
4597    keeping the symtab sorted.  */
4598
4599 static struct symbol *
4600 mylookup_symbol (char *name, const struct block *block,
4601                  domain_enum domain, enum address_class theclass)
4602 {
4603   struct block_iterator iter;
4604   int inc;
4605   struct symbol *sym;
4606
4607   inc = name[0];
4608   ALL_BLOCK_SYMBOLS (block, iter, sym)
4609     {
4610       if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
4611           && SYMBOL_DOMAIN (sym) == domain
4612           && SYMBOL_CLASS (sym) == theclass
4613           && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0)
4614         return sym;
4615     }
4616
4617   block = BLOCK_SUPERBLOCK (block);
4618   if (block)
4619     return mylookup_symbol (name, block, domain, theclass);
4620   return 0;
4621 }
4622
4623
4624 /* Add a new symbol S to a block B.  */
4625
4626 static void
4627 add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
4628 {
4629   symbol_set_symtab (s, symtab);
4630   dict_add_symbol (BLOCK_DICT (b), s);
4631 }
4632
4633 /* Add a new block B to a symtab S.  */
4634
4635 static void
4636 add_block (struct block *b, struct symtab *s)
4637 {
4638   /* Cast away "const", but that's ok because we're building the
4639      symtab and blockvector here.  */
4640   struct blockvector *bv = (struct blockvector *) SYMTAB_BLOCKVECTOR (s);
4641
4642   bv = (struct blockvector *) xrealloc ((void *) bv,
4643                                         (sizeof (struct blockvector)
4644                                          + BLOCKVECTOR_NBLOCKS (bv)
4645                                          * sizeof (bv->block)));
4646   if (bv != SYMTAB_BLOCKVECTOR (s))
4647     SYMTAB_BLOCKVECTOR (s) = bv;
4648
4649   BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b;
4650 }
4651
4652 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4653    MIPS' linenumber encoding might need more than one byte
4654    to describe it, LAST is used to detect these continuation lines.
4655
4656    Combining lines with the same line number seems like a bad idea.
4657    E.g: There could be a line number entry with the same line number after the
4658    prologue and GDB should not ignore it (this is a better way to find
4659    a prologue than mips_skip_prologue).
4660    But due to the compressed line table format there are line number entries
4661    for the same line which are needed to bridge the gap to the next
4662    line number entry.  These entries have a bogus address info with them
4663    and we are unable to tell them from intended duplicate line number
4664    entries.
4665    This is another reason why -ggdb debugging format is preferable.  */
4666
4667 static int
4668 add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last)
4669 {
4670   /* DEC c89 sometimes produces zero linenos which confuse gdb.
4671      Change them to something sensible.  */
4672   if (lineno == 0)
4673     lineno = 1;
4674   if (last == 0)
4675     last = -2;                  /* Make sure we record first line.  */
4676
4677   if (last == lineno)           /* Skip continuation lines.  */
4678     return lineno;
4679
4680   lt->item[lt->nitems].line = lineno;
4681   lt->item[lt->nitems++].pc = adr << 2;
4682   return lineno;
4683 }
4684 \f
4685 /* Sorting and reordering procedures.  */
4686
4687 /* Blocks with a smaller low bound should come first.  */
4688
4689 static int
4690 compare_blocks (const void *arg1, const void *arg2)
4691 {
4692   LONGEST addr_diff;
4693   struct block **b1 = (struct block **) arg1;
4694   struct block **b2 = (struct block **) arg2;
4695
4696   addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2)));
4697   if (addr_diff == 0)
4698     return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1)));
4699   return addr_diff;
4700 }
4701
4702 /* Sort the blocks of a symtab S.
4703    Reorder the blocks in the blockvector by code-address,
4704    as required by some MI search routines.  */
4705
4706 static void
4707 sort_blocks (struct symtab *s)
4708 {
4709   /* We have to cast away const here, but this is ok because we're
4710      constructing the blockvector in this code.  */
4711   struct blockvector *bv = (struct blockvector *) SYMTAB_BLOCKVECTOR (s);
4712
4713   if (BLOCKVECTOR_NBLOCKS (bv) <= FIRST_LOCAL_BLOCK)
4714     {
4715       /* Cosmetic */
4716       if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0)
4717         BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0;
4718       if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0)
4719         BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0;
4720       return;
4721     }
4722   /*
4723    * This is very unfortunate: normally all functions are compiled in
4724    * the order they are found, but if the file is compiled -O3 things
4725    * are very different.  It would be nice to find a reliable test
4726    * to detect -O3 images in advance.
4727    */
4728   if (BLOCKVECTOR_NBLOCKS (bv) > FIRST_LOCAL_BLOCK + 1)
4729     qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
4730            BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK,
4731            sizeof (struct block *),
4732            compare_blocks);
4733
4734   {
4735     CORE_ADDR high = 0;
4736     int i, j = BLOCKVECTOR_NBLOCKS (bv);
4737
4738     for (i = FIRST_LOCAL_BLOCK; i < j; i++)
4739       if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)))
4740         high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i));
4741     BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high;
4742   }
4743
4744   BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) =
4745     BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK));
4746
4747   BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4748     BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4749   BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4750     BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4751 }
4752 \f
4753
4754 /* Constructor/restructor/destructor procedures.  */
4755
4756 /* Allocate a new symtab for NAME.  Needs an estimate of how many
4757    linenumbers MAXLINES we'll put in it.  */
4758
4759 static struct compunit_symtab *
4760 new_symtab (const char *name, int maxlines, struct objfile *objfile)
4761 {
4762   struct compunit_symtab *cust = allocate_compunit_symtab (objfile, name);
4763   struct symtab *symtab;
4764   struct blockvector *bv;
4765
4766   add_compunit_symtab_to_objfile (cust);
4767   symtab = allocate_symtab (cust, name);
4768
4769   SYMTAB_LINETABLE (symtab) = new_linetable (maxlines);
4770
4771   /* All symtabs must have at least two blocks.  */
4772   bv = new_bvect (2);
4773   BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = new_block (NON_FUNCTION_BLOCK);
4774   BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = new_block (NON_FUNCTION_BLOCK);
4775   BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4776     BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
4777   COMPUNIT_BLOCKVECTOR (cust) = bv;
4778
4779   COMPUNIT_DEBUGFORMAT (cust) = "ECOFF";
4780   return cust;
4781 }
4782
4783 /* Allocate a new partial_symtab NAME.  */
4784
4785 static struct partial_symtab *
4786 new_psymtab (char *name, struct objfile *objfile)
4787 {
4788   struct partial_symtab *psymtab;
4789
4790   psymtab = allocate_psymtab (name, objfile);
4791
4792   /* Keep a backpointer to the file's symbols.  */
4793
4794   psymtab->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
4795                                                 sizeof (struct symloc));
4796   memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
4797   CUR_BFD (psymtab) = cur_bfd;
4798   DEBUG_SWAP (psymtab) = debug_swap;
4799   DEBUG_INFO (psymtab) = debug_info;
4800   PENDING_LIST (psymtab) = pending_list;
4801
4802   /* The way to turn this into a symtab is to call...  */
4803   psymtab->read_symtab = mdebug_read_symtab;
4804   return (psymtab);
4805 }
4806
4807
4808 /* Allocate a linetable array of the given SIZE.  Since the struct
4809    already includes one item, we subtract one when calculating the
4810    proper size to allocate.  */
4811
4812 static struct linetable *
4813 new_linetable (int size)
4814 {
4815   struct linetable *l;
4816
4817   if (size > 1)
4818     --size;
4819   size = size * sizeof (l->item) + sizeof (struct linetable);
4820   l = (struct linetable *) xmalloc (size);
4821   l->nitems = 0;
4822   return l;
4823 }
4824
4825 /* Oops, too big.  Shrink it.  This was important with the 2.4 linetables,
4826    I am not so sure about the 3.4 ones.
4827
4828    Since the struct linetable already includes one item, we subtract one when
4829    calculating the proper size to allocate.  */
4830
4831 static struct linetable *
4832 shrink_linetable (struct linetable *lt)
4833 {
4834   return (struct linetable *) xrealloc ((void *) lt,
4835                                         (sizeof (struct linetable)
4836                                          + ((lt->nitems - 1)
4837                                             * sizeof (lt->item))));
4838 }
4839
4840 /* Allocate and zero a new blockvector of NBLOCKS blocks.  */
4841
4842 static struct blockvector *
4843 new_bvect (int nblocks)
4844 {
4845   struct blockvector *bv;
4846   int size;
4847
4848   size = sizeof (struct blockvector) + nblocks * sizeof (struct block *);
4849   bv = (struct blockvector *) xzalloc (size);
4850
4851   BLOCKVECTOR_NBLOCKS (bv) = nblocks;
4852
4853   return bv;
4854 }
4855
4856 /* Allocate and zero a new block, and set its BLOCK_DICT.  If function
4857    is non-zero, assume the block is associated to a function, and make
4858    sure that the symbols are stored linearly; otherwise, store them
4859    hashed.  */
4860
4861 static struct block *
4862 new_block (enum block_type type)
4863 {
4864   /* FIXME: carlton/2003-09-11: This should use allocate_block to
4865      allocate the block.  Which, in turn, suggests that the block
4866      should be allocated on an obstack.  */
4867   struct block *retval = XCNEW (struct block);
4868
4869   if (type == FUNCTION_BLOCK)
4870     BLOCK_DICT (retval) = dict_create_linear_expandable ();
4871   else
4872     BLOCK_DICT (retval) = dict_create_hashed_expandable ();
4873
4874   return retval;
4875 }
4876
4877 /* Create a new symbol with printname NAME.  */
4878
4879 static struct symbol *
4880 new_symbol (char *name)
4881 {
4882   struct symbol *s = allocate_symbol (mdebugread_objfile);
4883
4884   SYMBOL_SET_LANGUAGE (s, psymtab_language,
4885                        &mdebugread_objfile->objfile_obstack);
4886   SYMBOL_SET_NAMES (s, name, strlen (name), 1, mdebugread_objfile);
4887   return s;
4888 }
4889
4890 /* Create a new type with printname NAME.  */
4891
4892 static struct type *
4893 new_type (char *name)
4894 {
4895   struct type *t;
4896
4897   t = alloc_type (mdebugread_objfile);
4898   TYPE_NAME (t) = name;
4899   INIT_CPLUS_SPECIFIC (t);
4900   return t;
4901 }
4902 \f
4903 /* Read ECOFF debugging information from a BFD section.  This is
4904    called from elfread.c.  It parses the section into a
4905    ecoff_debug_info struct, and then lets the rest of the file handle
4906    it as normal.  */
4907
4908 void
4909 elfmdebug_build_psymtabs (struct objfile *objfile,
4910                           const struct ecoff_debug_swap *swap, asection *sec)
4911 {
4912   bfd *abfd = objfile->obfd;
4913   struct ecoff_debug_info *info;
4914   struct cleanup *back_to;
4915
4916   /* FIXME: It's not clear whether we should be getting minimal symbol
4917      information from .mdebug in an ELF file, or whether we will.
4918      Re-initialize the minimal symbol reader in case we do.  */
4919
4920   init_minimal_symbol_collection ();
4921   back_to = make_cleanup_discard_minimal_symbols ();
4922
4923   info = ((struct ecoff_debug_info *)
4924           obstack_alloc (&objfile->objfile_obstack,
4925                          sizeof (struct ecoff_debug_info)));
4926
4927   if (!(*swap->read_debug_info) (abfd, sec, info))
4928     error (_("Error reading ECOFF debugging information: %s"),
4929            bfd_errmsg (bfd_get_error ()));
4930
4931   mdebug_build_psymtabs (objfile, swap, info);
4932
4933   install_minimal_symbols (objfile);
4934   do_cleanups (back_to);
4935 }
4936
4937 void
4938 _initialize_mdebugread (void)
4939 {
4940   basic_type_data = register_objfile_data ();
4941
4942   mdebug_register_index
4943     = register_symbol_register_impl (LOC_REGISTER, &mdebug_register_funcs);
4944   mdebug_regparm_index
4945     = register_symbol_register_impl (LOC_REGPARM_ADDR, &mdebug_register_funcs);
4946 }