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