OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [coffread.c] - Blame information for rev 330

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.