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