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