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