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