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