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