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