GDB (xrefs)
/tmp/gdb-7.10/gdb/coffread.c
Go to the documentation of this file.
1 /* Read coff symbol tables and convert to internal format, for GDB.
2  Copyright (C) 1987-2015 Free Software Foundation, Inc.
3  Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "demangle.h"
24 #include "breakpoint.h"
25 
26 #include "bfd.h"
27 #include "gdb_obstack.h"
28 #include <ctype.h>
29 
30 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
31 #include "libcoff.h" /* FIXME secret internal data from BFD */
32 #include "objfiles.h"
33 #include "buildsym.h"
34 #include "gdb-stabs.h"
35 #include "stabsread.h"
36 #include "complaints.h"
37 #include "target.h"
38 #include "block.h"
39 #include "dictionary.h"
40 
41 #include "coff-pe-read.h"
42 
43 #include "psymtab.h"
44 #include "build-id.h"
45 
46 extern void _initialize_coffread (void);
47 
48 /* Key for COFF-associated data. */
49 
50 static const struct objfile_data *coff_objfile_data_key;
51 
52 /* The objfile we are currently reading. */
53 
54 static struct objfile *coffread_objfile;
55 
57  {
58  file_ptr min_lineno_offset; /* Where in file lowest line#s are. */
59  file_ptr max_lineno_offset; /* 1+last byte of line#s in file. */
60 
61  CORE_ADDR textaddr; /* Addr of .text section. */
62  unsigned int textsize; /* Size of .text section. */
63  struct stab_section_list *stabsects; /* .stab sections. */
64  asection *stabstrsect; /* Section pointer for .stab section. */
65  char *stabstrdata;
66  };
67 
68 /* Translate an external name string into a user-visible name. */
69 #define EXTERNAL_NAME(string, abfd) \
70  (string[0] == bfd_get_symbol_leading_char (abfd) \
71  ? string + 1 : string)
72 
73 /* To be an sdb debug type, type must have at least a basic or primary
74  derived type. Using this rather than checking against T_NULL is
75  said to prevent core dumps if we try to operate on Michael Bloom
76  dbx-in-coff file. */
77 
78 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
79 
80 /* Core address of start and end of text of current source file.
81  This comes from a ".text" symbol where x_nlinno > 0. */
82 
85 
86 /* The addresses of the symbol table stream and number of symbols
87  of the object file we are reading (as copied into core). */
88 
89 static bfd *nlist_bfd_global;
90 static int nlist_nsyms_global;
91 
92 
93 /* Pointers to scratch storage, used for reading raw symbols and
94  auxents. */
95 
96 static char *temp_sym;
97 static char *temp_aux;
98 
99 /* Local variables that hold the shift and mask values for the
100  COFF file that we are currently reading. These come back to us
101  from BFD, and are referenced by their macro names, as well as
102  internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
103  macros from include/coff/internal.h . */
104 
105 static unsigned local_n_btmask;
106 static unsigned local_n_btshft;
107 static unsigned local_n_tmask;
108 static unsigned local_n_tshift;
109 
110 #define N_BTMASK local_n_btmask
111 #define N_BTSHFT local_n_btshft
112 #define N_TMASK local_n_tmask
113 #define N_TSHIFT local_n_tshift
114 
115 /* Local variables that hold the sizes in the file of various COFF
116  structures. (We only need to know this to read them from the file
117  -- BFD will then translate the data in them, into `internal_xxx'
118  structs in the right byte order, alignment, etc.) */
119 
120 static unsigned local_linesz;
121 static unsigned local_symesz;
122 static unsigned local_auxesz;
123 
124 /* This is set if this is a PE format file. */
125 
126 static int pe_file;
127 
128 /* Chain of typedefs of pointers to empty struct/union types.
129  They are chained thru the SYMBOL_VALUE_CHAIN. */
130 
131 static struct symbol *opaque_type_chain[HASHSIZE];
132 
133 /* Simplified internal version of coff symbol table information. */
134 
136  {
137  char *c_name;
138  int c_symnum; /* Symbol number of this entry. */
139  int c_naux; /* 0 if syment only, 1 if syment +
140  auxent, etc. */
142  int c_sclass;
143  int c_secnum;
144  unsigned int c_type;
145  };
146 
147 /* Vector of types defined so far, indexed by their type numbers. */
148 
149 static struct type **type_vector;
150 
151 /* Number of elements allocated for type_vector currently. */
152 
154 
155 /* Initial size of type vector. Is realloc'd larger if needed, and
156  realloc'd down to the size actually used, when completed. */
157 
158 #define INITIAL_TYPE_VECTOR_LENGTH 160
159 
160 extern void stabsread_clear_cache (void);
161 
162 static struct type *coff_read_struct_type (int, int, int,
163  struct objfile *);
164 
165 static struct type *decode_base_type (struct coff_symbol *,
166  unsigned int,
167  union internal_auxent *,
168  struct objfile *);
169 
170 static struct type *decode_type (struct coff_symbol *, unsigned int,
171  union internal_auxent *,
172  struct objfile *);
173 
174 static struct type *decode_function_type (struct coff_symbol *,
175  unsigned int,
176  union internal_auxent *,
177  struct objfile *);
178 
179 static struct type *coff_read_enum_type (int, int, int,
180  struct objfile *);
181 
182 static struct symbol *process_coff_symbol (struct coff_symbol *,
183  union internal_auxent *,
184  struct objfile *);
185 
186 static void patch_opaque_types (struct symtab *);
187 
188 static void enter_linenos (long, int, int, struct objfile *);
189 
190 static void free_linetab (void);
191 
192 static void free_linetab_cleanup (void *ignore);
193 
194 static int init_lineno (bfd *, long, int);
195 
196 static char *getsymname (struct internal_syment *);
197 
198 static const char *coff_getfilename (union internal_auxent *);
199 
200 static void free_stringtab (void);
201 
202 static void free_stringtab_cleanup (void *ignore);
203 
204 static int init_stringtab (bfd *, long);
205 
206 static void read_one_sym (struct coff_symbol *,
207  struct internal_syment *,
208  union internal_auxent *);
209 
210 static void coff_symtab_read (long, unsigned int, struct objfile *);
211 
212 /* We are called once per section from coff_symfile_read. We
213  need to examine each section we are passed, check to see
214  if it is something we are interested in processing, and
215  if so, stash away some access information for the section.
216 
217  FIXME: The section names should not be hardwired strings (what
218  should they be? I don't think most object file formats have enough
219  section flags to specify what kind of debug section it is
220  -kingdon). */
221 
222 static void
223 coff_locate_sections (bfd *abfd, asection *sectp, void *csip)
224 {
225  struct coff_symfile_info *csi;
226  const char *name;
227 
228  csi = (struct coff_symfile_info *) csip;
229  name = bfd_get_section_name (abfd, sectp);
230  if (strcmp (name, ".text") == 0)
231  {
232  csi->textaddr = bfd_section_vma (abfd, sectp);
233  csi->textsize += bfd_section_size (abfd, sectp);
234  }
235  else if (startswith (name, ".text"))
236  {
237  csi->textsize += bfd_section_size (abfd, sectp);
238  }
239  else if (strcmp (name, ".stabstr") == 0)
240  {
241  csi->stabstrsect = sectp;
242  }
243  else if (startswith (name, ".stab"))
244  {
245  const char *s;
246 
247  /* We can have multiple .stab sections if linked with
248  --split-by-reloc. */
249  for (s = name + sizeof ".stab" - 1; *s != '\0'; s++)
250  if (!isdigit (*s))
251  break;
252  if (*s == '\0')
253  {
254  struct stab_section_list *n, **pn;
255 
256  n = ((struct stab_section_list *)
257  xmalloc (sizeof (struct stab_section_list)));
258  n->section = sectp;
259  n->next = NULL;
260  for (pn = &csi->stabsects; *pn != NULL; pn = &(*pn)->next)
261  ;
262  *pn = n;
263 
264  /* This will be run after coffstab_build_psymtabs is called
265  in coff_symfile_read, at which point we no longer need
266  the information. */
267  make_cleanup (xfree, n);
268  }
269  }
270 }
271 
272 /* Return the section_offsets* that CS points to. */
273 static int cs_to_section (struct coff_symbol *, struct objfile *);
274 
276  {
278  asection **resultp;
279  };
280 
281 static void
282 find_targ_sec (bfd *abfd, asection *sect, void *obj)
283 {
284  struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
285 
286  if (sect->target_index == args->targ_index)
287  *args->resultp = sect;
288 }
289 
290 /* Return the bfd_section that CS points to. */
291 static struct bfd_section*
293 {
294  asection *sect = NULL;
295  struct find_targ_sec_arg args;
296 
297  args.targ_index = cs->c_secnum;
298  args.resultp = &sect;
299  bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
300  return sect;
301 }
302 
303 /* Return the section number (SECT_OFF_*) that CS points to. */
304 static int
306 {
307  asection *sect = cs_to_bfd_section (cs, objfile);
308 
309  if (sect == NULL)
310  return SECT_OFF_TEXT (objfile);
311  return gdb_bfd_section_index (objfile->obfd, sect);
312 }
313 
314 /* Return the address of the section of a COFF symbol. */
315 
316 static CORE_ADDR cs_section_address (struct coff_symbol *, bfd *);
317 
318 static CORE_ADDR
319 cs_section_address (struct coff_symbol *cs, bfd *abfd)
320 {
321  asection *sect = NULL;
322  struct find_targ_sec_arg args;
323  CORE_ADDR addr = 0;
324 
325  args.targ_index = cs->c_secnum;
326  args.resultp = &sect;
327  bfd_map_over_sections (abfd, find_targ_sec, &args);
328  if (sect != NULL)
329  addr = bfd_get_section_vma (abfd, sect);
330  return addr;
331 }
332 
333 /* Look up a coff type-number index. Return the address of the slot
334  where the type for that index is stored.
335  The type-number is in INDEX.
336 
337  This can be used for finding the type associated with that index
338  or for associating a new type with the index. */
339 
340 static struct type **
341 coff_lookup_type (int index)
342 {
343  if (index >= type_vector_length)
344  {
345  int old_vector_length = type_vector_length;
346 
347  type_vector_length *= 2;
348  if (index /* is still */ >= type_vector_length)
349  type_vector_length = index * 2;
350 
351  type_vector = (struct type **)
352  xrealloc ((char *) type_vector,
353  type_vector_length * sizeof (struct type *));
354  memset (&type_vector[old_vector_length], 0,
355  (type_vector_length - old_vector_length) * sizeof (struct type *));
356  }
357  return &type_vector[index];
358 }
359 
360 /* Make sure there is a type allocated for type number index
361  and return the type object.
362  This can create an empty (zeroed) type object. */
363 
364 static struct type *
365 coff_alloc_type (int index)
366 {
367  struct type **type_addr = coff_lookup_type (index);
368  struct type *type = *type_addr;
369 
370  /* If we are referring to a type not known at all yet,
371  allocate an empty type for it.
372  We will fill it in later if we find out how. */
373  if (type == NULL)
374  {
375  type = alloc_type (coffread_objfile);
376  *type_addr = type;
377  }
378  return type;
379 }
380 
381 /* Start a new symtab for a new source file.
382  This is called when a COFF ".file" symbol is seen;
383  it indicates the start of data for one original source file. */
384 
385 static void
386 coff_start_symtab (struct objfile *objfile, const char *name)
387 {
388  start_symtab (objfile,
389  /* We fill in the filename later. start_symtab puts this pointer
390  into last_source_file and we put it in subfiles->name, which
391  end_symtab frees; that's why it must be malloc'd. */
392  xstrdup (name),
393  /* We never know the directory name for COFF. */
394  NULL,
395  /* The start address is irrelevant, since we set
396  last_source_start_addr in coff_end_symtab. */
397  0);
398  record_debugformat ("COFF");
399 }
400 
401 /* Save the vital information from when starting to read a file,
402  for use when closing off the current file.
403  NAME is the file name the symbols came from, START_ADDR is the
404  first text address for the file, and SIZE is the number of bytes of
405  text. */
406 
407 static void
408 complete_symtab (const char *name, CORE_ADDR start_addr, unsigned int size)
409 {
410  set_last_source_file (name);
411  current_source_start_addr = start_addr;
412  current_source_end_addr = start_addr + size;
413 }
414 
415 /* Finish the symbol definitions for one main source file, close off
416  all the lexical contexts for that file (creating struct block's for
417  them), then make the struct symtab for that file and put it in the
418  list of all such. */
419 
420 static void
422 {
424 
426 
427  /* Reinitialize for beginning of new file. */
428  set_last_source_file (NULL);
429 }
430 
431 /* The linker sometimes generates some non-function symbols inside
432  functions referencing variables imported from another DLL.
433  Return nonzero if the given symbol corresponds to one of them. */
434 
435 static int
438 {
439  /* The following is a bit of a heuristic using the characterictics
440  of these fixup symbols, but should work well in practice... */
441  int i;
442 
443  /* Must be a non-static text symbol. */
444  if (type != mst_text)
445  return 0;
446 
447  /* Must be a non-function symbol. */
448  if (ISFCN (cs->c_type))
449  return 0;
450 
451  /* The name must start with "__fu<digits>__". */
452  if (!startswith (cs->c_name, "__fu"))
453  return 0;
454  if (! isdigit (cs->c_name[4]))
455  return 0;
456  for (i = 5; cs->c_name[i] != '\0' && isdigit (cs->c_name[i]); i++)
457  /* Nothing, just incrementing index past all digits. */;
458  if (cs->c_name[i] != '_' || cs->c_name[i + 1] != '_')
459  return 0;
460 
461  return 1;
462 }
463 
464 static struct minimal_symbol *
466  enum minimal_symbol_type type, int section,
467  struct objfile *objfile)
468 {
469  /* We don't want TDESC entry points in the minimal symbol table. */
470  if (cs->c_name[0] == '@')
471  return NULL;
472 
473  if (is_import_fixup_symbol (cs, type))
474  {
475  /* Because the value of these symbols is within a function code
476  range, these symbols interfere with the symbol-from-address
477  reverse lookup; this manifests itselfs in backtraces, or any
478  other commands that prints symbolic addresses. Just pretend
479  these symbols do not exist. */
480  return NULL;
481  }
482 
483  return prim_record_minimal_symbol_and_info (cs->c_name, address,
484  type, section, objfile);
485 }
486 
487 /* coff_symfile_init ()
488  is the coff-specific initialization routine for reading symbols.
489  It is passed a struct objfile which contains, among other things,
490  the BFD for the file whose symbols are being read, and a slot for
491  a pointer to "private data" which we fill with cookies and other
492  treats for coff_symfile_read ().
493 
494  We will only be called if this is a COFF or COFF-like file. BFD
495  handles figuring out the format of the file, and code in symtab.c
496  uses BFD's determination to vector to us.
497 
498  The ultimate result is a new symtab (or, FIXME, eventually a
499  psymtab). */
500 
501 static void
503 {
504  struct dbx_symfile_info *dbx;
505  struct coff_symfile_info *coff;
506 
507  /* Allocate struct to keep track of stab reading. */
508  dbx = XCNEW (struct dbx_symfile_info);
509  set_objfile_data (objfile, dbx_objfile_data_key, dbx);
510 
511  /* Allocate struct to keep track of the symfile. */
512  coff = XCNEW (struct coff_symfile_info);
513  set_objfile_data (objfile, coff_objfile_data_key, coff);
514 
515  /* COFF objects may be reordered, so set OBJF_REORDERED. If we
516  find this causes a significant slowdown in gdb then we could
517  set it in the debug symbol readers only when necessary. */
518  objfile->flags |= OBJF_REORDERED;
519 }
520 
521 /* This function is called for every section; it finds the outer
522  limits of the line table (minimum and maximum file offset) so that
523  the mainline code can read the whole thing for efficiency. */
524 
525 static void
526 find_linenos (bfd *abfd, struct bfd_section *asect, void *vpinfo)
527 {
528  struct coff_symfile_info *info;
529  int size, count;
530  file_ptr offset, maxoff;
531 
532  /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
533  count = asect->lineno_count;
534  /* End of warning. */
535 
536  if (count == 0)
537  return;
538  size = count * local_linesz;
539 
540  info = (struct coff_symfile_info *) vpinfo;
541  /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
542  offset = asect->line_filepos;
543  /* End of warning. */
544 
545  if (offset < info->min_lineno_offset || info->min_lineno_offset == 0)
546  info->min_lineno_offset = offset;
547 
548  maxoff = offset + size;
549  if (maxoff > info->max_lineno_offset)
550  info->max_lineno_offset = maxoff;
551 }
552 
553 
554 /* The BFD for this file -- only good while we're actively reading
555  symbols into a psymtab or a symtab. */
556 
557 static bfd *symfile_bfd;
558 
559 /* Read a symbol file, after initialization by coff_symfile_init. */
560 
561 static void
562 coff_symfile_read (struct objfile *objfile, int symfile_flags)
563 {
564  struct coff_symfile_info *info;
565  struct dbx_symfile_info *dbxinfo;
566  bfd *abfd = objfile->obfd;
567  coff_data_type *cdata = coff_data (abfd);
568  char *name = bfd_get_filename (abfd);
569  int val;
570  unsigned int num_symbols;
571  int symtab_offset;
572  int stringtab_offset;
573  struct cleanup *back_to, *cleanup_minimal_symbols;
574  int stabstrsize;
575 
576  info = objfile_data (objfile, coff_objfile_data_key);
577  dbxinfo = DBX_SYMFILE_INFO (objfile);
578  symfile_bfd = abfd; /* Kludge for swap routines. */
579 
580 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
581  num_symbols = bfd_get_symcount (abfd); /* How many syms */
582  symtab_offset = cdata->sym_filepos; /* Symbol table file offset */
583  stringtab_offset = symtab_offset + /* String table file offset */
584  num_symbols * cdata->local_symesz;
585 
586  /* Set a few file-statics that give us specific information about
587  the particular COFF file format we're reading. */
588  local_n_btmask = cdata->local_n_btmask;
589  local_n_btshft = cdata->local_n_btshft;
590  local_n_tmask = cdata->local_n_tmask;
591  local_n_tshift = cdata->local_n_tshift;
592  local_linesz = cdata->local_linesz;
593  local_symesz = cdata->local_symesz;
594  local_auxesz = cdata->local_auxesz;
595 
596  /* Allocate space for raw symbol and aux entries, based on their
597  space requirements as reported by BFD. */
598  temp_sym = (char *) xmalloc
599  (cdata->local_symesz + cdata->local_auxesz);
600  temp_aux = temp_sym + cdata->local_symesz;
602 
603  /* We need to know whether this is a PE file, because in PE files,
604  unlike standard COFF files, symbol values are stored as offsets
605  from the section address, rather than as absolute addresses.
606  FIXME: We should use BFD to read the symbol table, and thus avoid
607  this problem. */
608  pe_file =
609  startswith (bfd_get_target (objfile->obfd), "pe")
610  || startswith (bfd_get_target (objfile->obfd), "epoc-pe");
611 
612  /* End of warning. */
613 
614  info->min_lineno_offset = 0;
615  info->max_lineno_offset = 0;
616 
617  /* Only read line number information if we have symbols.
618 
619  On Windows NT, some of the system's DLL's have sections with
620  PointerToLinenumbers fields that are non-zero, but point at
621  random places within the image file. (In the case I found,
622  KERNEL32.DLL's .text section has a line number info pointer that
623  points into the middle of the string `lib\\i386\kernel32.dll'.)
624 
625  However, these DLL's also have no symbols. The line number
626  tables are meaningless without symbols. And in fact, GDB never
627  uses the line number information unless there are symbols. So we
628  can avoid spurious error messages (and maybe run a little
629  faster!) by not even reading the line number table unless we have
630  symbols. */
631  if (num_symbols > 0)
632  {
633  /* Read the line number table, all at once. */
634  bfd_map_over_sections (abfd, find_linenos, (void *) info);
635 
636  make_cleanup (free_linetab_cleanup, 0 /*ignore*/);
637  val = init_lineno (abfd, info->min_lineno_offset,
638  info->max_lineno_offset - info->min_lineno_offset);
639  if (val < 0)
640  error (_("\"%s\": error reading line numbers."), name);
641  }
642 
643  /* Now read the string table, all at once. */
644 
645  make_cleanup (free_stringtab_cleanup, 0 /*ignore*/);
646  val = init_stringtab (abfd, stringtab_offset);
647  if (val < 0)
648  error (_("\"%s\": can't get string table"), name);
649 
651  cleanup_minimal_symbols = make_cleanup_discard_minimal_symbols ();
652 
653  /* Now that the executable file is positioned at symbol table,
654  process it and define symbols accordingly. */
655 
656  coff_symtab_read ((long) symtab_offset, num_symbols, objfile);
657 
658  /* Install any minimal symbols that have been collected as the
659  current minimal symbols for this objfile. */
660 
661  install_minimal_symbols (objfile);
662 
663  if (pe_file)
664  {
665  struct minimal_symbol *msym;
666 
667  ALL_OBJFILE_MSYMBOLS (objfile, msym)
668  {
669  const char *name = MSYMBOL_LINKAGE_NAME (msym);
670 
671  /* If the minimal symbols whose name are prefixed by "__imp_"
672  or "_imp_", get rid of the prefix, and search the minimal
673  symbol in OBJFILE. Note that 'maintenance print msymbols'
674  shows that type of these "_imp_XXXX" symbols is mst_data. */
675  if (MSYMBOL_TYPE (msym) == mst_data)
676  {
677  const char *name1 = NULL;
678 
679  if (startswith (name, "_imp_"))
680  name1 = name + 5;
681  else if (startswith (name, "__imp_"))
682  name1 = name + 6;
683  if (name1 != NULL)
684  {
685  int lead = bfd_get_symbol_leading_char (objfile->obfd);
686  struct bound_minimal_symbol found;
687 
688  if (lead != '\0' && *name1 == lead)
689  name1 += 1;
690 
691  found = lookup_minimal_symbol (name1, NULL, objfile);
692 
693  /* If found, there are symbols named "_imp_foo" and "foo"
694  respectively in OBJFILE. Set the type of symbol "foo"
695  as 'mst_solib_trampoline'. */
696  if (found.minsym != NULL
697  && MSYMBOL_TYPE (found.minsym) == mst_text)
699  }
700  }
701  }
702  }
703 
704  /* Free the installed minimal symbol data. */
705  do_cleanups (cleanup_minimal_symbols);
706 
707  bfd_map_over_sections (abfd, coff_locate_sections, (void *) info);
708 
709  if (info->stabsects)
710  {
711  if (!info->stabstrsect)
712  {
713  error (_("The debugging information in `%s' is corrupted.\nThe "
714  "file has a `.stabs' section, but no `.stabstr' section."),
715  name);
716  }
717 
718  /* FIXME: dubious. Why can't we use something normal like
719  bfd_get_section_contents? */
720  bfd_seek (abfd, abfd->where, 0);
721 
722  stabstrsize = bfd_section_size (abfd, info->stabstrsect);
723 
724  coffstab_build_psymtabs (objfile,
725  info->textaddr, info->textsize,
726  info->stabsects,
727  info->stabstrsect->filepos, stabstrsize);
728  }
729  if (dwarf2_has_info (objfile, NULL))
730  {
731  /* DWARF2 sections. */
732  dwarf2_build_psymtabs (objfile);
733  }
734 
735  dwarf2_build_frame_info (objfile);
736 
737  /* Try to add separate debug file if no symbols table found. */
738  if (!objfile_has_partial_symbols (objfile))
739  {
740  char *debugfile;
741 
742  debugfile = find_separate_debug_file_by_buildid (objfile);
743 
744  if (debugfile == NULL)
745  debugfile = find_separate_debug_file_by_debuglink (objfile);
746  make_cleanup (xfree, debugfile);
747 
748  if (debugfile)
749  {
750  bfd *abfd = symfile_bfd_open (debugfile);
751 
752  make_cleanup_bfd_unref (abfd);
753  symbol_file_add_separate (abfd, debugfile, symfile_flags, objfile);
754  }
755  }
756 
757  do_cleanups (back_to);
758 }
759 
760 static void
762 {
763 }
764 
765 /* Perform any local cleanups required when we are done with a
766  particular objfile. I.E, we are in the process of discarding all
767  symbol information for an objfile, freeing up all memory held for
768  it, and unlinking the objfile struct from the global list of known
769  objfiles. */
770 
771 static void
773 {
774  /* Let stabs reader clean up. */
776 
777  dwarf2_free_objfile (objfile);
778 }
779 
780 
781 /* Given pointers to a symbol table in coff style exec file,
782  analyze them and create struct symtab's describing the symbols.
783  NSYMS is the number of symbols in the symbol table.
784  We read them one at a time using read_one_sym (). */
785 
786 static void
787 coff_symtab_read (long symtab_offset, unsigned int nsyms,
788  struct objfile *objfile)
789 {
790  struct gdbarch *gdbarch = get_objfile_arch (objfile);
791  struct context_stack *newobj;
792  struct coff_symbol coff_symbol;
793  struct coff_symbol *cs = &coff_symbol;
794  static struct internal_syment main_sym;
795  static union internal_auxent main_aux;
796  struct coff_symbol fcn_cs_saved;
797  static struct internal_syment fcn_sym_saved;
798  static union internal_auxent fcn_aux_saved;
799  /* A .file is open. */
800  int in_source_file = 0;
801  int next_file_symnum = -1;
802  /* Name of the current file. */
803  const char *filestring = "";
804  int depth = 0;
805  int fcn_first_line = 0;
806  CORE_ADDR fcn_first_line_addr = 0;
807  int fcn_last_line = 0;
808  int fcn_start_addr = 0;
809  long fcn_line_ptr = 0;
810  int val;
811  CORE_ADDR tmpaddr;
812  struct minimal_symbol *msym;
813 
814  /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
815  it's hard to know I've really worked around it. The fix should
816  be harmless, anyway). The symptom of the bug is that the first
817  fread (in read_one_sym), will (in my example) actually get data
818  from file offset 268, when the fseek was to 264 (and ftell shows
819  264). This causes all hell to break loose. I was unable to
820  reproduce this on a short test program which operated on the same
821  file, performing (I think) the same sequence of operations.
822 
823  It stopped happening when I put in this (former) rewind().
824 
825  FIXME: Find out if this has been reported to Sun, whether it has
826  been fixed in a later release, etc. */
827 
828  bfd_seek (objfile->obfd, 0, 0);
829 
830  /* Position to read the symbol table. */
831  val = bfd_seek (objfile->obfd, (long) symtab_offset, 0);
832  if (val < 0)
833  perror_with_name (objfile_name (objfile));
834 
835  coffread_objfile = objfile;
836  nlist_bfd_global = objfile->obfd;
837  nlist_nsyms_global = nsyms;
838  set_last_source_file (NULL);
839  memset (opaque_type_chain, 0, sizeof opaque_type_chain);
840 
841  if (type_vector) /* Get rid of previous one. */
842  xfree (type_vector);
844  type_vector = (struct type **)
845  xmalloc (type_vector_length * sizeof (struct type *));
846  memset (type_vector, 0, type_vector_length * sizeof (struct type *));
847 
848  coff_start_symtab (objfile, "");
849 
850  symnum = 0;
851  while (symnum < nsyms)
852  {
853  QUIT; /* Make this command interruptable. */
854 
855  read_one_sym (cs, &main_sym, &main_aux);
856 
857  if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
858  {
859  if (get_last_source_file ())
860  coff_end_symtab (objfile);
861 
862  coff_start_symtab (objfile, "_globals_");
863  /* coff_start_symtab will set the language of this symtab to
864  language_unknown, since such a ``file name'' is not
865  recognized. Override that with the minimal language to
866  allow printing values in this symtab. */
868  complete_symtab ("_globals_", 0, 0);
869  /* Done with all files, everything from here on out is
870  globals. */
871  }
872 
873  /* Special case for file with type declarations only, no
874  text. */
875  if (!get_last_source_file () && SDB_TYPE (cs->c_type)
876  && cs->c_secnum == N_DEBUG)
877  complete_symtab (filestring, 0, 0);
878 
879  /* Typedefs should not be treated as symbol definitions. */
880  if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
881  {
882  /* Record all functions -- external and static -- in
883  minsyms. */
884  int section = cs_to_section (cs, objfile);
885 
886  tmpaddr = cs->c_value;
887  record_minimal_symbol (cs, tmpaddr, mst_text,
888  section, objfile);
889 
890  fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
891  fcn_start_addr = tmpaddr;
892  fcn_cs_saved = *cs;
893  fcn_sym_saved = main_sym;
894  fcn_aux_saved = main_aux;
895  continue;
896  }
897 
898  switch (cs->c_sclass)
899  {
900  case C_EFCN:
901  case C_EXTDEF:
902  case C_ULABEL:
903  case C_USTATIC:
904  case C_LINE:
905  case C_ALIAS:
906  case C_HIDDEN:
908  _("Bad n_sclass for symbol %s"),
909  cs->c_name);
910  break;
911 
912  case C_FILE:
913  /* c_value field contains symnum of next .file entry in
914  table or symnum of first global after last .file. */
915  next_file_symnum = cs->c_value;
916  if (cs->c_naux > 0)
917  filestring = coff_getfilename (&main_aux);
918  else
919  filestring = "";
920 
921  /* Complete symbol table for last object file
922  containing debugging information. */
923  if (get_last_source_file ())
924  {
925  coff_end_symtab (objfile);
926  coff_start_symtab (objfile, filestring);
927  }
928  in_source_file = 1;
929  break;
930 
931  /* C_LABEL is used for labels and static functions.
932  Including it here allows gdb to see static functions when
933  no debug info is available. */
934  case C_LABEL:
935  /* However, labels within a function can make weird
936  backtraces, so filter them out (from phdm@macqel.be). */
937  if (within_function)
938  break;
939  case C_STAT:
940  case C_THUMBLABEL:
941  case C_THUMBSTAT:
942  case C_THUMBSTATFUNC:
943  if (cs->c_name[0] == '.')
944  {
945  if (strcmp (cs->c_name, ".text") == 0)
946  {
947  /* FIXME: don't wire in ".text" as section name or
948  symbol name! */
949  /* Check for in_source_file deals with case of a
950  file with debugging symbols followed by a later
951  file with no symbols. */
952  if (in_source_file)
953  complete_symtab (filestring,
954  cs->c_value + ANOFFSET (objfile->section_offsets,
955  SECT_OFF_TEXT (objfile)),
956  main_aux.x_scn.x_scnlen);
957  in_source_file = 0;
958  }
959  /* Flush rest of '.' symbols. */
960  break;
961  }
962  else if (!SDB_TYPE (cs->c_type)
963  && cs->c_name[0] == 'L'
964  && (startswith (cs->c_name, "LI%")
965  || startswith (cs->c_name, "LF%")
966  || startswith (cs->c_name, "LC%")
967  || startswith (cs->c_name, "LP%")
968  || startswith (cs->c_name, "LPB%")
969  || startswith (cs->c_name, "LBB%")
970  || startswith (cs->c_name, "LBE%")
971  || startswith (cs->c_name, "LPBX%")))
972  /* At least on a 3b1, gcc generates swbeg and string labels
973  that look like this. Ignore them. */
974  break;
975  /* Fall in for static symbols that don't start with '.' */
976  case C_THUMBEXT:
977  case C_THUMBEXTFUNC:
978  case C_EXT:
979  {
980  /* Record it in the minimal symbols regardless of
981  SDB_TYPE. This parallels what we do for other debug
982  formats, and probably is needed to make
983  print_address_symbolic work right without the (now
984  gone) "set fast-symbolic-addr off" kludge. */
985 
986  enum minimal_symbol_type ms_type;
987  int sec;
988  CORE_ADDR offset = 0;
989 
990  if (cs->c_secnum == N_UNDEF)
991  {
992  /* This is a common symbol. We used to rely on
993  the target to tell us whether it knows where
994  the symbol has been relocated to, but none of
995  the target implementations actually provided
996  that operation. So we just ignore the symbol,
997  the same way we would do if we had a target-side
998  symbol lookup which returned no match. */
999  break;
1000  }
1001  else if (cs->c_secnum == N_ABS)
1002  {
1003  /* Use the correct minimal symbol type (and don't
1004  relocate) for absolute values. */
1005  ms_type = mst_abs;
1006  sec = cs_to_section (cs, objfile);
1007  tmpaddr = cs->c_value;
1008  }
1009  else
1010  {
1011  asection *bfd_section = cs_to_bfd_section (cs, objfile);
1012 
1013  sec = cs_to_section (cs, objfile);
1014  tmpaddr = cs->c_value;
1015  /* Statics in a PE file also get relocated. */
1016  if (cs->c_sclass == C_EXT
1017  || cs->c_sclass == C_THUMBEXTFUNC
1018  || cs->c_sclass == C_THUMBEXT
1019  || (pe_file && (cs->c_sclass == C_STAT)))
1020  offset = ANOFFSET (objfile->section_offsets, sec);
1021 
1022  if (bfd_section->flags & SEC_CODE)
1023  {
1024  ms_type =
1025  cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
1026  || cs->c_sclass == C_THUMBEXT ?
1028  tmpaddr = gdbarch_addr_bits_remove (gdbarch, tmpaddr);
1029  }
1030  else if (bfd_section->flags & SEC_ALLOC
1031  && bfd_section->flags & SEC_LOAD)
1032  {
1033  ms_type =
1034  cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1035  ? mst_data : mst_file_data;
1036  }
1037  else if (bfd_section->flags & SEC_ALLOC)
1038  {
1039  ms_type =
1040  cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1041  ? mst_bss : mst_file_bss;
1042  }
1043  else
1044  ms_type = mst_unknown;
1045  }
1046 
1047  msym = record_minimal_symbol (cs, tmpaddr, ms_type,
1048  sec, objfile);
1049  if (msym)
1051  cs->c_sclass, msym);
1052 
1053  if (SDB_TYPE (cs->c_type))
1054  {
1055  struct symbol *sym;
1056 
1057  sym = process_coff_symbol
1058  (cs, &main_aux, objfile);
1059  SYMBOL_VALUE (sym) = tmpaddr + offset;
1060  SYMBOL_SECTION (sym) = sec;
1061  }
1062  }
1063  break;
1064 
1065  case C_FCN:
1066  if (strcmp (cs->c_name, ".bf") == 0)
1067  {
1068  within_function = 1;
1069 
1070  /* Value contains address of first non-init type
1071  code. */
1072  /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1073  contains line number of '{' }. */
1074  if (cs->c_naux != 1)
1076  _("`.bf' symbol %d has no aux entry"),
1077  cs->c_symnum);
1078  fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
1079  fcn_first_line_addr = cs->c_value;
1080 
1081  /* Might want to check that locals are 0 and
1082  context_stack_depth is zero, and complain if not. */
1083 
1084  depth = 0;
1085  newobj = push_context (depth, fcn_start_addr);
1086  fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
1087  newobj->name =
1088  process_coff_symbol (&fcn_cs_saved,
1089  &fcn_aux_saved, objfile);
1090  }
1091  else if (strcmp (cs->c_name, ".ef") == 0)
1092  {
1093  if (!within_function)
1094  error (_("Bad coff function information."));
1095  /* The value of .ef is the address of epilogue code;
1096  not useful for gdb. */
1097  /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1098  contains number of lines to '}' */
1099 
1100  if (context_stack_depth <= 0)
1101  { /* We attempted to pop an empty context stack. */
1103  _("`.ef' symbol without matching `.bf' "
1104  "symbol ignored starting at symnum %d"),
1105  cs->c_symnum);
1106  within_function = 0;
1107  break;
1108  }
1109 
1110  newobj = pop_context ();
1111  /* Stack must be empty now. */
1112  if (context_stack_depth > 0 || newobj == NULL)
1113  {
1115  _("Unmatched .ef symbol(s) ignored "
1116  "starting at symnum %d"),
1117  cs->c_symnum);
1118  within_function = 0;
1119  break;
1120  }
1121  if (cs->c_naux != 1)
1122  {
1124  _("`.ef' symbol %d has no aux entry"),
1125  cs->c_symnum);
1126  fcn_last_line = 0x7FFFFFFF;
1127  }
1128  else
1129  {
1130  fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
1131  }
1132  /* fcn_first_line is the line number of the opening '{'.
1133  Do not record it - because it would affect gdb's idea
1134  of the line number of the first statement of the
1135  function - except for one-line functions, for which
1136  it is also the line number of all the statements and
1137  of the closing '}', and for which we do not have any
1138  other statement-line-number. */
1139  if (fcn_last_line == 1)
1140  record_line (current_subfile, fcn_first_line,
1141  gdbarch_addr_bits_remove (gdbarch,
1142  fcn_first_line_addr));
1143  else
1144  enter_linenos (fcn_line_ptr, fcn_first_line,
1145  fcn_last_line, objfile);
1146 
1147  finish_block (newobj->name, &local_symbols,
1148  newobj->old_blocks, newobj->start_addr,
1149  fcn_cs_saved.c_value
1150  + fcn_aux_saved.x_sym.x_misc.x_fsize
1151  + ANOFFSET (objfile->section_offsets,
1152  SECT_OFF_TEXT (objfile)));
1153  within_function = 0;
1154  }
1155  break;
1156 
1157  case C_BLOCK:
1158  if (strcmp (cs->c_name, ".bb") == 0)
1159  {
1160  tmpaddr = cs->c_value;
1161  tmpaddr += ANOFFSET (objfile->section_offsets,
1162  SECT_OFF_TEXT (objfile));
1163  push_context (++depth, tmpaddr);
1164  }
1165  else if (strcmp (cs->c_name, ".eb") == 0)
1166  {
1167  if (context_stack_depth <= 0)
1168  { /* We attempted to pop an empty context stack. */
1170  _("`.eb' symbol without matching `.bb' "
1171  "symbol ignored starting at symnum %d"),
1172  cs->c_symnum);
1173  break;
1174  }
1175 
1176  newobj = pop_context ();
1177  if (depth-- != newobj->depth)
1178  {
1180  _("Mismatched .eb symbol ignored "
1181  "starting at symnum %d"),
1182  symnum);
1183  break;
1184  }
1186  {
1187  tmpaddr =
1188  cs->c_value + ANOFFSET (objfile->section_offsets,
1189  SECT_OFF_TEXT (objfile));
1190  /* Make a block for the local symbols within. */
1191  finish_block (0, &local_symbols, newobj->old_blocks,
1192  newobj->start_addr, tmpaddr);
1193  }
1194  /* Now pop locals of block just finished. */
1195  local_symbols = newobj->locals;
1196  }
1197  break;
1198 
1199  default:
1200  process_coff_symbol (cs, &main_aux, objfile);
1201  break;
1202  }
1203  }
1204 
1205  if ((nsyms == 0) && (pe_file))
1206  {
1207  /* We've got no debugging symbols, but it's a portable
1208  executable, so try to read the export table. */
1209  read_pe_exported_syms (objfile);
1210  }
1211 
1212  if (get_last_source_file ())
1213  coff_end_symtab (objfile);
1214 
1215  /* Patch up any opaque types (references to types that are not defined
1216  in the file where they are referenced, e.g. "struct foo *bar"). */
1217  {
1218  struct compunit_symtab *cu;
1219  struct symtab *s;
1220 
1221  ALL_OBJFILE_FILETABS (objfile, cu, s)
1222  patch_opaque_types (s);
1223  }
1224 
1225  coffread_objfile = NULL;
1226 }
1227 
1228 /* Routines for reading headers and symbols from executable. */
1229 
1230 /* Read the next symbol, swap it, and return it in both
1231  internal_syment form, and coff_symbol form. Also return its first
1232  auxent, if any, in internal_auxent form, and skip any other
1233  auxents. */
1234 
1235 static void
1237  struct internal_syment *sym,
1238  union internal_auxent *aux)
1239 {
1240  int i;
1241  bfd_size_type bytes;
1242 
1243  cs->c_symnum = symnum;
1244  bytes = bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
1245  if (bytes != local_symesz)
1246  error (_("%s: error reading symbols"), objfile_name (coffread_objfile));
1247  bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
1248  cs->c_naux = sym->n_numaux & 0xff;
1249  if (cs->c_naux >= 1)
1250  {
1251  bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1252  if (bytes != local_auxesz)
1253  error (_("%s: error reading symbols"), objfile_name (coffread_objfile));
1254  bfd_coff_swap_aux_in (symfile_bfd, temp_aux,
1255  sym->n_type, sym->n_sclass,
1256  0, cs->c_naux, (char *) aux);
1257  /* If more than one aux entry, read past it (only the first aux
1258  is important). */
1259  for (i = 1; i < cs->c_naux; i++)
1260  {
1261  bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1262  if (bytes != local_auxesz)
1263  error (_("%s: error reading symbols"),
1264  objfile_name (coffread_objfile));
1265  }
1266  }
1267  cs->c_name = getsymname (sym);
1268  cs->c_value = sym->n_value;
1269  cs->c_sclass = (sym->n_sclass & 0xff);
1270  cs->c_secnum = sym->n_scnum;
1271  cs->c_type = (unsigned) sym->n_type;
1272  if (!SDB_TYPE (cs->c_type))
1273  cs->c_type = 0;
1274 
1275 #if 0
1276  if (cs->c_sclass & 128)
1277  printf (_("thumb symbol %s, class 0x%x\n"), cs->c_name, cs->c_sclass);
1278 #endif
1279 
1280  symnum += 1 + cs->c_naux;
1281 
1282  /* The PE file format stores symbol values as offsets within the
1283  section, rather than as absolute addresses. We correct that
1284  here, if the symbol has an appropriate storage class. FIXME: We
1285  should use BFD to read the symbols, rather than duplicating the
1286  work here. */
1287  if (pe_file)
1288  {
1289  switch (cs->c_sclass)
1290  {
1291  case C_EXT:
1292  case C_THUMBEXT:
1293  case C_THUMBEXTFUNC:
1294  case C_SECTION:
1295  case C_NT_WEAK:
1296  case C_STAT:
1297  case C_THUMBSTAT:
1298  case C_THUMBSTATFUNC:
1299  case C_LABEL:
1300  case C_THUMBLABEL:
1301  case C_BLOCK:
1302  case C_FCN:
1303  case C_EFCN:
1304  if (cs->c_secnum != 0)
1305  cs->c_value += cs_section_address (cs, symfile_bfd);
1306  break;
1307  }
1308  }
1309 }
1310 
1311 /* Support for string table handling. */
1312 
1313 static char *stringtab = NULL;
1314 
1315 static int
1316 init_stringtab (bfd *abfd, long offset)
1317 {
1318  long length;
1319  int val;
1320  unsigned char lengthbuf[4];
1321 
1322  free_stringtab ();
1323 
1324  /* If the file is stripped, the offset might be zero, indicating no
1325  string table. Just return with `stringtab' set to null. */
1326  if (offset == 0)
1327  return 0;
1328 
1329  if (bfd_seek (abfd, offset, 0) < 0)
1330  return -1;
1331 
1332  val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd);
1333  length = bfd_h_get_32 (symfile_bfd, lengthbuf);
1334 
1335  /* If no string table is needed, then the file may end immediately
1336  after the symbols. Just return with `stringtab' set to null. */
1337  if (val != sizeof lengthbuf || length < sizeof lengthbuf)
1338  return 0;
1339 
1340  stringtab = (char *) xmalloc (length);
1341  /* This is in target format (probably not very useful, and not
1342  currently used), not host format. */
1343  memcpy (stringtab, lengthbuf, sizeof lengthbuf);
1344  if (length == sizeof length) /* Empty table -- just the count. */
1345  return 0;
1346 
1347  val = bfd_bread (stringtab + sizeof lengthbuf,
1348  length - sizeof lengthbuf, abfd);
1349  if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0')
1350  return -1;
1351 
1352  return 0;
1353 }
1354 
1355 static void
1357 {
1358  if (stringtab)
1359  xfree (stringtab);
1360  stringtab = NULL;
1361 }
1362 
1363 static void
1365 {
1366  free_stringtab ();
1367 }
1368 
1369 static char *
1370 getsymname (struct internal_syment *symbol_entry)
1371 {
1372  static char buffer[SYMNMLEN + 1];
1373  char *result;
1374 
1375  if (symbol_entry->_n._n_n._n_zeroes == 0)
1376  {
1377  /* FIXME: Probably should be detecting corrupt symbol files by
1378  seeing whether offset points to within the stringtab. */
1379  result = stringtab + symbol_entry->_n._n_n._n_offset;
1380  }
1381  else
1382  {
1383  strncpy (buffer, symbol_entry->_n._n_name, SYMNMLEN);
1384  buffer[SYMNMLEN] = '\0';
1385  result = buffer;
1386  }
1387  return result;
1388 }
1389 
1390 /* Extract the file name from the aux entry of a C_FILE symbol.
1391  Return only the last component of the name. Result is in static
1392  storage and is only good for temporary use. */
1393 
1394 static const char *
1395 coff_getfilename (union internal_auxent *aux_entry)
1396 {
1397  static char buffer[BUFSIZ];
1398  const char *result;
1399 
1400  if (aux_entry->x_file.x_n.x_zeroes == 0)
1401  {
1402  if (strlen (stringtab + aux_entry->x_file.x_n.x_offset) >= BUFSIZ)
1403  internal_error (__FILE__, __LINE__, _("coff file name too long"));
1404  strcpy (buffer, stringtab + aux_entry->x_file.x_n.x_offset);
1405  }
1406  else
1407  {
1408  strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
1409  buffer[FILNMLEN] = '\0';
1410  }
1411  result = buffer;
1412 
1413  /* FIXME: We should not be throwing away the information about what
1414  directory. It should go into dirname of the symtab, or some such
1415  place. */
1416  result = lbasename (result);
1417  return (result);
1418 }
1419 
1420 /* Support for line number handling. */
1421 
1422 static char *linetab = NULL;
1423 static long linetab_offset;
1424 static unsigned long linetab_size;
1425 
1426 /* Read in all the line numbers for fast lookups later. Leave them in
1427  external (unswapped) format in memory; we'll swap them as we enter
1428  them into GDB's data structures. */
1429 
1430 static int
1431 init_lineno (bfd *abfd, long offset, int size)
1432 {
1433  int val;
1434 
1436  linetab_size = size;
1437 
1438  free_linetab ();
1439 
1440  if (size == 0)
1441  return 0;
1442 
1443  if (bfd_seek (abfd, offset, 0) < 0)
1444  return -1;
1445 
1446  /* Allocate the desired table, plus a sentinel. */
1447  linetab = (char *) xmalloc (size + local_linesz);
1448 
1449  val = bfd_bread (linetab, size, abfd);
1450  if (val != size)
1451  return -1;
1452 
1453  /* Terminate it with an all-zero sentinel record. */
1454  memset (linetab + size, 0, local_linesz);
1455 
1456  return 0;
1457 }
1458 
1459 static void
1461 {
1462  if (linetab)
1463  xfree (linetab);
1464  linetab = NULL;
1465 }
1466 
1467 static void
1469 {
1470  free_linetab ();
1471 }
1472 
1473 #if !defined (L_LNNO32)
1474 #define L_LNNO32(lp) ((lp)->l_lnno)
1475 #endif
1476 
1477 static void
1478 enter_linenos (long file_offset, int first_line,
1479  int last_line, struct objfile *objfile)
1480 {
1481  struct gdbarch *gdbarch = get_objfile_arch (objfile);
1482  char *rawptr;
1483  struct internal_lineno lptr;
1484 
1485  if (!linetab)
1486  return;
1487  if (file_offset < linetab_offset)
1488  {
1490  _("Line number pointer %ld lower than start of line numbers"),
1491  file_offset);
1492  if (file_offset > linetab_size) /* Too big to be an offset? */
1493  return;
1494  file_offset += linetab_offset; /* Try reading at that linetab
1495  offset. */
1496  }
1497 
1498  rawptr = &linetab[file_offset - linetab_offset];
1499 
1500  /* Skip first line entry for each function. */
1501  rawptr += local_linesz;
1502  /* Line numbers start at one for the first line of the function. */
1503  first_line--;
1504 
1505  /* If the line number table is full (e.g. 64K lines in COFF debug
1506  info), the next function's L_LNNO32 might not be zero, so don't
1507  overstep the table's end in any case. */
1508  while (rawptr <= &linetab[0] + linetab_size)
1509  {
1510  bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
1511  rawptr += local_linesz;
1512  /* The next function, or the sentinel, will have L_LNNO32 zero;
1513  we exit. */
1514  if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
1515  {
1516  CORE_ADDR addr = lptr.l_addr.l_paddr;
1517  addr += ANOFFSET (objfile->section_offsets,
1518  SECT_OFF_TEXT (objfile));
1520  first_line + L_LNNO32 (&lptr),
1521  gdbarch_addr_bits_remove (gdbarch, addr));
1522  }
1523  else
1524  break;
1525  }
1526 }
1527 
1528 static void
1529 patch_type (struct type *type, struct type *real_type)
1530 {
1531  struct type *target = TYPE_TARGET_TYPE (type);
1532  struct type *real_target = TYPE_TARGET_TYPE (real_type);
1533  int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field);
1534 
1535  TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
1536  TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target);
1537  TYPE_FIELDS (target) = (struct field *) TYPE_ALLOC (target,
1538  field_size);
1539 
1540  memcpy (TYPE_FIELDS (target),
1541  TYPE_FIELDS (real_target),
1542  field_size);
1543 
1544  if (TYPE_NAME (real_target))
1545  {
1546  /* The previous copy of TYPE_NAME is allocated by
1547  process_coff_symbol. */
1548  if (TYPE_NAME (target))
1549  xfree ((char*) TYPE_NAME (target));
1550  TYPE_NAME (target) = xstrdup (TYPE_NAME (real_target));
1551  }
1552 }
1553 
1554 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1555  so that they can be used to print out opaque data structures
1556  properly. */
1557 
1558 static void
1560 {
1561  struct block *b;
1562  struct block_iterator iter;
1563  struct symbol *real_sym;
1564 
1565  /* Go through the per-file symbols only. */
1567  ALL_BLOCK_SYMBOLS (b, iter, real_sym)
1568  {
1569  /* Find completed typedefs to use to fix opaque ones.
1570  Remove syms from the chain when their types are stored,
1571  but search the whole chain, as there may be several syms
1572  from different files with the same name. */
1573  if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF
1574  && SYMBOL_DOMAIN (real_sym) == VAR_DOMAIN
1575  && TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR
1576  && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
1577  {
1578  const char *name = SYMBOL_LINKAGE_NAME (real_sym);
1579  int hash = hashname (name);
1580  struct symbol *sym, *prev;
1581 
1582  prev = 0;
1583  for (sym = opaque_type_chain[hash]; sym;)
1584  {
1585  if (name[0] == SYMBOL_LINKAGE_NAME (sym)[0]
1586  && strcmp (name + 1, SYMBOL_LINKAGE_NAME (sym) + 1) == 0)
1587  {
1588  if (prev)
1589  {
1590  SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
1591  }
1592  else
1593  {
1594  opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
1595  }
1596 
1597  patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
1598 
1599  if (prev)
1600  {
1601  sym = SYMBOL_VALUE_CHAIN (prev);
1602  }
1603  else
1604  {
1605  sym = opaque_type_chain[hash];
1606  }
1607  }
1608  else
1609  {
1610  prev = sym;
1611  sym = SYMBOL_VALUE_CHAIN (sym);
1612  }
1613  }
1614  }
1615  }
1616 }
1617 
1618 static int
1620 {
1621  return gdbarch_sdb_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
1622 }
1623 
1624 static const struct symbol_register_ops coff_register_funcs = {
1626 };
1627 
1628 /* The "aclass" index for computed COFF symbols. */
1629 
1631 
1632 static struct symbol *
1634  union internal_auxent *aux,
1635  struct objfile *objfile)
1636 {
1637  struct symbol *sym = allocate_symbol (objfile);
1638  char *name;
1639 
1640  name = cs->c_name;
1641  name = EXTERNAL_NAME (name, objfile->obfd);
1643  &objfile->objfile_obstack);
1644  SYMBOL_SET_NAMES (sym, name, strlen (name), 1, objfile);
1645 
1646  /* default assumptions */
1647  SYMBOL_VALUE (sym) = cs->c_value;
1648  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1649  SYMBOL_SECTION (sym) = cs_to_section (cs, objfile);
1650 
1651  if (ISFCN (cs->c_type))
1652  {
1653  SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets,
1654  SECT_OFF_TEXT (objfile));
1655  SYMBOL_TYPE (sym) =
1657  aux, objfile));
1658 
1660  if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
1661  || cs->c_sclass == C_THUMBSTATFUNC)
1663  else if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1664  || cs->c_sclass == C_THUMBEXTFUNC)
1666  }
1667  else
1668  {
1669  SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux, objfile);
1670  switch (cs->c_sclass)
1671  {
1672  case C_NULL:
1673  break;
1674 
1675  case C_AUTO:
1678  break;
1679 
1680  case C_THUMBEXT:
1681  case C_THUMBEXTFUNC:
1682  case C_EXT:
1684  SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1685  SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
1686  SECT_OFF_TEXT (objfile));
1688  break;
1689 
1690  case C_THUMBSTAT:
1691  case C_THUMBSTATFUNC:
1692  case C_STAT:
1694  SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1695  SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
1696  SECT_OFF_TEXT (objfile));
1697  if (within_function)
1698  {
1699  /* Static symbol of local scope. */
1701  }
1702  else
1703  {
1704  /* Static symbol at top level of file. */
1706  }
1707  break;
1708 
1709 #ifdef C_GLBLREG /* AMD coff */
1710  case C_GLBLREG:
1711 #endif
1712  case C_REG:
1714  SYMBOL_VALUE (sym) = cs->c_value;
1716  break;
1717 
1718  case C_THUMBLABEL:
1719  case C_LABEL:
1720  break;
1721 
1722  case C_ARG:
1723  SYMBOL_ACLASS_INDEX (sym) = LOC_ARG;
1724  SYMBOL_IS_ARGUMENT (sym) = 1;
1726  break;
1727 
1728  case C_REGPARM:
1730  SYMBOL_IS_ARGUMENT (sym) = 1;
1731  SYMBOL_VALUE (sym) = cs->c_value;
1733  break;
1734 
1735  case C_TPDEF:
1737  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1738 
1739  /* If type has no name, give it one. */
1740  if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1741  {
1742  if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1743  || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1744  {
1745  /* If we are giving a name to a type such as
1746  "pointer to foo" or "function returning foo", we
1747  better not set the TYPE_NAME. If the program
1748  contains "typedef char *caddr_t;", we don't want
1749  all variables of type char * to print as caddr_t.
1750  This is not just a consequence of GDB's type
1751  management; CC and GCC (at least through version
1752  2.4) both output variables of either type char *
1753  or caddr_t with the type refering to the C_TPDEF
1754  symbol for caddr_t. If a future compiler cleans
1755  this up it GDB is not ready for it yet, but if it
1756  becomes ready we somehow need to disable this
1757  check (without breaking the PCC/GCC2.4 case).
1758 
1759  Sigh.
1760 
1761  Fortunately, this check seems not to be necessary
1762  for anything except pointers or functions. */
1763  ;
1764  }
1765  else
1766  TYPE_NAME (SYMBOL_TYPE (sym)) =
1767  xstrdup (SYMBOL_LINKAGE_NAME (sym));
1768  }
1769 
1770  /* Keep track of any type which points to empty structured
1771  type, so it can be filled from a definition from another
1772  file. A simple forward reference (TYPE_CODE_UNDEF) is
1773  not an empty structured type, though; the forward
1774  references work themselves out via the magic of
1775  coff_lookup_type. */
1776  if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1777  && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0
1779  != TYPE_CODE_UNDEF)
1780  {
1781  int i = hashname (SYMBOL_LINKAGE_NAME (sym));
1782 
1783  SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
1784  opaque_type_chain[i] = sym;
1785  }
1787  break;
1788 
1789  case C_STRTAG:
1790  case C_UNTAG:
1791  case C_ENTAG:
1793  SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
1794 
1795  /* Some compilers try to be helpful by inventing "fake"
1796  names for anonymous enums, structures, and unions, like
1797  "~0fake" or ".0fake". Thanks, but no thanks... */
1798  if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1799  if (SYMBOL_LINKAGE_NAME (sym) != NULL
1800  && *SYMBOL_LINKAGE_NAME (sym) != '~'
1801  && *SYMBOL_LINKAGE_NAME (sym) != '.')
1802  TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
1803  concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL);
1804 
1806  break;
1807 
1808  default:
1809  break;
1810  }
1811  }
1812  return sym;
1813 }
1814 
1815 /* Decode a coff type specifier; return the type that is meant. */
1816 
1817 static struct type *
1818 decode_type (struct coff_symbol *cs, unsigned int c_type,
1819  union internal_auxent *aux, struct objfile *objfile)
1820 {
1821  struct type *type = 0;
1822  unsigned int new_c_type;
1823 
1824  if (c_type & ~N_BTMASK)
1825  {
1826  new_c_type = DECREF (c_type);
1827  if (ISPTR (c_type))
1828  {
1829  type = decode_type (cs, new_c_type, aux, objfile);
1830  type = lookup_pointer_type (type);
1831  }
1832  else if (ISFCN (c_type))
1833  {
1834  type = decode_type (cs, new_c_type, aux, objfile);
1835  type = lookup_function_type (type);
1836  }
1837  else if (ISARY (c_type))
1838  {
1839  int i, n;
1840  unsigned short *dim;
1841  struct type *base_type, *index_type, *range_type;
1842 
1843  /* Define an array type. */
1844  /* auxent refers to array, not base type. */
1845  if (aux->x_sym.x_tagndx.l == 0)
1846  cs->c_naux = 0;
1847 
1848  /* Shift the indices down. */
1849  dim = &aux->x_sym.x_fcnary.x_ary.x_dimen[0];
1850  i = 1;
1851  n = dim[0];
1852  for (i = 0; *dim && i < DIMNUM - 1; i++, dim++)
1853  *dim = *(dim + 1);
1854  *dim = 0;
1855 
1856  base_type = decode_type (cs, new_c_type, aux, objfile);
1857  index_type = objfile_type (objfile)->builtin_int;
1858  range_type
1859  = create_static_range_type ((struct type *) NULL,
1860  index_type, 0, n - 1);
1861  type =
1862  create_array_type ((struct type *) NULL,
1863  base_type, range_type);
1864  }
1865  return type;
1866  }
1867 
1868  /* Reference to existing type. This only occurs with the struct,
1869  union, and enum types. EPI a29k coff fakes us out by producing
1870  aux entries with a nonzero x_tagndx for definitions of structs,
1871  unions, and enums, so we have to check the c_sclass field. SCO
1872  3.2v4 cc gets confused with pointers to pointers to defined
1873  structs, and generates negative x_tagndx fields. */
1874  if (cs->c_naux > 0 && aux->x_sym.x_tagndx.l != 0)
1875  {
1876  if (cs->c_sclass != C_STRTAG
1877  && cs->c_sclass != C_UNTAG
1878  && cs->c_sclass != C_ENTAG
1879  && aux->x_sym.x_tagndx.l >= 0)
1880  {
1881  type = coff_alloc_type (aux->x_sym.x_tagndx.l);
1882  return type;
1883  }
1884  else
1885  {
1887  _("Symbol table entry for %s has bad tagndx value"),
1888  cs->c_name);
1889  /* And fall through to decode_base_type... */
1890  }
1891  }
1892 
1893  return decode_base_type (cs, BTYPE (c_type), aux, objfile);
1894 }
1895 
1896 /* Decode a coff type specifier for function definition;
1897  return the type that the function returns. */
1898 
1899 static struct type *
1901  unsigned int c_type,
1902  union internal_auxent *aux,
1903  struct objfile *objfile)
1904 {
1905  if (aux->x_sym.x_tagndx.l == 0)
1906  cs->c_naux = 0; /* auxent refers to function, not base
1907  type. */
1908 
1909  return decode_type (cs, DECREF (c_type), aux, objfile);
1910 }
1911 
1912 /* Basic C types. */
1913 
1914 static struct type *
1916  unsigned int c_type,
1917  union internal_auxent *aux,
1918  struct objfile *objfile)
1919 {
1920  struct gdbarch *gdbarch = get_objfile_arch (objfile);
1921  struct type *type;
1922 
1923  switch (c_type)
1924  {
1925  case T_NULL:
1926  /* Shows up with "void (*foo)();" structure members. */
1927  return objfile_type (objfile)->builtin_void;
1928 
1929 #ifdef T_VOID
1930  case T_VOID:
1931  /* Intel 960 COFF has this symbol and meaning. */
1932  return objfile_type (objfile)->builtin_void;
1933 #endif
1934 
1935  case T_CHAR:
1936  return objfile_type (objfile)->builtin_char;
1937 
1938  case T_SHORT:
1939  return objfile_type (objfile)->builtin_short;
1940 
1941  case T_INT:
1942  return objfile_type (objfile)->builtin_int;
1943 
1944  case T_LONG:
1945  if (cs->c_sclass == C_FIELD
1946  && aux->x_sym.x_misc.x_lnsz.x_size
1947  > gdbarch_long_bit (gdbarch))
1948  return objfile_type (objfile)->builtin_long_long;
1949  else
1950  return objfile_type (objfile)->builtin_long;
1951 
1952  case T_FLOAT:
1953  return objfile_type (objfile)->builtin_float;
1954 
1955  case T_DOUBLE:
1956  return objfile_type (objfile)->builtin_double;
1957 
1958  case T_LNGDBL:
1959  return objfile_type (objfile)->builtin_long_double;
1960 
1961  case T_STRUCT:
1962  if (cs->c_naux != 1)
1963  {
1964  /* Anonymous structure type. */
1965  type = coff_alloc_type (cs->c_symnum);
1966  TYPE_CODE (type) = TYPE_CODE_STRUCT;
1967  TYPE_NAME (type) = NULL;
1968  /* This used to set the tag to "<opaque>". But I think
1969  setting it to NULL is right, and the printing code can
1970  print it as "struct {...}". */
1971  TYPE_TAG_NAME (type) = NULL;
1972  INIT_CPLUS_SPECIFIC (type);
1973  TYPE_LENGTH (type) = 0;
1974  TYPE_FIELDS (type) = 0;
1975  TYPE_NFIELDS (type) = 0;
1976  }
1977  else
1978  {
1979  type = coff_read_struct_type (cs->c_symnum,
1980  aux->x_sym.x_misc.x_lnsz.x_size,
1981  aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
1982  objfile);
1983  }
1984  return type;
1985 
1986  case T_UNION:
1987  if (cs->c_naux != 1)
1988  {
1989  /* Anonymous union type. */
1990  type = coff_alloc_type (cs->c_symnum);
1991  TYPE_NAME (type) = NULL;
1992  /* This used to set the tag to "<opaque>". But I think
1993  setting it to NULL is right, and the printing code can
1994  print it as "union {...}". */
1995  TYPE_TAG_NAME (type) = NULL;
1996  INIT_CPLUS_SPECIFIC (type);
1997  TYPE_LENGTH (type) = 0;
1998  TYPE_FIELDS (type) = 0;
1999  TYPE_NFIELDS (type) = 0;
2000  }
2001  else
2002  {
2003  type = coff_read_struct_type (cs->c_symnum,
2004  aux->x_sym.x_misc.x_lnsz.x_size,
2005  aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
2006  objfile);
2007  }
2008  TYPE_CODE (type) = TYPE_CODE_UNION;
2009  return type;
2010 
2011  case T_ENUM:
2012  if (cs->c_naux != 1)
2013  {
2014  /* Anonymous enum type. */
2015  type = coff_alloc_type (cs->c_symnum);
2016  TYPE_CODE (type) = TYPE_CODE_ENUM;
2017  TYPE_NAME (type) = NULL;
2018  /* This used to set the tag to "<opaque>". But I think
2019  setting it to NULL is right, and the printing code can
2020  print it as "enum {...}". */
2021  TYPE_TAG_NAME (type) = NULL;
2022  TYPE_LENGTH (type) = 0;
2023  TYPE_FIELDS (type) = 0;
2024  TYPE_NFIELDS (type) = 0;
2025  }
2026  else
2027  {
2028  type = coff_read_enum_type (cs->c_symnum,
2029  aux->x_sym.x_misc.x_lnsz.x_size,
2030  aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
2031  objfile);
2032  }
2033  return type;
2034 
2035  case T_MOE:
2036  /* Shouldn't show up here. */
2037  break;
2038 
2039  case T_UCHAR:
2040  return objfile_type (objfile)->builtin_unsigned_char;
2041 
2042  case T_USHORT:
2043  return objfile_type (objfile)->builtin_unsigned_short;
2044 
2045  case T_UINT:
2046  return objfile_type (objfile)->builtin_unsigned_int;
2047 
2048  case T_ULONG:
2049  if (cs->c_sclass == C_FIELD
2050  && aux->x_sym.x_misc.x_lnsz.x_size
2051  > gdbarch_long_bit (gdbarch))
2052  return objfile_type (objfile)->builtin_unsigned_long_long;
2053  else
2054  return objfile_type (objfile)->builtin_unsigned_long;
2055  }
2057  _("Unexpected type for symbol %s"), cs->c_name);
2058  return objfile_type (objfile)->builtin_void;
2059 }
2060 
2061 /* This page contains subroutines of read_type. */
2062 
2063 /* Read the description of a structure (or union type) and return an
2064  object describing the type. */
2065 
2066 static struct type *
2067 coff_read_struct_type (int index, int length, int lastsym,
2068  struct objfile *objfile)
2069 {
2070  struct nextfield
2071  {
2072  struct nextfield *next;
2073  struct field field;
2074  };
2075 
2076  struct type *type;
2077  struct nextfield *list = 0;
2078  struct nextfield *newobj;
2079  int nfields = 0;
2080  int n;
2081  char *name;
2082  struct coff_symbol member_sym;
2083  struct coff_symbol *ms = &member_sym;
2084  struct internal_syment sub_sym;
2085  union internal_auxent sub_aux;
2086  int done = 0;
2087 
2088  type = coff_alloc_type (index);
2089  TYPE_CODE (type) = TYPE_CODE_STRUCT;
2090  INIT_CPLUS_SPECIFIC (type);
2091  TYPE_LENGTH (type) = length;
2092 
2093  while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
2094  {
2095  read_one_sym (ms, &sub_sym, &sub_aux);
2096  name = ms->c_name;
2097  name = EXTERNAL_NAME (name, objfile->obfd);
2098 
2099  switch (ms->c_sclass)
2100  {
2101  case C_MOS:
2102  case C_MOU:
2103 
2104  /* Get space to record the next field's data. */
2105  newobj = (struct nextfield *) alloca (sizeof (struct nextfield));
2106  newobj->next = list;
2107  list = newobj;
2108 
2109  /* Save the data. */
2110  list->field.name = obstack_copy0 (&objfile->objfile_obstack,
2111  name, strlen (name));
2112  FIELD_TYPE (list->field) = decode_type (ms, ms->c_type,
2113  &sub_aux, objfile);
2114  SET_FIELD_BITPOS (list->field, 8 * ms->c_value);
2115  FIELD_BITSIZE (list->field) = 0;
2116  nfields++;
2117  break;
2118 
2119  case C_FIELD:
2120 
2121  /* Get space to record the next field's data. */
2122  newobj = (struct nextfield *) alloca (sizeof (struct nextfield));
2123  newobj->next = list;
2124  list = newobj;
2125 
2126  /* Save the data. */
2127  list->field.name = obstack_copy0 (&objfile->objfile_obstack,
2128  name, strlen (name));
2129  FIELD_TYPE (list->field) = decode_type (ms, ms->c_type,
2130  &sub_aux, objfile);
2131  SET_FIELD_BITPOS (list->field, ms->c_value);
2132  FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
2133  nfields++;
2134  break;
2135 
2136  case C_EOS:
2137  done = 1;
2138  break;
2139  }
2140  }
2141  /* Now create the vector of fields, and record how big it is. */
2142 
2143  TYPE_NFIELDS (type) = nfields;
2144  TYPE_FIELDS (type) = (struct field *)
2145  TYPE_ALLOC (type, sizeof (struct field) * nfields);
2146 
2147  /* Copy the saved-up fields into the field vector. */
2148 
2149  for (n = nfields; list; list = list->next)
2150  TYPE_FIELD (type, --n) = list->field;
2151 
2152  return type;
2153 }
2154 
2155 /* Read a definition of an enumeration type,
2156  and create and return a suitable type object.
2157  Also defines the symbols that represent the values of the type. */
2158 
2159 static struct type *
2160 coff_read_enum_type (int index, int length, int lastsym,
2161  struct objfile *objfile)
2162 {
2163  struct gdbarch *gdbarch = get_objfile_arch (objfile);
2164  struct symbol *sym;
2165  struct type *type;
2166  int nsyms = 0;
2167  int done = 0;
2168  struct pending **symlist;
2169  struct coff_symbol member_sym;
2170  struct coff_symbol *ms = &member_sym;
2171  struct internal_syment sub_sym;
2172  union internal_auxent sub_aux;
2173  struct pending *osyms, *syms;
2174  int o_nsyms;
2175  int n;
2176  char *name;
2177  int unsigned_enum = 1;
2178 
2179  type = coff_alloc_type (index);
2180  if (within_function)
2181  symlist = &local_symbols;
2182  else
2183  symlist = &file_symbols;
2184  osyms = *symlist;
2185  o_nsyms = osyms ? osyms->nsyms : 0;
2186 
2187  while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
2188  {
2189  read_one_sym (ms, &sub_sym, &sub_aux);
2190  name = ms->c_name;
2191  name = EXTERNAL_NAME (name, objfile->obfd);
2192 
2193  switch (ms->c_sclass)
2194  {
2195  case C_MOE:
2196  sym = allocate_symbol (objfile);
2197 
2199  obstack_copy0 (&objfile->objfile_obstack,
2200  name, strlen (name)));
2202  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
2203  SYMBOL_VALUE (sym) = ms->c_value;
2204  add_symbol_to_list (sym, symlist);
2205  nsyms++;
2206  break;
2207 
2208  case C_EOS:
2209  /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2210  up the count of how many symbols to read. So stop
2211  on .eos. */
2212  done = 1;
2213  break;
2214  }
2215  }
2216 
2217  /* Now fill in the fields of the type-structure. */
2218 
2219  if (length > 0)
2220  TYPE_LENGTH (type) = length;
2221  else /* Assume ints. */
2222  TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
2223  TYPE_CODE (type) = TYPE_CODE_ENUM;
2224  TYPE_NFIELDS (type) = nsyms;
2225  TYPE_FIELDS (type) = (struct field *)
2226  TYPE_ALLOC (type, sizeof (struct field) * nsyms);
2227 
2228  /* Find the symbols for the values and put them into the type.
2229  The symbols can be found in the symlist that we put them on
2230  to cause them to be defined. osyms contains the old value
2231  of that symlist; everything up to there was defined by us. */
2232  /* Note that we preserve the order of the enum constants, so
2233  that in something like "enum {FOO, LAST_THING=FOO}" we print
2234  FOO, not LAST_THING. */
2235 
2236  for (syms = *symlist, n = 0; syms; syms = syms->next)
2237  {
2238  int j = 0;
2239 
2240  if (syms == osyms)
2241  j = o_nsyms;
2242  for (; j < syms->nsyms; j++, n++)
2243  {
2244  struct symbol *xsym = syms->symbol[j];
2245 
2246  SYMBOL_TYPE (xsym) = type;
2247  TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
2248  SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
2249  if (SYMBOL_VALUE (xsym) < 0)
2250  unsigned_enum = 0;
2251  TYPE_FIELD_BITSIZE (type, n) = 0;
2252  }
2253  if (syms == osyms)
2254  break;
2255  }
2256 
2257  if (unsigned_enum)
2258  TYPE_UNSIGNED (type) = 1;
2259 
2260  return type;
2261 }
2262 
2263 /* Register our ability to parse symbols for coff BFD files. */
2264 
2265 static const struct sym_fns coff_sym_fns =
2266 {
2267  coff_new_init, /* sym_new_init: init anything gbl to
2268  entire symtab */
2269  coff_symfile_init, /* sym_init: read initial info, setup
2270  for sym_read() */
2271  coff_symfile_read, /* sym_read: read a symbol file into
2272  symtab */
2273  NULL, /* sym_read_psymbols */
2274  coff_symfile_finish, /* sym_finish: finished with file,
2275  cleanup */
2276  default_symfile_offsets, /* sym_offsets: xlate external to
2277  internal form */
2278  default_symfile_segments, /* sym_segments: Get segment
2279  information from a file */
2280  NULL, /* sym_read_linetable */
2281 
2282  default_symfile_relocate, /* sym_relocate: Relocate a debug
2283  section. */
2284  NULL, /* sym_probe_fns */
2286 };
2287 
2288 /* Free the per-objfile COFF data. */
2289 
2290 static void
2291 coff_free_info (struct objfile *objfile, void *arg)
2292 {
2293  xfree (arg);
2294 }
2295 
2296 void
2298 {
2299  add_symtab_fns (bfd_target_coff_flavour, &coff_sym_fns);
2300 
2301  coff_objfile_data_key = register_objfile_data_with_cleanup (NULL,
2302  coff_free_info);
2303 
2305  = register_symbol_register_impl (LOC_REGISTER, &coff_register_funcs);
2306 }
int c_secnum
Definition: coffread.c:143
static unsigned local_n_tmask
Definition: coffread.c:107
int dwarf2_has_info(struct objfile *objfile, const struct dwarf2_debug_sections *names)
Definition: dwarf2read.c:2032
struct field field
Definition: dwarf2read.c:1305
static struct minimal_symbol * record_minimal_symbol(struct coff_symbol *cs, CORE_ADDR address, enum minimal_symbol_type type, int section, struct objfile *objfile)
Definition: coffread.c:465
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:683
bfd * obfd
Definition: objfiles.h:313
#define ALL_OBJFILE_FILETABS(objfile, cu, s)
Definition: objfiles.h:591
static CORE_ADDR current_source_start_addr
Definition: coffread.c:83
struct type * create_static_range_type(struct type *result_type, struct type *index_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:867
static struct type * decode_type(struct coff_symbol *, unsigned int, union internal_auxent *, struct objfile *)
Definition: coffread.c:1818
static void enter_linenos(long, int, int, struct objfile *)
Definition: coffread.c:1478
void dwarf2_build_frame_info(struct objfile *objfile)
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:409
struct type * builtin_void
Definition: gdbtypes.h:1570
bfd_vma CORE_ADDR
Definition: common-types.h:41
unsigned int textsize
Definition: coffread.c:62
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
static void free_stringtab_cleanup(void *ignore)
Definition: coffread.c:1364
char * find_separate_debug_file_by_buildid(struct objfile *objfile)
Definition: build-id.c:141
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition: gdb_bfd.c:806
static void coff_symfile_finish(struct objfile *objfile)
Definition: coffread.c:772
void xfree(void *)
Definition: common-utils.c:97
int hashname(const char *name)
Definition: buildsym.c:1664
void coffstab_build_psymtabs(struct objfile *objfile, CORE_ADDR textaddr, unsigned int textsize, struct stab_section_list *stabsects, file_ptr stabstroffset, unsigned int stabstrsize)
Definition: dbxread.c:3282
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
struct type * builtin_double
Definition: gdbtypes.h:1583
struct type * create_array_type(struct type *result_type, struct type *element_type, struct type *range_type)
Definition: gdbtypes.c:1119
struct type * builtin_long_double
Definition: gdbtypes.h:1584
static void coff_start_symtab(struct objfile *objfile, const char *name)
Definition: coffread.c:386
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
static struct type ** coff_lookup_type(int index)
Definition: coffread.c:341
#define INIT_CPLUS_SPECIFIC(type)
Definition: gdbtypes.h:1195
static char * getsymname(struct internal_syment *)
Definition: coffread.c:1370
static int init_stringtab(bfd *, long)
Definition: coffread.c:1316
void _initialize_coffread(void)
Definition: coffread.c:2297
void set_last_source_file(const char *name)
Definition: buildsym.c:1720
#define SYMBOL_SET_LINKAGE_NAME(symbol, linkage_name)
Definition: symtab.h:207
static void patch_opaque_types(struct symtab *)
Definition: coffread.c:1559
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
static unsigned local_n_btmask
Definition: coffread.c:105
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
void add_symtab_fns(enum bfd_flavour flavour, const struct sym_fns *sf)
Definition: symfile.c:1800
EXTERN struct pending * file_symbols
Definition: buildsym.h:109
struct type * builtin_float
Definition: gdbtypes.h:1582
static CORE_ADDR current_source_end_addr
Definition: coffread.c:84
struct symfile_segment_data * default_symfile_segments(bfd *abfd)
Definition: symfile.c:812
struct symbol * symbol[PENDINGSIZE]
Definition: buildsym.h:102
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1507
void dwarf2_build_psymtabs(struct objfile *objfile)
Definition: dwarf2read.c:4236
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
static struct type * coff_read_enum_type(int, int, int, struct objfile *)
Definition: coffread.c:2160
static int pe_file
Definition: coffread.c:126
struct type * builtin_short
Definition: gdbtypes.h:1572
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
static void coff_free_info(struct objfile *objfile, void *arg)
Definition: coffread.c:2291
struct type * builtin_long_long
Definition: gdbtypes.h:1575
EXTERN int context_stack_depth
Definition: buildsym.h:162
static int type_vector_length
Definition: coffread.c:153
#define SET_FIELD_BITPOS(thisfld, bitpos)
Definition: gdbtypes.h:1349
struct type * builtin_long
Definition: gdbtypes.h:1574
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1367
static struct type * decode_function_type(struct coff_symbol *, unsigned int, union internal_auxent *, struct objfile *)
Definition: coffread.c:1900
static const char * coff_getfilename(union internal_auxent *)
Definition: coffread.c:1395
#define INITIAL_TYPE_VECTOR_LENGTH
Definition: coffread.c:158
EXTERN struct subfile * current_subfile
Definition: buildsym.h:73
struct obstack objfile_obstack
Definition: objfiles.h:328
static void free_stringtab(void)
Definition: coffread.c:1356
int objfile_has_partial_symbols(struct objfile *objfile)
Definition: objfiles.c:921
const char *const name
Definition: aarch64-tdep.c:68
static void free_linetab(void)
Definition: coffread.c:1460
#define SYMTAB_BLOCKVECTOR(symtab)
Definition: symtab.h:968
bfd_byte * default_symfile_relocate(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition: symfile.c:3740
asection * section
Definition: stabsread.h:157
EXTERN unsigned int symnum
Definition: buildsym.h:90
#define SYMBOL_ACLASS_INDEX(symbol)
Definition: symtab.h:792
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:182
struct type * builtin_unsigned_long_long
Definition: gdbtypes.h:1581
int nsyms
Definition: buildsym.h:101
#define SDB_TYPE(type)
Definition: coffread.c:78
static void coff_locate_sections(bfd *abfd, asection *sectp, void *csip)
Definition: coffread.c:223
void dwarf2_free_objfile(struct objfile *objfile)
Definition: dwarf2read.c:22162
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:790
EXTERN struct pending * global_symbols
Definition: buildsym.h:113
struct pending * next
Definition: buildsym.h:100
struct pending_block * old_blocks
Definition: buildsym.h:138
void symbol_file_add_separate(bfd *bfd, const char *name, int symfile_flags, struct objfile *objfile)
Definition: symfile.c:1249
static unsigned local_linesz
Definition: coffread.c:120
static bfd * symfile_bfd
Definition: coffread.c:557
#define N_BTMASK
Definition: coffread.c:110
struct stab_section_list * next
Definition: stabsread.h:154
#define SYMBOL_SET_LANGUAGE(symbol, language, obstack)
Definition: symtab.h:196
static char * linetab
Definition: coffread.c:1422
struct type * builtin_char
Definition: gdbtypes.h:1571
static void coff_end_symtab(struct objfile *objfile)
Definition: coffread.c:421
static int nlist_nsyms_global
Definition: coffread.c:90
void free_current_contents(void *ptr)
Definition: utils.c:476
static unsigned local_n_tshift
Definition: coffread.c:108
struct type * builtin_unsigned_long
Definition: gdbtypes.h:1580
static long linetab_offset
Definition: coffread.c:1423
void complaint(struct complaints **complaints, const char *fmt,...)
Definition: complaints.c:251
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
EXTERN struct pending * local_symbols
Definition: buildsym.h:117
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
Definition: gdbtypes.h:749
asection ** resultp
Definition: coffread.c:278
static char * temp_sym
Definition: coffread.c:96
struct context_stack * pop_context(void)
Definition: buildsym.c:1653
#define L_LNNO32(lp)
Definition: coffread.c:1474
struct type * alloc_type(struct objfile *objfile)
Definition: gdbtypes.c:165
int c_sclass
Definition: coffread.c:142
static const char * type
Definition: language.c:103
const char * get_last_source_file(void)
Definition: buildsym.c:1729
static char * stringtab
Definition: coffread.c:1313
char * find_separate_debug_file_by_debuglink(struct objfile *objfile)
Definition: symfile.c:1566
static struct bfd_section * cs_to_bfd_section(struct coff_symbol *cs, struct objfile *objfile)
Definition: coffread.c:292
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
struct cleanup * make_cleanup_discard_minimal_symbols(void)
Definition: minsyms.c:1115
#define SET_FIELD_ENUMVAL(thisfld, enumval)
Definition: gdbtypes.h:1352
static CORE_ADDR cs_section_address(struct coff_symbol *, bfd *)
Definition: coffread.c:319
#define TYPE_FIELDS(thistype)
Definition: gdbtypes.h:1242
static void coff_symfile_read(struct objfile *objfile, int symfile_flags)
Definition: coffread.c:562
void gdbarch_coff_make_msymbol_special(struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
Definition: gdbarch.c:3166
Definition: symtab.h:925
static void complete_symtab(const char *name, CORE_ADDR start_addr, unsigned int size)
Definition: coffread.c:408
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
#define FIELD_BITSIZE(thisfld)
Definition: gdbtypes.h:1365
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
void * xmalloc(YYSIZE_T)
struct compunit_symtab * start_symtab(struct objfile *objfile, const char *name, const char *comp_dir, CORE_ADDR start_addr)
Definition: buildsym.c:1036
static struct symbol * process_coff_symbol(struct coff_symbol *, union internal_auxent *, struct objfile *)
Definition: coffread.c:1633
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1377
bfd * symfile_bfd_open(const char *name)
Definition: symfile.c:1721
static struct type * coff_read_struct_type(int, int, int, struct objfile *)
Definition: coffread.c:2067
struct type * builtin_unsigned_short
Definition: gdbtypes.h:1578
CORE_ADDR textaddr
Definition: coffread.c:61
#define EXTERNAL_NAME(string, abfd)
Definition: coffread.c:69
static int coff_register_index
Definition: coffread.c:1630
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:233
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:181
static unsigned long linetab_size
Definition: coffread.c:1424
#define SYMBOL_VALUE_CHAIN(symbol)
Definition: symtab.h:186
Definition: block.h:60
void init_minimal_symbol_collection(void)
Definition: minsyms.c:925
file_ptr max_lineno_offset
Definition: coffread.c:59
struct type * builtin_int
Definition: gdbtypes.h:1573
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
void read_pe_exported_syms(struct objfile *objfile)
Definition: coff-pe-read.c:334
static unsigned local_symesz
Definition: coffread.c:121
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
int c_naux
Definition: coffread.c:139
static void find_linenos(bfd *abfd, struct bfd_section *asect, void *vpinfo)
Definition: coffread.c:526
char * stabstrdata
Definition: coffread.c:65
static struct objfile * coffread_objfile
Definition: coffread.c:54
static char * temp_aux
Definition: coffread.c:97
#define SYMBOL_SET_NAMES(symbol, linkage_name, len, copy_name, objfile)
Definition: symtab.h:212
struct nextfield * next
Definition: dwarf2read.c:1302
unsigned length
Definition: gdbtypes.h:807
struct stab_section_list * stabsects
Definition: coffread.c:63
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:382
static void read_one_sym(struct coff_symbol *, struct internal_syment *, union internal_auxent *)
Definition: coffread.c:1236
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
struct pending * locals
Definition: buildsym.h:130
struct symbol * allocate_symbol(struct objfile *objfile)
Definition: symtab.c:6204
static void free_linetab_cleanup(void *ignore)
Definition: coffread.c:1468
static const struct objfile_data * coff_objfile_data_key
Definition: coffread.c:50
char * c_name
Definition: coffread.c:137
#define DBX_SYMFILE_INFO(o)
Definition: gdb-stabs.h:62
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
void record_debugformat(const char *format)
Definition: buildsym.c:1671
struct complaints * symfile_complaints
Definition: complaints.c:105
struct minimal_symbol * minsym
Definition: minsyms.h:32
const char * name
Definition: gdbtypes.h:559
file_ptr min_lineno_offset
Definition: coffread.c:58
static void patch_type(struct type *type, struct type *real_type)
Definition: coffread.c:1529
const struct quick_symbol_functions psym_functions
Definition: psymtab.c:1466
static bfd * nlist_bfd_global
Definition: coffread.c:89
static void find_targ_sec(bfd *abfd, asection *sect, void *obj)
Definition: coffread.c:282
int offset
Definition: agent.c:65
int register_symbol_register_impl(enum address_class aclass, const struct symbol_register_ops *ops)
Definition: symtab.c:6154
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
record_line_ftype record_line
Definition: buffer.h:23
CORE_ADDR start_addr
Definition: buildsym.h:146
EXTERN CORE_ADDR last_source_start_addr
Definition: buildsym.h:53
void default_symfile_offsets(struct objfile *objfile, const struct section_addr_info *addrs)
Definition: symfile.c:722
static struct type ** type_vector
Definition: coffread.c:149
int gdbarch_sdb_reg_to_regnum(struct gdbarch *gdbarch, int sdb_regnr)
Definition: gdbarch.c:2083
static void coff_symfile_init(struct objfile *objfile)
Definition: coffread.c:502
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
static void coff_new_init(struct objfile *ignore)
Definition: coffread.c:761
#define HASHSIZE
Definition: buildsym.h:46
static int init_lineno(bfd *, long, int)
Definition: coffread.c:1431
#define ALL_OBJFILE_MSYMBOLS(objfile, m)
Definition: objfiles.h:602
int c_symnum
Definition: coffread.c:138
struct symbol * name
Definition: buildsym.h:142
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
struct type * builtin_unsigned_int
Definition: gdbtypes.h:1579
#define TYPE_ALLOC(t, size)
Definition: gdbtypes.h:1631
enum language language
Definition: buildsym.h:69
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
const struct objfile_data * dbx_objfile_data_key
Definition: dbxread.c:65
Definition: symtab.h:703
static struct type * coff_alloc_type(int index)
Definition: coffread.c:365
struct context_stack * push_context(int desc, CORE_ADDR valu)
Definition: buildsym.c:1623
unsigned short flags
Definition: objfiles.h:282
static unsigned local_auxesz
Definition: coffread.c:122
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
#define SYMBOL_SECTION(symbol)
Definition: symtab.h:188
struct section_offsets * section_offsets
Definition: objfiles.h:362
minimal_symbol_type
Definition: symtab.h:287
#define QUIT
Definition: defs.h:160
#define OBJF_REORDERED
Definition: objfiles.h:425
EXTERN int within_function
Definition: buildsym.h:174
void install_minimal_symbols(struct objfile *objfile)
Definition: minsyms.c:1248
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
static int is_import_fixup_symbol(struct coff_symbol *cs, enum minimal_symbol_type type)
Definition: coffread.c:436
static int coff_reg_to_regnum(struct symbol *sym, struct gdbarch *gdbarch)
Definition: coffread.c:1619
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
static unsigned local_n_btshft
Definition: coffread.c:106
static void coff_symtab_read(long, unsigned int, struct objfile *)
Definition: coffread.c:787
static int cs_to_section(struct coff_symbol *, struct objfile *)
Definition: coffread.c:305
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
#define ALL_BLOCK_SYMBOLS(block, iter, sym)
Definition: block.h:333
static struct type * decode_base_type(struct coff_symbol *, unsigned int, union internal_auxent *, struct objfile *)
Definition: coffread.c:1915
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
#define FIELD_TYPE(thisfld)
Definition: gdbtypes.h:1339
unsigned int c_type
Definition: coffread.c:144
struct type * builtin_unsigned_char
Definition: gdbtypes.h:1577
CORE_ADDR c_value
Definition: coffread.c:141
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:482
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:795
asection * stabstrsect
Definition: coffread.c:64
file_ptr symtab_offset
Definition: gdb-stabs.h:44
struct block * finish_block(struct symbol *symbol, struct pending **listhead, struct pending_block *old_blocks, CORE_ADDR start, CORE_ADDR end)
Definition: buildsym.c:515
void stabsread_clear_cache(void)
Definition: stabsread.c:502