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