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