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