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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [xcoffread.c] - Blame information for rev 104

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Read AIX xcoff symbol tables and convert to internal format, for GDB.
2
   Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 1997
3
   Free Software Foundation, Inc.
4
   Derived from coffread.c, dbxread.c, and a lot of hacking.
5
   Contributed by IBM Corporation.
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 2 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, write to the Free Software
21
   Foundation, Inc., 59 Temple Place - Suite 330,
22
   Boston, MA 02111-1307, USA.  */
23
 
24
#include "defs.h"
25
#include "bfd.h"
26
 
27
#include <sys/types.h>
28
#include <fcntl.h>
29
#include <ctype.h>
30
#include "gdb_string.h"
31
 
32
#include <sys/param.h>
33
#ifndef NO_SYS_FILE
34
#include <sys/file.h>
35
#endif
36
#include "gdb_stat.h"
37
 
38
#include "coff/internal.h"
39
#include "libcoff.h"            /* FIXME, internal data from BFD */
40
#include "coff/rs6000.h"
41
 
42
#include "symtab.h"
43
#include "gdbtypes.h"
44
#include "symfile.h"
45
#include "objfiles.h"
46
#include "buildsym.h"
47
#include "stabsread.h"
48
#include "expression.h"
49
#include "language.h"           /* Needed inside partial-stab.h */
50
#include "complaints.h"
51
 
52
#include "gdb-stabs.h"
53
 
54
/* For interface with stabsread.c.  */
55
#include "aout/stab_gnu.h"
56
 
57
/* For interface with partial-stab.h.  */
58
#define N_UNDF  0                /* Undefined symbol */
59
#undef N_ABS
60
#define N_ABS 2
61
#define N_TEXT  4               /* Text sym -- defined at offset in text seg */
62
#define N_DATA  6               /* Data sym -- defined at offset in data seg */
63
#define N_BSS   8               /* BSS  sym -- defined at offset in zero'd seg */
64
#define N_COMM  0x12            /* Common symbol (visible after shared lib dynlink) */
65
#define N_FN    0x1f            /* File name of .o file */
66
#define N_FN_SEQ 0x0C           /* N_FN from Sequent compilers (sigh) */
67
/* Note: N_EXT can only be usefully OR-ed with N_UNDF, N_ABS, N_TEXT,
68
   N_DATA, or N_BSS.  When the low-order bit of other types is set,
69
   (e.g. N_WARNING versus N_FN), they are two different types.  */
70
#define N_EXT   1               /* External symbol (as opposed to local-to-this-file) */
71
#define N_INDR 0x0a
72
 
73
/* The following symbols refer to set elements.
74
   All the N_SET[ATDB] symbols with the same name form one set.
75
   Space is allocated for the set in the text section, and each set
76
   elements value is stored into one word of the space.
77
   The first word of the space is the length of the set (number of elements).
78
 
79
   The address of the set is made into an N_SETV symbol
80
   whose name is the same as the name of the set.
81
   This symbol acts like a N_DATA global symbol
82
   in that it can satisfy undefined external references.  */
83
 
84
/* These appear as input to LD, in a .o file.  */
85
#define N_SETA  0x14            /* Absolute set element symbol */
86
#define N_SETT  0x16            /* Text set element symbol */
87
#define N_SETD  0x18            /* Data set element symbol */
88
#define N_SETB  0x1A            /* Bss set element symbol */
89
 
90
/* This is output from LD.  */
91
#define N_SETV  0x1C            /* Pointer to set vector in data area.  */
92
 
93
/* We put a pointer to this structure in the read_symtab_private field
94
   of the psymtab.  */
95
 
96
struct symloc
97
  {
98
 
99
    /* First symbol number for this file.  */
100
 
101
    int first_symnum;
102
 
103
    /* Number of symbols in the section of the symbol table devoted to
104
       this file's symbols (actually, the section bracketed may contain
105
       more than just this file's symbols).  If numsyms is 0, the only
106
       reason for this thing's existence is the dependency list.  Nothing
107
       else will happen when it is read in.  */
108
 
109
    int numsyms;
110
 
111
    /* Position of the start of the line number information for this psymtab.  */
112
    unsigned int lineno_off;
113
  };
114
 
115
/* Remember what we deduced to be the source language of this psymtab. */
116
 
117
static enum language psymtab_language = language_unknown;
118
 
119
 
120
/* Simplified internal version of coff symbol table information */
121
 
122
struct coff_symbol
123
  {
124
    char *c_name;
125
    int c_symnum;               /* symbol number of this entry */
126
    int c_naux;                 /* 0 if syment only, 1 if syment + auxent */
127
    long c_value;
128
    unsigned char c_sclass;
129
    int c_secnum;
130
    unsigned int c_type;
131
  };
132
 
133
/* last function's saved coff symbol `cs' */
134
 
135
static struct coff_symbol fcn_cs_saved;
136
 
137
static bfd *symfile_bfd;
138
 
139
/* Core address of start and end of text of current source file.
140
   This is calculated from the first function seen after a C_FILE
141
   symbol. */
142
 
143
 
144
static CORE_ADDR cur_src_end_addr;
145
 
146
/* Core address of the end of the first object file.  */
147
 
148
static CORE_ADDR first_object_file_end;
149
 
150
/* initial symbol-table-debug-string vector length */
151
 
152
#define INITIAL_STABVECTOR_LENGTH       40
153
 
154
/* Nonzero if within a function (so symbols should be local,
155
   if nothing says specifically).  */
156
 
157
int within_function;
158
 
159
/* Size of a COFF symbol.  I think it is always 18, so I'm not sure
160
   there is any reason not to just use a #define, but might as well
161
   ask BFD for the size and store it here, I guess.  */
162
 
163
static unsigned local_symesz;
164
 
165
struct coff_symfile_info
166
  {
167
    file_ptr min_lineno_offset; /* Where in file lowest line#s are */
168
    file_ptr max_lineno_offset; /* 1+last byte of line#s in file */
169
 
170
    /* Pointer to the string table.  */
171
    char *strtbl;
172
 
173
    /* Pointer to debug section.  */
174
    char *debugsec;
175
 
176
    /* Pointer to the a.out symbol table.  */
177
    char *symtbl;
178
 
179
    /* Number of symbols in symtbl.  */
180
    int symtbl_num_syms;
181
 
182
    /* Offset in data section to TOC anchor.  */
183
    CORE_ADDR toc_offset;
184
  };
185
 
186
static struct complaint storclass_complaint =
187
{"Unexpected storage class: %d", 0, 0};
188
 
189
static struct complaint bf_notfound_complaint =
190
{"line numbers off, `.bf' symbol not found", 0, 0};
191
 
192
static struct complaint ef_complaint =
193
{"Mismatched .ef symbol ignored starting at symnum %d", 0, 0};
194
 
195
static struct complaint eb_complaint =
196
{"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
197
 
198
static void
199
xcoff_initial_scan PARAMS ((struct objfile *, int));
200
 
201
static void
202
scan_xcoff_symtab PARAMS ((struct objfile *));
203
 
204
static char *
205
  xcoff_next_symbol_text PARAMS ((struct objfile *));
206
 
207
static void
208
record_include_begin PARAMS ((struct coff_symbol *));
209
 
210
static void
211
enter_line_range PARAMS ((struct subfile *, unsigned, unsigned,
212
                          CORE_ADDR, CORE_ADDR, unsigned *));
213
 
214
static void
215
init_stringtab PARAMS ((bfd *, file_ptr, struct objfile *));
216
 
217
static void
218
xcoff_symfile_init PARAMS ((struct objfile *));
219
 
220
static void
221
xcoff_new_init PARAMS ((struct objfile *));
222
 
223
static void
224
xcoff_symfile_finish PARAMS ((struct objfile *));
225
 
226
static void
227
  xcoff_symfile_offsets PARAMS ((struct objfile *, struct section_addr_info *addrs));
228
 
229
static void
230
find_linenos PARAMS ((bfd *, sec_ptr, PTR));
231
 
232
static char *
233
  coff_getfilename PARAMS ((union internal_auxent *, struct objfile *));
234
 
235
static void
236
read_symbol PARAMS ((struct internal_syment *, int));
237
 
238
static int
239
read_symbol_lineno PARAMS ((int));
240
 
241
static int
242
read_symbol_nvalue PARAMS ((int));
243
 
244
static struct symbol *
245
  process_xcoff_symbol PARAMS ((struct coff_symbol *, struct objfile *));
246
 
247
static void
248
read_xcoff_symtab PARAMS ((struct partial_symtab *));
249
 
250
#if 0
251
static void
252
add_stab_to_list PARAMS ((char *, struct pending_stabs **));
253
#endif
254
 
255
static int
256
compare_lte PARAMS ((const void *, const void *));
257
 
258
static struct linetable *
259
  arrange_linetable PARAMS ((struct linetable *));
260
 
261
static void
262
record_include_end PARAMS ((struct coff_symbol *));
263
 
264
static void
265
process_linenos PARAMS ((CORE_ADDR, CORE_ADDR));
266
 
267
 
268
/* Translate from a COFF section number (target_index) to a SECT_OFF_*
269
   code.  */
270
static int secnum_to_section PARAMS ((int, struct objfile *));
271
static asection *secnum_to_bfd_section PARAMS ((int, struct objfile *));
272
 
273
struct find_targ_sec_arg
274
  {
275
    int targ_index;
276
    int *resultp;
277
    asection **bfd_sect;
278
  };
279
 
280
static void find_targ_sec PARAMS ((bfd *, asection *, void *));
281
 
282
static void
283
find_targ_sec (abfd, sect, obj)
284
     bfd *abfd;
285
     asection *sect;
286
     PTR obj;
287
{
288
  struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
289
  if (sect->target_index == args->targ_index)
290
    {
291
      /* This is the section.  Figure out what SECT_OFF_* code it is.  */
292
      if (bfd_get_section_flags (abfd, sect) & SEC_CODE)
293
        *args->resultp = SECT_OFF_TEXT;
294
      else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
295
        *args->resultp = SECT_OFF_DATA;
296
      else
297
        *args->resultp = SECT_OFF_BSS;
298
      *args->bfd_sect = sect;
299
    }
300
}
301
 
302
/* Return the section number (SECT_OFF_*) that CS points to.  */
303
static int
304
secnum_to_section (secnum, objfile)
305
     int secnum;
306
     struct objfile *objfile;
307
{
308
  int off = SECT_OFF_TEXT;
309
  asection *sect = NULL;
310
  struct find_targ_sec_arg args;
311
  args.targ_index = secnum;
312
  args.resultp = &off;
313
  args.bfd_sect = &sect;
314
  bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
315
  return off;
316
}
317
 
318
/* Return the BFD section that CS points to.  */
319
static asection *
320
secnum_to_bfd_section (secnum, objfile)
321
     int secnum;
322
     struct objfile *objfile;
323
{
324
  int off = SECT_OFF_TEXT;
325
  asection *sect = NULL;
326
  struct find_targ_sec_arg args;
327
  args.targ_index = secnum;
328
  args.resultp = &off;
329
  args.bfd_sect = &sect;
330
  bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
331
  return sect;
332
}
333
 
334
/* add a given stab string into given stab vector. */
335
 
336
#if 0
337
 
338
static void
339
add_stab_to_list (stabname, stabvector)
340
     char *stabname;
341
     struct pending_stabs **stabvector;
342
{
343
  if (*stabvector == NULL)
344
    {
345
      *stabvector = (struct pending_stabs *)
346
        xmalloc (sizeof (struct pending_stabs) +
347
                 INITIAL_STABVECTOR_LENGTH * sizeof (char *));
348
      (*stabvector)->count = 0;
349
      (*stabvector)->length = INITIAL_STABVECTOR_LENGTH;
350
    }
351
  else if ((*stabvector)->count >= (*stabvector)->length)
352
    {
353
      (*stabvector)->length += INITIAL_STABVECTOR_LENGTH;
354
      *stabvector = (struct pending_stabs *)
355
        xrealloc ((char *) *stabvector, sizeof (struct pending_stabs) +
356
                    (*stabvector)->length * sizeof (char *));
357
    }
358
  (*stabvector)->stab[(*stabvector)->count++] = stabname;
359
}
360
 
361
#endif
362
/* *INDENT-OFF* */
363
/* Linenos are processed on a file-by-file basis.
364
 
365
   Two reasons:
366
 
367
   1) xlc (IBM's native c compiler) postpones static function code
368
   emission to the end of a compilation unit. This way it can
369
   determine if those functions (statics) are needed or not, and
370
   can do some garbage collection (I think). This makes line
371
   numbers and corresponding addresses unordered, and we end up
372
   with a line table like:
373
 
374
 
375
   lineno       addr
376
   foo()          10    0x100
377
   20   0x200
378
   30   0x300
379
 
380
   foo3()         70    0x400
381
   80   0x500
382
   90   0x600
383
 
384
   static foo2()
385
   40   0x700
386
   50   0x800
387
   60   0x900
388
 
389
   and that breaks gdb's binary search on line numbers, if the
390
   above table is not sorted on line numbers. And that sort
391
   should be on function based, since gcc can emit line numbers
392
   like:
393
 
394
   10   0x100   - for the init/test part of a for stmt.
395
   20   0x200
396
   30   0x300
397
   10   0x400   - for the increment part of a for stmt.
398
 
399
   arrange_linetable() will do this sorting.
400
 
401
   2)   aix symbol table might look like:
402
 
403
   c_file               // beginning of a new file
404
   .bi          // beginning of include file
405
   .ei          // end of include file
406
   .bi
407
   .ei
408
 
409
   basically, .bi/.ei pairs do not necessarily encapsulate
410
   their scope. They need to be recorded, and processed later
411
   on when we come the end of the compilation unit.
412
   Include table (inclTable) and process_linenos() handle
413
   that.  */
414
/* *INDENT-ON* */
415
 
416
 
417
 
418
/* compare line table entry addresses. */
419
 
420
static int
421
compare_lte (lte1p, lte2p)
422
     const void *lte1p;
423
     const void *lte2p;
424
{
425
  struct linetable_entry *lte1 = (struct linetable_entry *) lte1p;
426
  struct linetable_entry *lte2 = (struct linetable_entry *) lte2p;
427
  return lte1->pc - lte2->pc;
428
}
429
 
430
/* Given a line table with function entries are marked, arrange its functions
431
   in ascending order and strip off function entry markers and return it in
432
   a newly created table. If the old one is good enough, return the old one. */
433
/* FIXME: I think all this stuff can be replaced by just passing
434
   sort_linevec = 1 to end_symtab.  */
435
 
436
static struct linetable *
437
arrange_linetable (oldLineTb)
438
     struct linetable *oldLineTb;       /* old linetable */
439
{
440
  int ii, jj, newline,          /* new line count */
441
    function_count;             /* # of functions */
442
 
443
  struct linetable_entry *fentry;       /* function entry vector */
444
  int fentry_size;              /* # of function entries */
445
  struct linetable *newLineTb;  /* new line table */
446
 
447
#define NUM_OF_FUNCTIONS 20
448
 
449
  fentry_size = NUM_OF_FUNCTIONS;
450
  fentry = (struct linetable_entry *)
451
    xmalloc (fentry_size * sizeof (struct linetable_entry));
452
 
453
  for (function_count = 0, ii = 0; ii < oldLineTb->nitems; ++ii)
454
    {
455
 
456
      if (oldLineTb->item[ii].line == 0)
457
        {                       /* function entry found. */
458
 
459
          if (function_count >= fentry_size)
460
            {                   /* make sure you have room. */
461
              fentry_size *= 2;
462
              fentry = (struct linetable_entry *)
463
                xrealloc (fentry, fentry_size * sizeof (struct linetable_entry));
464
            }
465
          fentry[function_count].line = ii;
466
          fentry[function_count].pc = oldLineTb->item[ii].pc;
467
          ++function_count;
468
        }
469
    }
470
 
471
  if (function_count == 0)
472
    {
473
      free (fentry);
474
      return oldLineTb;
475
    }
476
  else if (function_count > 1)
477
    qsort (fentry, function_count, sizeof (struct linetable_entry), compare_lte);
478
 
479
  /* allocate a new line table. */
480
  newLineTb = (struct linetable *)
481
    xmalloc
482
    (sizeof (struct linetable) +
483
    (oldLineTb->nitems - function_count) * sizeof (struct linetable_entry));
484
 
485
  /* if line table does not start with a function beginning, copy up until
486
     a function begin. */
487
 
488
  newline = 0;
489
  if (oldLineTb->item[0].line != 0)
490
    for (newline = 0;
491
    newline < oldLineTb->nitems && oldLineTb->item[newline].line; ++newline)
492
      newLineTb->item[newline] = oldLineTb->item[newline];
493
 
494
  /* Now copy function lines one by one. */
495
 
496
  for (ii = 0; ii < function_count; ++ii)
497
    {
498
      for (jj = fentry[ii].line + 1;
499
           jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0;
500
           ++jj, ++newline)
501
        newLineTb->item[newline] = oldLineTb->item[jj];
502
    }
503
  free (fentry);
504
  newLineTb->nitems = oldLineTb->nitems - function_count;
505
  return newLineTb;
506
}
507
 
508
/* include file support: C_BINCL/C_EINCL pairs will be kept in the
509
   following `IncludeChain'. At the end of each symtab (end_symtab),
510
   we will determine if we should create additional symtab's to
511
   represent if (the include files. */
512
 
513
 
514
typedef struct _inclTable
515
{
516
  char *name;                   /* include filename */
517
 
518
  /* Offsets to the line table.  end points to the last entry which is
519
     part of this include file.  */
520
  int begin, end;
521
 
522
  struct subfile *subfile;
523
  unsigned funStartLine;        /* start line # of its function */
524
}
525
InclTable;
526
 
527
#define INITIAL_INCLUDE_TABLE_LENGTH    20
528
static InclTable *inclTable;    /* global include table */
529
static int inclIndx;            /* last entry to table */
530
static int inclLength;          /* table length */
531
static int inclDepth;           /* nested include depth */
532
 
533
static void allocate_include_entry PARAMS ((void));
534
 
535
static void
536
record_include_begin (cs)
537
     struct coff_symbol *cs;
538
{
539
  if (inclDepth)
540
    {
541
      /* In xcoff, we assume include files cannot be nested (not in .c files
542
         of course, but in corresponding .s files.).  */
543
 
544
      /* This can happen with old versions of GCC.
545
         GCC 2.3.3-930426 does not exhibit this on a test case which
546
         a user said produced the message for him.  */
547
      static struct complaint msg =
548
      {"Nested C_BINCL symbols", 0, 0};
549
      complain (&msg);
550
    }
551
  ++inclDepth;
552
 
553
  allocate_include_entry ();
554
 
555
  inclTable[inclIndx].name = cs->c_name;
556
  inclTable[inclIndx].begin = cs->c_value;
557
}
558
 
559
static void
560
record_include_end (cs)
561
     struct coff_symbol *cs;
562
{
563
  InclTable *pTbl;
564
 
565
  if (inclDepth == 0)
566
    {
567
      static struct complaint msg =
568
      {"Mismatched C_BINCL/C_EINCL pair", 0, 0};
569
      complain (&msg);
570
    }
571
 
572
  allocate_include_entry ();
573
 
574
  pTbl = &inclTable[inclIndx];
575
  pTbl->end = cs->c_value;
576
 
577
  --inclDepth;
578
  ++inclIndx;
579
}
580
 
581
static void
582
allocate_include_entry ()
583
{
584
  if (inclTable == NULL)
585
    {
586
      inclTable = (InclTable *)
587
        xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
588
      memset (inclTable,
589
              '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
590
      inclLength = INITIAL_INCLUDE_TABLE_LENGTH;
591
      inclIndx = 0;
592
    }
593
  else if (inclIndx >= inclLength)
594
    {
595
      inclLength += INITIAL_INCLUDE_TABLE_LENGTH;
596
      inclTable = (InclTable *)
597
        xrealloc (inclTable, sizeof (InclTable) * inclLength);
598
      memset (inclTable + inclLength - INITIAL_INCLUDE_TABLE_LENGTH,
599
              '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
600
    }
601
}
602
 
603
/* Global variable to pass the psymtab down to all the routines involved
604
   in psymtab to symtab processing.  */
605
static struct partial_symtab *this_symtab_psymtab;
606
 
607
/* given the start and end addresses of a compilation unit (or a csect,
608
   at times) process its lines and create appropriate line vectors. */
609
 
610
static void
611
process_linenos (start, end)
612
     CORE_ADDR start, end;
613
{
614
  int offset, ii;
615
  file_ptr max_offset =
616
  ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
617
  ->max_lineno_offset;
618
 
619
  /* subfile structure for the main compilation unit.  */
620
  struct subfile main_subfile;
621
 
622
  /* In the main source file, any time we see a function entry, we
623
     reset this variable to function's absolute starting line number.
624
     All the following line numbers in the function are relative to
625
     this, and we record absolute line numbers in record_line().  */
626
 
627
  unsigned int main_source_baseline = 0;
628
 
629
  unsigned *firstLine;
630
 
631
  offset =
632
    ((struct symloc *) this_symtab_psymtab->read_symtab_private)->lineno_off;
633
  if (offset == 0)
634
    goto return_after_cleanup;
635
 
636
  memset (&main_subfile, '\0', sizeof (main_subfile));
637
 
638
  if (inclIndx == 0)
639
    /* All source lines were in the main source file. None in include files. */
640
 
641
    enter_line_range (&main_subfile, offset, 0, start, end,
642
                      &main_source_baseline);
643
 
644
  else
645
    {
646
      /* There was source with line numbers in include files.  */
647
      main_source_baseline = 0;
648
      for (ii = 0; ii < inclIndx; ++ii)
649
        {
650
          struct subfile *tmpSubfile;
651
 
652
          /* If there is main file source before include file, enter it.  */
653
          if (offset < inclTable[ii].begin)
654
            {
655
              enter_line_range
656
                (&main_subfile, offset, inclTable[ii].begin - LINESZ,
657
                 start, 0, &main_source_baseline);
658
            }
659
 
660
          /* Have a new subfile for the include file.  */
661
 
662
          tmpSubfile = inclTable[ii].subfile =
663
            (struct subfile *) xmalloc (sizeof (struct subfile));
664
 
665
          memset (tmpSubfile, '\0', sizeof (struct subfile));
666
          firstLine = &(inclTable[ii].funStartLine);
667
 
668
          /* Enter include file's lines now.  */
669
          enter_line_range (tmpSubfile, inclTable[ii].begin,
670
                            inclTable[ii].end, start, 0, firstLine);
671
 
672
          if (offset <= inclTable[ii].end)
673
            offset = inclTable[ii].end + LINESZ;
674
        }
675
 
676
      /* All the include files' line have been processed at this point.  Now,
677
         enter remaining lines of the main file, if any left.  */
678
      if (offset < max_offset + 1 - LINESZ)
679
        {
680
          enter_line_range (&main_subfile, offset, 0, start, end,
681
                            &main_source_baseline);
682
        }
683
    }
684
 
685
  /* Process main file's line numbers.  */
686
  if (main_subfile.line_vector)
687
    {
688
      struct linetable *lineTb, *lv;
689
 
690
      lv = main_subfile.line_vector;
691
 
692
      /* Line numbers are not necessarily ordered. xlc compilation will
693
         put static function to the end. */
694
 
695
      lineTb = arrange_linetable (lv);
696
      if (lv == lineTb)
697
        {
698
          current_subfile->line_vector = (struct linetable *)
699
            xrealloc (lv, (sizeof (struct linetable)
700
                           + lv->nitems * sizeof (struct linetable_entry)));
701
        }
702
      else
703
        {
704
          free (lv);
705
          current_subfile->line_vector = lineTb;
706
        }
707
 
708
      current_subfile->line_vector_length =
709
        current_subfile->line_vector->nitems;
710
    }
711
 
712
  /* Now, process included files' line numbers.  */
713
 
714
  for (ii = 0; ii < inclIndx; ++ii)
715
    {
716
      if ((inclTable[ii].subfile)->line_vector)         /* Useless if!!! FIXMEmgo */
717
        {
718
          struct linetable *lineTb, *lv;
719
 
720
          lv = (inclTable[ii].subfile)->line_vector;
721
 
722
          /* Line numbers are not necessarily ordered. xlc compilation will
723
             put static function to the end. */
724
 
725
          lineTb = arrange_linetable (lv);
726
 
727
          push_subfile ();
728
 
729
          /* For the same include file, we might want to have more than one
730
             subfile.  This happens if we have something like:
731
 
732
             ......
733
             #include "foo.h"
734
             ......
735
             #include "foo.h"
736
             ......
737
 
738
             while foo.h including code in it. (stupid but possible)
739
             Since start_subfile() looks at the name and uses an
740
             existing one if finds, we need to provide a fake name and
741
             fool it.  */
742
 
743
#if 0
744
          start_subfile (inclTable[ii].name, (char *) 0);
745
#else
746
          {
747
            /* Pick a fake name that will produce the same results as this
748
               one when passed to deduce_language_from_filename.  Kludge on
749
               top of kludge.  */
750
            char *fakename = strrchr (inclTable[ii].name, '.');
751
            if (fakename == NULL)
752
              fakename = " ?";
753
            start_subfile (fakename, (char *) 0);
754
            free (current_subfile->name);
755
          }
756
          current_subfile->name = xstrdup (inclTable[ii].name);
757
#endif
758
 
759
          if (lv == lineTb)
760
            {
761
              current_subfile->line_vector =
762
                (struct linetable *) xrealloc
763
                (lv, (sizeof (struct linetable)
764
                      + lv->nitems * sizeof (struct linetable_entry)));
765
 
766
            }
767
          else
768
            {
769
              free (lv);
770
              current_subfile->line_vector = lineTb;
771
            }
772
 
773
          current_subfile->line_vector_length =
774
            current_subfile->line_vector->nitems;
775
          start_subfile (pop_subfile (), (char *) 0);
776
        }
777
    }
778
 
779
return_after_cleanup:
780
 
781
  /* We don't want to keep alloc/free'ing the global include file table.  */
782
  inclIndx = 0;
783
 
784
  /* Start with a fresh subfile structure for the next file.  */
785
  memset (&main_subfile, '\0', sizeof (struct subfile));
786
}
787
 
788
void
789
aix_process_linenos ()
790
{
791
  /* process line numbers and enter them into line vector */
792
  process_linenos (last_source_start_addr, cur_src_end_addr);
793
}
794
 
795
 
796
/* Enter a given range of lines into the line vector.
797
   can be called in the following two ways:
798
   enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine)  or
799
   enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine)
800
 
801
   endoffset points to the last line table entry that we should pay
802
   attention to.  */
803
 
804
static void
805
enter_line_range (subfile, beginoffset, endoffset, startaddr, endaddr,
806
                  firstLine)
807
     struct subfile *subfile;
808
     unsigned beginoffset, endoffset;   /* offsets to line table */
809
     CORE_ADDR startaddr, endaddr;
810
     unsigned *firstLine;
811
{
812
  unsigned int curoffset;
813
  CORE_ADDR addr;
814
  struct external_lineno ext_lnno;
815
  struct internal_lineno int_lnno;
816
  unsigned int limit_offset;
817
  bfd *abfd;
818
 
819
  if (endoffset == 0 && startaddr == 0 && endaddr == 0)
820
    return;
821
  curoffset = beginoffset;
822
  limit_offset =
823
    ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
824
    ->max_lineno_offset;
825
 
826
  if (endoffset != 0)
827
    {
828
      if (endoffset >= limit_offset)
829
        {
830
          static struct complaint msg =
831
          {"Bad line table offset in C_EINCL directive", 0, 0};
832
          complain (&msg);
833
          return;
834
        }
835
      limit_offset = endoffset;
836
    }
837
  else
838
    limit_offset -= 1;
839
  abfd = this_symtab_psymtab->objfile->obfd;
840
 
841
  while (curoffset <= limit_offset)
842
    {
843
      bfd_seek (abfd, curoffset, SEEK_SET);
844
      bfd_read (&ext_lnno, sizeof (struct external_lineno), 1, abfd);
845
      bfd_coff_swap_lineno_in (abfd, &ext_lnno, &int_lnno);
846
 
847
      /* Find the address this line represents.  */
848
      addr = (int_lnno.l_lnno
849
              ? int_lnno.l_addr.l_paddr
850
              : read_symbol_nvalue (int_lnno.l_addr.l_symndx));
851
      addr += ANOFFSET (this_symtab_psymtab->objfile->section_offsets,
852
                        SECT_OFF_TEXT);
853
 
854
      if (addr < startaddr || (endaddr && addr >= endaddr))
855
        return;
856
 
857
      if (int_lnno.l_lnno == 0)
858
        {
859
          *firstLine = read_symbol_lineno (int_lnno.l_addr.l_symndx);
860
          record_line (subfile, 0, addr);
861
          --(*firstLine);
862
        }
863
      else
864
        record_line (subfile, *firstLine + int_lnno.l_lnno, addr);
865
      curoffset += LINESZ;
866
    }
867
}
868
 
869
 
870
/* Save the vital information for use when closing off the current file.
871
   NAME is the file name the symbols came from, START_ADDR is the first
872
   text address for the file, and SIZE is the number of bytes of text.  */
873
 
874
#define complete_symtab(name, start_addr) {     \
875
  last_source_file = savestring (name, strlen (name));  \
876
  last_source_start_addr = start_addr;                  \
877
}
878
 
879
 
880
/* Refill the symbol table input buffer
881
   and set the variables that control fetching entries from it.
882
   Reports an error if no data available.
883
   This function can read past the end of the symbol table
884
   (into the string table) but this does no harm.  */
885
 
886
/* Reading symbol table has to be fast! Keep the followings as macros, rather
887
   than functions. */
888
 
889
#define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, SECTION, OBJFILE) \
890
{                                               \
891
  char *namestr;                                \
892
  namestr = (NAME); \
893
  if (namestr[0] == '.') ++namestr; \
894
  prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \
895
                                       (char *)NULL, (SECTION), (asection *)NULL, (OBJFILE)); \
896
  misc_func_recorded = 1;                                       \
897
}
898
 
899
 
900
/* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
901
   nested. At any given time, a symbol can only be in one static block.
902
   This is the base address of current static block, zero if non exists. */
903
 
904
static int static_block_base = 0;
905
 
906
/* Section number for the current static block.  */
907
 
908
static int static_block_section = -1;
909
 
910
/* true if space for symbol name has been allocated. */
911
 
912
static int symname_alloced = 0;
913
 
914
/* Next symbol to read.  Pointer into raw seething symbol table.  */
915
 
916
static char *raw_symbol;
917
 
918
/* This is the function which stabsread.c calls to get symbol
919
   continuations.  */
920
 
921
static char *
922
xcoff_next_symbol_text (objfile)
923
     struct objfile *objfile;
924
{
925
  struct internal_syment symbol;
926
  static struct complaint msg =
927
  {"Unexpected symbol continuation", 0, 0};
928
  char *retval;
929
  /* FIXME: is this the same as the passed arg? */
930
  objfile = this_symtab_psymtab->objfile;
931
 
932
  bfd_coff_swap_sym_in (objfile->obfd, raw_symbol, &symbol);
933
  if (symbol.n_zeroes)
934
    {
935
      complain (&msg);
936
 
937
      /* Return something which points to '\0' and hope the symbol reading
938
         code does something reasonable.  */
939
      retval = "";
940
    }
941
  else if (symbol.n_sclass & 0x80)
942
    {
943
      retval =
944
        ((struct coff_symfile_info *) objfile->sym_private)->debugsec
945
        + symbol.n_offset;
946
      raw_symbol +=
947
        coff_data (objfile->obfd)->local_symesz;
948
      ++symnum;
949
    }
950
  else
951
    {
952
      complain (&msg);
953
 
954
      /* Return something which points to '\0' and hope the symbol reading
955
         code does something reasonable.  */
956
      retval = "";
957
    }
958
  return retval;
959
}
960
 
961
/* Read symbols for a given partial symbol table.  */
962
 
963
static void
964
read_xcoff_symtab (pst)
965
     struct partial_symtab *pst;
966
{
967
  struct objfile *objfile = pst->objfile;
968
  bfd *abfd = objfile->obfd;
969
  char *raw_auxptr;             /* Pointer to first raw aux entry for sym */
970
  char *strtbl = ((struct coff_symfile_info *) objfile->sym_private)->strtbl;
971
  char *debugsec =
972
  ((struct coff_symfile_info *) objfile->sym_private)->debugsec;
973
 
974
  struct internal_syment symbol[1];
975
  union internal_auxent main_aux;
976
  struct coff_symbol cs[1];
977
  CORE_ADDR file_start_addr = 0;
978
  CORE_ADDR file_end_addr = 0;
979
 
980
  int next_file_symnum = -1;
981
  unsigned int max_symnum;
982
  int just_started = 1;
983
  int depth = 0;
984
  int fcn_start_addr = 0;
985
 
986
  struct coff_symbol fcn_stab_saved;
987
 
988
  /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
989
  union internal_auxent fcn_aux_saved;
990
  struct context_stack *new;
991
 
992
  char *filestring = " _start_ ";       /* Name of the current file. */
993
 
994
  char *last_csect_name;        /* last seen csect's name and value */
995
  CORE_ADDR last_csect_val;
996
  int last_csect_sec;
997
 
998
  this_symtab_psymtab = pst;
999
 
1000
  /* Get the appropriate COFF "constants" related to the file we're
1001
     handling. */
1002
  local_symesz = coff_data (abfd)->local_symesz;
1003
 
1004
  last_source_file = NULL;
1005
  last_csect_name = 0;
1006
  last_csect_val = 0;
1007
 
1008
  start_stabs ();
1009
  start_symtab (filestring, (char *) NULL, file_start_addr);
1010
  record_debugformat ("XCOFF");
1011
  symnum = ((struct symloc *) pst->read_symtab_private)->first_symnum;
1012
  max_symnum =
1013
    symnum + ((struct symloc *) pst->read_symtab_private)->numsyms;
1014
  first_object_file_end = 0;
1015
 
1016
  raw_symbol =
1017
    ((struct coff_symfile_info *) objfile->sym_private)->symtbl
1018
    + symnum * local_symesz;
1019
 
1020
  while (symnum < max_symnum)
1021
    {
1022
 
1023
      QUIT;                     /* make this command interruptable.  */
1024
 
1025
      /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
1026
      /* read one symbol into `cs' structure. After processing the
1027
         whole symbol table, only string table will be kept in memory,
1028
         symbol table and debug section of xcoff will be freed. Thus
1029
         we can mark symbols with names in string table as
1030
         `alloced'. */
1031
      {
1032
        int ii;
1033
 
1034
        /* Swap and align the symbol into a reasonable C structure.  */
1035
        bfd_coff_swap_sym_in (abfd, raw_symbol, symbol);
1036
 
1037
        cs->c_symnum = symnum;
1038
        cs->c_naux = symbol->n_numaux;
1039
        if (symbol->n_zeroes)
1040
          {
1041
            symname_alloced = 0;
1042
            /* We must use the original, unswapped, name here so the name field
1043
               pointed to by cs->c_name will persist throughout xcoffread.  If
1044
               we use the new field, it gets overwritten for each symbol.  */
1045
            cs->c_name = ((struct external_syment *) raw_symbol)->e.e_name;
1046
            /* If it's exactly E_SYMNMLEN characters long it isn't
1047
               '\0'-terminated.  */
1048
            if (cs->c_name[E_SYMNMLEN - 1] != '\0')
1049
              {
1050
                char *p;
1051
                p = obstack_alloc (&objfile->symbol_obstack, E_SYMNMLEN + 1);
1052
                strncpy (p, cs->c_name, E_SYMNMLEN);
1053
                p[E_SYMNMLEN] = '\0';
1054
                cs->c_name = p;
1055
                symname_alloced = 1;
1056
              }
1057
          }
1058
        else if (symbol->n_sclass & 0x80)
1059
          {
1060
            cs->c_name = debugsec + symbol->n_offset;
1061
            symname_alloced = 0;
1062
          }
1063
        else
1064
          {
1065
            /* in string table */
1066
            cs->c_name = strtbl + (int) symbol->n_offset;
1067
            symname_alloced = 1;
1068
          }
1069
        cs->c_value = symbol->n_value;
1070
        cs->c_sclass = symbol->n_sclass;
1071
        cs->c_secnum = symbol->n_scnum;
1072
        cs->c_type = (unsigned) symbol->n_type;
1073
 
1074
        raw_symbol += coff_data (abfd)->local_symesz;
1075
        ++symnum;
1076
 
1077
        /* Save addr of first aux entry.  */
1078
        raw_auxptr = raw_symbol;
1079
 
1080
        /* Skip all the auxents associated with this symbol.  */
1081
        for (ii = symbol->n_numaux; ii; --ii)
1082
          {
1083
            raw_symbol += coff_data (abfd)->local_auxesz;
1084
            ++symnum;
1085
          }
1086
      }
1087
 
1088
      /* if symbol name starts with ".$" or "$", ignore it. */
1089
      if (cs->c_name[0] == '$'
1090
          || (cs->c_name[1] == '$' && cs->c_name[0] == '.'))
1091
        continue;
1092
 
1093
      if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
1094
        {
1095
          if (last_source_file)
1096
            {
1097
              pst->symtab =
1098
                end_symtab (cur_src_end_addr, objfile, SECT_OFF_TEXT);
1099
              end_stabs ();
1100
            }
1101
 
1102
          start_stabs ();
1103
          start_symtab ("_globals_", (char *) NULL, (CORE_ADDR) 0);
1104
          record_debugformat ("XCOFF");
1105
          cur_src_end_addr = first_object_file_end;
1106
          /* done with all files, everything from here on is globals */
1107
        }
1108
 
1109
      /* if explicitly specified as a function, treat is as one. */
1110
      if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
1111
        {
1112
          bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1113
                                0, cs->c_naux, &main_aux);
1114
          goto function_entry_point;
1115
        }
1116
 
1117
      if ((cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT)
1118
          && cs->c_naux == 1)
1119
        {
1120
          /* Dealing with a symbol with a csect entry.  */
1121
 
1122
#define CSECT(PP) ((PP)->x_csect)
1123
#define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
1124
#define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1125
#define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1126
#define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1127
 
1128
          /* Convert the auxent to something we can access.  */
1129
          bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1130
                                0, cs->c_naux, &main_aux);
1131
 
1132
          switch (CSECT_SMTYP (&main_aux))
1133
            {
1134
 
1135
            case XTY_ER:
1136
              /* Ignore all external references.  */
1137
              continue;
1138
 
1139
            case XTY_SD:
1140
              /* A section description.  */
1141
              {
1142
                switch (CSECT_SCLAS (&main_aux))
1143
                  {
1144
 
1145
                  case XMC_PR:
1146
                    {
1147
 
1148
                      /* A program csect is seen.  We have to allocate one
1149
                         symbol table for each program csect.  Normally gdb
1150
                         prefers one symtab for each source file.  In case
1151
                         of AIX, one source file might include more than one
1152
                         [PR] csect, and they don't have to be adjacent in
1153
                         terms of the space they occupy in memory. Thus, one
1154
                         single source file might get fragmented in the
1155
                         memory and gdb's file start and end address
1156
                         approach does not work!  GCC (and I think xlc) seem
1157
                         to put all the code in the unnamed program csect.  */
1158
 
1159
                      if (last_csect_name)
1160
                        {
1161
                          complete_symtab (filestring, file_start_addr);
1162
                          cur_src_end_addr = file_end_addr;
1163
                          end_symtab (file_end_addr, objfile, SECT_OFF_TEXT);
1164
                          end_stabs ();
1165
                          start_stabs ();
1166
                          /* Give all csects for this source file the same
1167
                             name.  */
1168
                          start_symtab (filestring, NULL, (CORE_ADDR) 0);
1169
                          record_debugformat ("XCOFF");
1170
                        }
1171
 
1172
                      /* If this is the very first csect seen,
1173
                         basically `__start'. */
1174
                      if (just_started)
1175
                        {
1176
                          first_object_file_end
1177
                            = cs->c_value + CSECT_LEN (&main_aux);
1178
                          just_started = 0;
1179
                        }
1180
 
1181
                      file_start_addr =
1182
                        cs->c_value + ANOFFSET (objfile->section_offsets,
1183
                                                SECT_OFF_TEXT);
1184
                      file_end_addr = file_start_addr + CSECT_LEN (&main_aux);
1185
 
1186
                      if (cs->c_name && cs->c_name[0] == '.')
1187
                        {
1188
                          last_csect_name = cs->c_name;
1189
                          last_csect_val = cs->c_value;
1190
                          last_csect_sec = secnum_to_section (cs->c_secnum, objfile);
1191
                        }
1192
                    }
1193
                    continue;
1194
 
1195
                    /* All other symbols are put into the minimal symbol
1196
                       table only.  */
1197
 
1198
                  case XMC_RW:
1199
                    continue;
1200
 
1201
                  case XMC_TC0:
1202
                    continue;
1203
 
1204
                  case XMC_TC:
1205
                    continue;
1206
 
1207
                  default:
1208
                    /* Ignore the symbol.  */
1209
                    continue;
1210
                  }
1211
              }
1212
              break;
1213
 
1214
            case XTY_LD:
1215
 
1216
              switch (CSECT_SCLAS (&main_aux))
1217
                {
1218
                case XMC_PR:
1219
                  /* a function entry point. */
1220
                function_entry_point:
1221
 
1222
                  fcn_start_addr = cs->c_value;
1223
 
1224
                  /* save the function header info, which will be used
1225
                     when `.bf' is seen. */
1226
                  fcn_cs_saved = *cs;
1227
                  fcn_aux_saved = main_aux;
1228
                  continue;
1229
 
1230
                case XMC_GL:
1231
                  /* shared library function trampoline code entry point. */
1232
                  continue;
1233
 
1234
                case XMC_DS:
1235
                  /* The symbols often have the same names as debug symbols for
1236
                     functions, and confuse lookup_symbol.  */
1237
                  continue;
1238
 
1239
                default:
1240
                  /* xlc puts each variable in a separate csect, so we get
1241
                     an XTY_SD for each variable.  But gcc puts several
1242
                     variables in a csect, so that each variable only gets
1243
                     an XTY_LD. This will typically be XMC_RW; I suspect
1244
                     XMC_RO and XMC_BS might be possible too.
1245
                     These variables are put in the minimal symbol table
1246
                     only.  */
1247
                  continue;
1248
                }
1249
              break;
1250
 
1251
            case XTY_CM:
1252
              /* Common symbols are put into the minimal symbol table only.  */
1253
              continue;
1254
 
1255
            default:
1256
              break;
1257
            }
1258
        }
1259
 
1260
      switch (cs->c_sclass)
1261
        {
1262
 
1263
        case C_FILE:
1264
 
1265
          /* c_value field contains symnum of next .file entry in table
1266
             or symnum of first global after last .file. */
1267
 
1268
          next_file_symnum = cs->c_value;
1269
 
1270
          /* Complete symbol table for last object file containing
1271
             debugging information. */
1272
 
1273
          /* Whether or not there was a csect in the previous file, we
1274
             have to call `end_stabs' and `start_stabs' to reset
1275
             type_vector, line_vector, etc. structures.  */
1276
 
1277
          complete_symtab (filestring, file_start_addr);
1278
          cur_src_end_addr = file_end_addr;
1279
          end_symtab (file_end_addr, objfile, SECT_OFF_TEXT);
1280
          end_stabs ();
1281
 
1282
          /* XCOFF, according to the AIX 3.2 documentation, puts the filename
1283
             in cs->c_name.  But xlc 1.3.0.2 has decided to do things the
1284
             standard COFF way and put it in the auxent.  We use the auxent if
1285
             the symbol is ".file" and an auxent exists, otherwise use the symbol
1286
             itself.  Simple enough.  */
1287
          if (!strcmp (cs->c_name, ".file") && cs->c_naux > 0)
1288
            {
1289
              bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1290
                                    0, cs->c_naux, &main_aux);
1291
              filestring = coff_getfilename (&main_aux, objfile);
1292
            }
1293
          else
1294
            filestring = cs->c_name;
1295
 
1296
          start_stabs ();
1297
          start_symtab (filestring, (char *) NULL, (CORE_ADDR) 0);
1298
          record_debugformat ("XCOFF");
1299
          last_csect_name = 0;
1300
 
1301
          /* reset file start and end addresses. A compilation unit with no text
1302
             (only data) should have zero file boundaries. */
1303
          file_start_addr = file_end_addr = 0;
1304
          break;
1305
 
1306
        case C_FUN:
1307
          fcn_stab_saved = *cs;
1308
          break;
1309
 
1310
        case C_FCN:
1311
          if (STREQ (cs->c_name, ".bf"))
1312
            {
1313
              CORE_ADDR off = ANOFFSET (objfile->section_offsets,
1314
                                        SECT_OFF_TEXT);
1315
              bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1316
                                    0, cs->c_naux, &main_aux);
1317
 
1318
              within_function = 1;
1319
 
1320
              new = push_context (0, fcn_start_addr + off);
1321
 
1322
              new->name = define_symbol
1323
                (fcn_cs_saved.c_value + off,
1324
                 fcn_stab_saved.c_name, 0, 0, objfile);
1325
              if (new->name != NULL)
1326
                SYMBOL_SECTION (new->name) = SECT_OFF_TEXT;
1327
            }
1328
          else if (STREQ (cs->c_name, ".ef"))
1329
            {
1330
 
1331
              bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1332
                                    0, cs->c_naux, &main_aux);
1333
 
1334
              /* The value of .ef is the address of epilogue code;
1335
                 not useful for gdb.  */
1336
              /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1337
                 contains number of lines to '}' */
1338
 
1339
              if (context_stack_depth <= 0)
1340
                {               /* We attempted to pop an empty context stack */
1341
                  complain (&ef_complaint, cs->c_symnum);
1342
                  within_function = 0;
1343
                  break;
1344
                }
1345
              new = pop_context ();
1346
              /* Stack must be empty now.  */
1347
              if (context_stack_depth > 0 || new == NULL)
1348
                {
1349
                  complain (&ef_complaint, cs->c_symnum);
1350
                  within_function = 0;
1351
                  break;
1352
                }
1353
 
1354
              finish_block (new->name, &local_symbols, new->old_blocks,
1355
                            new->start_addr,
1356
                            (fcn_cs_saved.c_value
1357
                             + fcn_aux_saved.x_sym.x_misc.x_fsize
1358
                             + ANOFFSET (objfile->section_offsets,
1359
                                         SECT_OFF_TEXT)),
1360
                            objfile);
1361
              within_function = 0;
1362
            }
1363
          break;
1364
 
1365
        case C_BSTAT:
1366
          /* Begin static block.  */
1367
          {
1368
            struct internal_syment symbol;
1369
 
1370
            read_symbol (&symbol, cs->c_value);
1371
            static_block_base = symbol.n_value;
1372
            static_block_section =
1373
              secnum_to_section (symbol.n_scnum, objfile);
1374
          }
1375
          break;
1376
 
1377
        case C_ESTAT:
1378
          /* End of static block.  */
1379
          static_block_base = 0;
1380
          static_block_section = -1;
1381
          break;
1382
 
1383
        case C_ARG:
1384
        case C_REGPARM:
1385
        case C_REG:
1386
        case C_TPDEF:
1387
        case C_STRTAG:
1388
        case C_UNTAG:
1389
        case C_ENTAG:
1390
          {
1391
            static struct complaint msg =
1392
            {"Unrecognized storage class %d.", 0, 0};
1393
            complain (&msg, cs->c_sclass);
1394
          }
1395
          break;
1396
 
1397
        case C_LABEL:
1398
        case C_NULL:
1399
          /* Ignore these.  */
1400
          break;
1401
 
1402
        case C_HIDEXT:
1403
        case C_STAT:
1404
          break;
1405
 
1406
        case C_BINCL:
1407
          /* beginning of include file */
1408
          /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1409
             order. Thus, when wee see them, we might not know enough info
1410
             to process them. Thus, we'll be saving them into a table
1411
             (inclTable) and postpone their processing. */
1412
 
1413
          record_include_begin (cs);
1414
          break;
1415
 
1416
        case C_EINCL:
1417
          /* End of include file.  */
1418
          /* See the comment after case C_BINCL.  */
1419
          record_include_end (cs);
1420
          break;
1421
 
1422
        case C_BLOCK:
1423
          if (STREQ (cs->c_name, ".bb"))
1424
            {
1425
              depth++;
1426
              new = push_context (depth,
1427
                                  (cs->c_value
1428
                                   + ANOFFSET (objfile->section_offsets,
1429
                                               SECT_OFF_TEXT)));
1430
            }
1431
          else if (STREQ (cs->c_name, ".eb"))
1432
            {
1433
              if (context_stack_depth <= 0)
1434
                {               /* We attempted to pop an empty context stack */
1435
                  complain (&eb_complaint, cs->c_symnum);
1436
                  break;
1437
                }
1438
              new = pop_context ();
1439
              if (depth-- != new->depth)
1440
                {
1441
                  complain (&eb_complaint, cs->c_symnum);
1442
                  break;
1443
                }
1444
              if (local_symbols && context_stack_depth > 0)
1445
                {
1446
                  /* Make a block for the local symbols within.  */
1447
                  finish_block (new->name, &local_symbols, new->old_blocks,
1448
                                new->start_addr,
1449
                                (cs->c_value
1450
                                 + ANOFFSET (objfile->section_offsets,
1451
                                             SECT_OFF_TEXT)),
1452
                                objfile);
1453
                }
1454
              local_symbols = new->locals;
1455
            }
1456
          break;
1457
 
1458
        default:
1459
          process_xcoff_symbol (cs, objfile);
1460
          break;
1461
        }
1462
    }
1463
 
1464
  if (last_source_file)
1465
    {
1466
      struct symtab *s;
1467
 
1468
      complete_symtab (filestring, file_start_addr);
1469
      cur_src_end_addr = file_end_addr;
1470
      s = end_symtab (file_end_addr, objfile, SECT_OFF_TEXT);
1471
      /* When reading symbols for the last C_FILE of the objfile, try
1472
         to make sure that we set pst->symtab to the symtab for the
1473
         file, not to the _globals_ symtab.  I'm not sure whether this
1474
         actually works right or when/if it comes up.  */
1475
      if (pst->symtab == NULL)
1476
        pst->symtab = s;
1477
      end_stabs ();
1478
    }
1479
}
1480
 
1481
#define SYMBOL_DUP(SYMBOL1, SYMBOL2)    \
1482
  (SYMBOL2) = (struct symbol *)         \
1483
        obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1484
  *(SYMBOL2) = *(SYMBOL1);
1485
 
1486
 
1487
#define SYMNAME_ALLOC(NAME, ALLOCED)    \
1488
  (ALLOCED) ? (NAME) : obsavestring ((NAME), strlen (NAME), &objfile->symbol_obstack);
1489
 
1490
 
1491
static struct type *func_symbol_type;
1492
static struct type *var_symbol_type;
1493
 
1494
/* process one xcoff symbol. */
1495
 
1496
static struct symbol *
1497
process_xcoff_symbol (cs, objfile)
1498
     register struct coff_symbol *cs;
1499
     struct objfile *objfile;
1500
{
1501
  struct symbol onesymbol;
1502
  register struct symbol *sym = &onesymbol;
1503
  struct symbol *sym2 = NULL;
1504
  char *name, *pp;
1505
 
1506
  int sec;
1507
  CORE_ADDR off;
1508
 
1509
  if (cs->c_secnum < 0)
1510
    {
1511
      /* The value is a register number, offset within a frame, etc.,
1512
         and does not get relocated.  */
1513
      off = 0;
1514
      sec = -1;
1515
    }
1516
  else
1517
    {
1518
      sec = secnum_to_section (cs->c_secnum, objfile);
1519
      off = ANOFFSET (objfile->section_offsets, sec);
1520
    }
1521
 
1522
  name = cs->c_name;
1523
  if (name[0] == '.')
1524
    ++name;
1525
 
1526
  memset (sym, '\0', sizeof (struct symbol));
1527
 
1528
  /* default assumptions */
1529
  SYMBOL_VALUE (sym) = cs->c_value + off;
1530
  SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1531
  SYMBOL_SECTION (sym) = secnum_to_section (cs->c_secnum, objfile);
1532
 
1533
  if (ISFCN (cs->c_type))
1534
    {
1535
      /* At this point, we don't know the type of the function.  This
1536
         will be patched with the type from its stab entry later on in
1537
         patch_block_stabs (), unless the file was compiled without -g.  */
1538
 
1539
      SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
1540
      SYMBOL_TYPE (sym) = func_symbol_type;
1541
 
1542
      SYMBOL_CLASS (sym) = LOC_BLOCK;
1543
      SYMBOL_DUP (sym, sym2);
1544
 
1545
      if (cs->c_sclass == C_EXT)
1546
        add_symbol_to_list (sym2, &global_symbols);
1547
      else if (cs->c_sclass == C_HIDEXT || cs->c_sclass == C_STAT)
1548
        add_symbol_to_list (sym2, &file_symbols);
1549
    }
1550
  else
1551
    {
1552
      /* In case we can't figure out the type, provide default. */
1553
      SYMBOL_TYPE (sym) = var_symbol_type;
1554
 
1555
      switch (cs->c_sclass)
1556
        {
1557
#if 0
1558
          /* The values of functions and global symbols are now resolved
1559
             via the global_sym_chain in stabsread.c.  */
1560
        case C_FUN:
1561
          if (fcn_cs_saved.c_sclass == C_EXT)
1562
            add_stab_to_list (name, &global_stabs);
1563
          else
1564
            add_stab_to_list (name, &file_stabs);
1565
          break;
1566
 
1567
        case C_GSYM:
1568
          add_stab_to_list (name, &global_stabs);
1569
          break;
1570
#endif
1571
 
1572
        case C_BCOMM:
1573
          common_block_start (cs->c_name, objfile);
1574
          break;
1575
 
1576
        case C_ECOMM:
1577
          common_block_end (objfile);
1578
          break;
1579
 
1580
        default:
1581
          complain (&storclass_complaint, cs->c_sclass);
1582
          /* FALLTHROUGH */
1583
 
1584
        case C_DECL:
1585
        case C_PSYM:
1586
        case C_RPSYM:
1587
        case C_ECOML:
1588
        case C_LSYM:
1589
        case C_RSYM:
1590
        case C_GSYM:
1591
 
1592
          {
1593
            sym = define_symbol (cs->c_value + off, cs->c_name, 0, 0, objfile);
1594
            if (sym != NULL)
1595
              {
1596
                SYMBOL_SECTION (sym) = sec;
1597
              }
1598
            return sym;
1599
          }
1600
 
1601
        case C_STSYM:
1602
 
1603
          /* For xlc (not GCC), the 'V' symbol descriptor is used for
1604
             all statics and we need to distinguish file-scope versus
1605
             function-scope using within_function.  We do this by
1606
             changing the string we pass to define_symbol to use 'S'
1607
             where we need to, which is not necessarily super-clean,
1608
             but seems workable enough.  */
1609
 
1610
          if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL)
1611
            return NULL;
1612
 
1613
          ++pp;
1614
          if (*pp == 'V' && !within_function)
1615
            *pp = 'S';
1616
          sym = define_symbol ((cs->c_value
1617
                                + ANOFFSET (objfile->section_offsets,
1618
                                            static_block_section)),
1619
                               cs->c_name, 0, 0, objfile);
1620
          if (sym != NULL)
1621
            {
1622
              SYMBOL_VALUE (sym) += static_block_base;
1623
              SYMBOL_SECTION (sym) = static_block_section;
1624
            }
1625
          return sym;
1626
 
1627
        }
1628
    }
1629
  return sym2;
1630
}
1631
 
1632
/* Extract the file name from the aux entry of a C_FILE symbol.
1633
   Result is in static storage and is only good for temporary use.  */
1634
 
1635
static char *
1636
coff_getfilename (aux_entry, objfile)
1637
     union internal_auxent *aux_entry;
1638
     struct objfile *objfile;
1639
{
1640
  static char buffer[BUFSIZ];
1641
 
1642
  if (aux_entry->x_file.x_n.x_zeroes == 0)
1643
    strcpy (buffer,
1644
            ((struct coff_symfile_info *) objfile->sym_private)->strtbl
1645
            + aux_entry->x_file.x_n.x_offset);
1646
  else
1647
    {
1648
      strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
1649
      buffer[FILNMLEN] = '\0';
1650
    }
1651
  return (buffer);
1652
}
1653
 
1654
/* Set *SYMBOL to symbol number symno in symtbl.  */
1655
static void
1656
read_symbol (symbol, symno)
1657
     struct internal_syment *symbol;
1658
     int symno;
1659
{
1660
  int nsyms =
1661
  ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
1662
  ->symtbl_num_syms;
1663
  char *stbl =
1664
  ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
1665
  ->symtbl;
1666
  if (symno < 0 || symno >= nsyms)
1667
    {
1668
      static struct complaint msg =
1669
      {"Invalid symbol offset", 0, 0};
1670
      complain (&msg);
1671
      symbol->n_value = 0;
1672
      symbol->n_scnum = -1;
1673
      return;
1674
    }
1675
  bfd_coff_swap_sym_in (this_symtab_psymtab->objfile->obfd,
1676
                        stbl + (symno * local_symesz),
1677
                        symbol);
1678
}
1679
 
1680
/* Get value corresponding to symbol number symno in symtbl.  */
1681
 
1682
static int
1683
read_symbol_nvalue (symno)
1684
     int symno;
1685
{
1686
  struct internal_syment symbol[1];
1687
 
1688
  read_symbol (symbol, symno);
1689
  return symbol->n_value;
1690
}
1691
 
1692
 
1693
/* Find the address of the function corresponding to symno, where
1694
   symno is the symbol pointed to by the linetable.  */
1695
 
1696
static int
1697
read_symbol_lineno (symno)
1698
     int symno;
1699
{
1700
  int nsyms =
1701
  ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
1702
  ->symtbl_num_syms;
1703
  char *stbl =
1704
  ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
1705
  ->symtbl;
1706
  struct internal_syment symbol[1];
1707
  union internal_auxent main_aux[1];
1708
 
1709
  if (symno < 0)
1710
    {
1711
      complain (&bf_notfound_complaint);
1712
      return 0;
1713
    }
1714
 
1715
  /* Note that just searching for a short distance (e.g. 50 symbols)
1716
     is not enough, at least in the following case.
1717
 
1718
     .extern foo
1719
     [many .stabx entries]
1720
     [a few functions, referring to foo]
1721
     .globl foo
1722
     .bf
1723
 
1724
     What happens here is that the assembler moves the .stabx entries
1725
     to right before the ".bf" for foo, but the symbol for "foo" is before
1726
     all the stabx entries.  See PR gdb/2222.  */
1727
 
1728
  /* Maintaining a table of .bf entries might be preferable to this search.
1729
     If I understand things correctly it would need to be done only for
1730
     the duration of a single psymtab to symtab conversion.  */
1731
  while (symno < nsyms)
1732
    {
1733
      bfd_coff_swap_sym_in (symfile_bfd,
1734
                            stbl + (symno * local_symesz), symbol);
1735
      if (symbol->n_sclass == C_FCN && STREQ (symbol->n_name, ".bf"))
1736
        goto gotit;
1737
      symno += symbol->n_numaux + 1;
1738
    }
1739
 
1740
  complain (&bf_notfound_complaint);
1741
  return 0;
1742
 
1743
gotit:
1744
  /* take aux entry and return its lineno */
1745
  symno++;
1746
  bfd_coff_swap_aux_in (this_symtab_psymtab->objfile->obfd,
1747
                        stbl + symno * local_symesz,
1748
                        symbol->n_type, symbol->n_sclass,
1749
                        0, symbol->n_numaux, main_aux);
1750
 
1751
  return main_aux->x_sym.x_misc.x_lnsz.x_lnno;
1752
}
1753
 
1754
/* Support for line number handling */
1755
 
1756
/* This function is called for every section; it finds the outer limits
1757
 * of the line table (minimum and maximum file offset) so that the
1758
 * mainline code can read the whole thing for efficiency.
1759
 */
1760
static void
1761
find_linenos (abfd, asect, vpinfo)
1762
     bfd *abfd;
1763
     sec_ptr asect;
1764
     PTR vpinfo;
1765
{
1766
  struct coff_symfile_info *info;
1767
  int size, count;
1768
  file_ptr offset, maxoff;
1769
 
1770
  count = asect->lineno_count;
1771
 
1772
  if (!STREQ (asect->name, ".text") || count == 0)
1773
    return;
1774
 
1775
  size = count * coff_data (abfd)->local_linesz;
1776
  info = (struct coff_symfile_info *) vpinfo;
1777
  offset = asect->line_filepos;
1778
  maxoff = offset + size;
1779
 
1780
  if (offset < info->min_lineno_offset || info->min_lineno_offset == 0)
1781
    info->min_lineno_offset = offset;
1782
 
1783
  if (maxoff > info->max_lineno_offset)
1784
    info->max_lineno_offset = maxoff;
1785
}
1786
 
1787
static void xcoff_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
1788
 
1789
static void
1790
xcoff_psymtab_to_symtab_1 (pst)
1791
     struct partial_symtab *pst;
1792
{
1793
  struct cleanup *old_chain;
1794
  int i;
1795
 
1796
  if (!pst)
1797
    return;
1798
 
1799
  if (pst->readin)
1800
    {
1801
      fprintf_unfiltered
1802
        (gdb_stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
1803
         pst->filename);
1804
      return;
1805
    }
1806
 
1807
  /* Read in all partial symtabs on which this one is dependent */
1808
  for (i = 0; i < pst->number_of_dependencies; i++)
1809
    if (!pst->dependencies[i]->readin)
1810
      {
1811
        /* Inform about additional files that need to be read in.  */
1812
        if (info_verbose)
1813
          {
1814
            fputs_filtered (" ", gdb_stdout);
1815
            wrap_here ("");
1816
            fputs_filtered ("and ", gdb_stdout);
1817
            wrap_here ("");
1818
            printf_filtered ("%s...", pst->dependencies[i]->filename);
1819
            wrap_here ("");     /* Flush output */
1820
            gdb_flush (gdb_stdout);
1821
          }
1822
        xcoff_psymtab_to_symtab_1 (pst->dependencies[i]);
1823
      }
1824
 
1825
  if (((struct symloc *) pst->read_symtab_private)->numsyms != 0)
1826
    {
1827
      /* Init stuff necessary for reading in symbols.  */
1828
      stabsread_init ();
1829
      buildsym_init ();
1830
      old_chain = make_cleanup (really_free_pendings, 0);
1831
 
1832
      read_xcoff_symtab (pst);
1833
      sort_symtab_syms (pst->symtab);
1834
 
1835
      do_cleanups (old_chain);
1836
    }
1837
 
1838
  pst->readin = 1;
1839
}
1840
 
1841
static void xcoff_psymtab_to_symtab PARAMS ((struct partial_symtab *));
1842
 
1843
/* Read in all of the symbols for a given psymtab for real.
1844
   Be verbose about it if the user wants that.  */
1845
 
1846
static void
1847
xcoff_psymtab_to_symtab (pst)
1848
     struct partial_symtab *pst;
1849
{
1850
  bfd *sym_bfd;
1851
 
1852
  if (!pst)
1853
    return;
1854
 
1855
  if (pst->readin)
1856
    {
1857
      fprintf_unfiltered
1858
        (gdb_stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
1859
         pst->filename);
1860
      return;
1861
    }
1862
 
1863
  if (((struct symloc *) pst->read_symtab_private)->numsyms != 0
1864
      || pst->number_of_dependencies)
1865
    {
1866
      /* Print the message now, before reading the string table,
1867
         to avoid disconcerting pauses.  */
1868
      if (info_verbose)
1869
        {
1870
          printf_filtered ("Reading in symbols for %s...", pst->filename);
1871
          gdb_flush (gdb_stdout);
1872
        }
1873
 
1874
      sym_bfd = pst->objfile->obfd;
1875
 
1876
      next_symbol_text_func = xcoff_next_symbol_text;
1877
 
1878
      xcoff_psymtab_to_symtab_1 (pst);
1879
 
1880
      /* Match with global symbols.  This only needs to be done once,
1881
         after all of the symtabs and dependencies have been read in.   */
1882
      scan_file_globals (pst->objfile);
1883
 
1884
      /* Finish up the debug error message.  */
1885
      if (info_verbose)
1886
        printf_filtered ("done.\n");
1887
    }
1888
}
1889
 
1890
static void
1891
xcoff_new_init (objfile)
1892
     struct objfile *objfile;
1893
{
1894
  stabsread_new_init ();
1895
  buildsym_new_init ();
1896
}
1897
 
1898
/* Do initialization in preparation for reading symbols from OBJFILE.
1899
 
1900
   We will only be called if this is an XCOFF or XCOFF-like file.
1901
   BFD handles figuring out the format of the file, and code in symfile.c
1902
   uses BFD's determination to vector to us.  */
1903
 
1904
static void
1905
xcoff_symfile_init (objfile)
1906
     struct objfile *objfile;
1907
{
1908
  /* Allocate struct to keep track of the symfile */
1909
  objfile->sym_private = xmmalloc (objfile->md,
1910
                                   sizeof (struct coff_symfile_info));
1911
 
1912
  /* XCOFF objects may be reordered, so set OBJF_REORDERED.  If we
1913
     find this causes a significant slowdown in gdb then we could
1914
     set it in the debug symbol readers only when necessary.  */
1915
  objfile->flags |= OBJF_REORDERED;
1916
 
1917
  init_entry_point_info (objfile);
1918
}
1919
 
1920
/* Perform any local cleanups required when we are done with a particular
1921
   objfile.  I.E, we are in the process of discarding all symbol information
1922
   for an objfile, freeing up all memory held for it, and unlinking the
1923
   objfile struct from the global list of known objfiles. */
1924
 
1925
static void
1926
xcoff_symfile_finish (objfile)
1927
     struct objfile *objfile;
1928
{
1929
  if (objfile->sym_private != NULL)
1930
    {
1931
      mfree (objfile->md, objfile->sym_private);
1932
    }
1933
 
1934
  /* Start with a fresh include table for the next objfile.  */
1935
  if (inclTable)
1936
    {
1937
      free (inclTable);
1938
      inclTable = NULL;
1939
    }
1940
  inclIndx = inclLength = inclDepth = 0;
1941
}
1942
 
1943
 
1944
static void
1945
init_stringtab (abfd, offset, objfile)
1946
     bfd *abfd;
1947
     file_ptr offset;
1948
     struct objfile *objfile;
1949
{
1950
  long length;
1951
  int val;
1952
  unsigned char lengthbuf[4];
1953
  char *strtbl;
1954
 
1955
  ((struct coff_symfile_info *) objfile->sym_private)->strtbl = NULL;
1956
 
1957
  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
1958
    error ("cannot seek to string table in %s: %s",
1959
           bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
1960
 
1961
  val = bfd_read ((char *) lengthbuf, 1, sizeof lengthbuf, abfd);
1962
  length = bfd_h_get_32 (abfd, lengthbuf);
1963
 
1964
  /* If no string table is needed, then the file may end immediately
1965
     after the symbols.  Just return with `strtbl' set to NULL.  */
1966
 
1967
  if (val != sizeof lengthbuf || length < sizeof lengthbuf)
1968
    return;
1969
 
1970
  /* Allocate string table from symbol_obstack. We will need this table
1971
     as long as we have its symbol table around. */
1972
 
1973
  strtbl = (char *) obstack_alloc (&objfile->symbol_obstack, length);
1974
  ((struct coff_symfile_info *) objfile->sym_private)->strtbl = strtbl;
1975
 
1976
  /* Copy length buffer, the first byte is usually zero and is
1977
     used for stabs with a name length of zero.  */
1978
  memcpy (strtbl, lengthbuf, sizeof lengthbuf);
1979
  if (length == sizeof lengthbuf)
1980
    return;
1981
 
1982
  val = bfd_read (strtbl + sizeof lengthbuf, 1, length - sizeof lengthbuf,
1983
                  abfd);
1984
 
1985
  if (val != length - sizeof lengthbuf)
1986
    error ("cannot read string table from %s: %s",
1987
           bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
1988
  if (strtbl[length - 1] != '\0')
1989
    error ("bad symbol file: string table does not end with null character");
1990
 
1991
  return;
1992
}
1993
 
1994
/* If we have not yet seen a function for this psymtab, this is 0.  If we
1995
   have seen one, it is the offset in the line numbers of the line numbers
1996
   for the psymtab.  */
1997
static unsigned int first_fun_line_offset;
1998
 
1999
static struct partial_symtab *xcoff_start_psymtab
2000
  PARAMS ((struct objfile *, char *, int,
2001
           struct partial_symbol **, struct partial_symbol **));
2002
 
2003
/* Allocate and partially fill a partial symtab.  It will be
2004
   completely filled at the end of the symbol list.
2005
 
2006
   SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2007
   is the address relative to which its symbols are (incremental) or 0
2008
   (normal). */
2009
 
2010
static struct partial_symtab *
2011
xcoff_start_psymtab (objfile, filename, first_symnum, global_syms,
2012
                     static_syms)
2013
     struct objfile *objfile;
2014
     char *filename;
2015
     int first_symnum;
2016
     struct partial_symbol **global_syms;
2017
     struct partial_symbol **static_syms;
2018
{
2019
  struct partial_symtab *result =
2020
  start_psymtab_common (objfile, objfile->section_offsets,
2021
                        filename,
2022
                        /* We fill in textlow later.  */
2023
                        0,
2024
                        global_syms, static_syms);
2025
 
2026
  result->read_symtab_private = (char *)
2027
    obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc));
2028
  ((struct symloc *) result->read_symtab_private)->first_symnum = first_symnum;
2029
  result->read_symtab = xcoff_psymtab_to_symtab;
2030
 
2031
  /* Deduce the source language from the filename for this psymtab. */
2032
  psymtab_language = deduce_language_from_filename (filename);
2033
 
2034
  return result;
2035
}
2036
 
2037
static struct partial_symtab *xcoff_end_psymtab
2038
  PARAMS ((struct partial_symtab *, char **, int, int,
2039
           struct partial_symtab **, int, int));
2040
 
2041
/* Close off the current usage of PST.
2042
   Returns PST, or NULL if the partial symtab was empty and thrown away.
2043
 
2044
   CAPPING_SYMBOL_NUMBER is the end of pst (exclusive).
2045
 
2046
   INCLUDE_LIST, NUM_INCLUDES, DEPENDENCY_LIST, and NUMBER_DEPENDENCIES
2047
   are the information for includes and dependencies.  */
2048
 
2049
static struct partial_symtab *
2050
xcoff_end_psymtab (pst, include_list, num_includes, capping_symbol_number,
2051
                   dependency_list, number_dependencies, textlow_not_set)
2052
     struct partial_symtab *pst;
2053
     char **include_list;
2054
     int num_includes;
2055
     int capping_symbol_number;
2056
     struct partial_symtab **dependency_list;
2057
     int number_dependencies;
2058
     int textlow_not_set;
2059
{
2060
  int i;
2061
  struct objfile *objfile = pst->objfile;
2062
 
2063
  if (capping_symbol_number != -1)
2064
    ((struct symloc *) pst->read_symtab_private)->numsyms =
2065
      capping_symbol_number
2066
      - ((struct symloc *) pst->read_symtab_private)->first_symnum;
2067
  ((struct symloc *) pst->read_symtab_private)->lineno_off =
2068
    first_fun_line_offset;
2069
  first_fun_line_offset = 0;
2070
  pst->n_global_syms =
2071
    objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
2072
  pst->n_static_syms =
2073
    objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
2074
 
2075
  pst->number_of_dependencies = number_dependencies;
2076
  if (number_dependencies)
2077
    {
2078
      pst->dependencies = (struct partial_symtab **)
2079
        obstack_alloc (&objfile->psymbol_obstack,
2080
                    number_dependencies * sizeof (struct partial_symtab *));
2081
      memcpy (pst->dependencies, dependency_list,
2082
              number_dependencies * sizeof (struct partial_symtab *));
2083
    }
2084
  else
2085
    pst->dependencies = 0;
2086
 
2087
  for (i = 0; i < num_includes; i++)
2088
    {
2089
      struct partial_symtab *subpst =
2090
      allocate_psymtab (include_list[i], objfile);
2091
 
2092
      subpst->section_offsets = pst->section_offsets;
2093
      subpst->read_symtab_private =
2094
        (char *) obstack_alloc (&objfile->psymbol_obstack,
2095
                                sizeof (struct symloc));
2096
      ((struct symloc *) subpst->read_symtab_private)->first_symnum = 0;
2097
      ((struct symloc *) subpst->read_symtab_private)->numsyms = 0;
2098
      subpst->textlow = 0;
2099
      subpst->texthigh = 0;
2100
 
2101
      /* We could save slight bits of space by only making one of these,
2102
         shared by the entire set of include files.  FIXME-someday.  */
2103
      subpst->dependencies = (struct partial_symtab **)
2104
        obstack_alloc (&objfile->psymbol_obstack,
2105
                       sizeof (struct partial_symtab *));
2106
      subpst->dependencies[0] = pst;
2107
      subpst->number_of_dependencies = 1;
2108
 
2109
      subpst->globals_offset =
2110
        subpst->n_global_syms =
2111
        subpst->statics_offset =
2112
        subpst->n_static_syms = 0;
2113
 
2114
      subpst->readin = 0;
2115
      subpst->symtab = 0;
2116
      subpst->read_symtab = pst->read_symtab;
2117
    }
2118
 
2119
  sort_pst_symbols (pst);
2120
 
2121
  /* If there is already a psymtab or symtab for a file of this name,
2122
     remove it.  (If there is a symtab, more drastic things also
2123
     happen.)  This happens in VxWorks.  */
2124
  free_named_symtabs (pst->filename);
2125
 
2126
  if (num_includes == 0
2127
      && number_dependencies == 0
2128
      && pst->n_global_syms == 0
2129
      && pst->n_static_syms == 0)
2130
    {
2131
      /* Throw away this psymtab, it's empty.  We can't deallocate it, since
2132
         it is on the obstack, but we can forget to chain it on the list.  */
2133
      /* Empty psymtabs happen as a result of header files which don't have
2134
         any symbols in them.  There can be a lot of them.  */
2135
 
2136
      discard_psymtab (pst);
2137
 
2138
      /* Indicate that psymtab was thrown away.  */
2139
      pst = (struct partial_symtab *) NULL;
2140
    }
2141
  return pst;
2142
}
2143
 
2144
static void swap_sym PARAMS ((struct internal_syment *,
2145
                              union internal_auxent *, char **, char **,
2146
                              unsigned int *,
2147
                              struct objfile *));
2148
 
2149
/* Swap raw symbol at *RAW and put the name in *NAME, the symbol in
2150
   *SYMBOL, the first auxent in *AUX.  Advance *RAW and *SYMNUMP over
2151
   the symbol and its auxents.  */
2152
 
2153
static void
2154
swap_sym (symbol, aux, name, raw, symnump, objfile)
2155
     struct internal_syment *symbol;
2156
     union internal_auxent *aux;
2157
     char **name;
2158
     char **raw;
2159
     unsigned int *symnump;
2160
     struct objfile *objfile;
2161
{
2162
  bfd_coff_swap_sym_in (objfile->obfd, *raw, symbol);
2163
  if (symbol->n_zeroes)
2164
    {
2165
      /* If it's exactly E_SYMNMLEN characters long it isn't
2166
         '\0'-terminated.  */
2167
      if (symbol->n_name[E_SYMNMLEN - 1] != '\0')
2168
        {
2169
          /* FIXME: wastes memory for symbols which we don't end up putting
2170
             into the minimal symbols.  */
2171
          char *p;
2172
          p = obstack_alloc (&objfile->psymbol_obstack, E_SYMNMLEN + 1);
2173
          strncpy (p, symbol->n_name, E_SYMNMLEN);
2174
          p[E_SYMNMLEN] = '\0';
2175
          *name = p;
2176
        }
2177
      else
2178
        /* Point to the unswapped name as that persists as long as the
2179
           objfile does.  */
2180
        *name = ((struct external_syment *) *raw)->e.e_name;
2181
    }
2182
  else if (symbol->n_sclass & 0x80)
2183
    {
2184
      *name = ((struct coff_symfile_info *) objfile->sym_private)->debugsec
2185
        + symbol->n_offset;
2186
    }
2187
  else
2188
    {
2189
      *name = ((struct coff_symfile_info *) objfile->sym_private)->strtbl
2190
        + symbol->n_offset;
2191
    }
2192
  ++*symnump;
2193
  *raw += coff_data (objfile->obfd)->local_symesz;
2194
  if (symbol->n_numaux > 0)
2195
    {
2196
      bfd_coff_swap_aux_in (objfile->obfd, *raw, symbol->n_type,
2197
                            symbol->n_sclass, 0, symbol->n_numaux, aux);
2198
 
2199
      *symnump += symbol->n_numaux;
2200
      *raw += coff_data (objfile->obfd)->local_symesz * symbol->n_numaux;
2201
    }
2202
}
2203
 
2204
static void
2205
scan_xcoff_symtab (objfile)
2206
     struct objfile *objfile;
2207
{
2208
  CORE_ADDR toc_offset = 0;      /* toc offset value in data section. */
2209
  char *filestring = NULL;
2210
 
2211
  char *namestring;
2212
  int past_first_source_file = 0;
2213
  bfd *abfd;
2214
  asection *bfd_sect;
2215
  unsigned int nsyms;
2216
 
2217
  /* Current partial symtab */
2218
  struct partial_symtab *pst;
2219
 
2220
  /* List of current psymtab's include files */
2221
  char **psymtab_include_list;
2222
  int includes_allocated;
2223
  int includes_used;
2224
 
2225
  /* Index within current psymtab dependency list */
2226
  struct partial_symtab **dependency_list;
2227
  int dependencies_used, dependencies_allocated;
2228
 
2229
  char *sraw_symbol;
2230
  struct internal_syment symbol;
2231
  union internal_auxent main_aux[5];
2232
  unsigned int ssymnum;
2233
 
2234
  char *last_csect_name = NULL; /* last seen csect's name and value */
2235
  CORE_ADDR last_csect_val = 0;
2236
  int last_csect_sec = 0;
2237
  int misc_func_recorded = 0;    /* true if any misc. function */
2238
  int textlow_not_set = 1;
2239
 
2240
  pst = (struct partial_symtab *) 0;
2241
 
2242
  includes_allocated = 30;
2243
  includes_used = 0;
2244
  psymtab_include_list = (char **) alloca (includes_allocated *
2245
                                           sizeof (char *));
2246
 
2247
  dependencies_allocated = 30;
2248
  dependencies_used = 0;
2249
  dependency_list =
2250
    (struct partial_symtab **) alloca (dependencies_allocated *
2251
                                       sizeof (struct partial_symtab *));
2252
 
2253
  last_source_file = NULL;
2254
 
2255
  abfd = objfile->obfd;
2256
 
2257
  sraw_symbol = ((struct coff_symfile_info *) objfile->sym_private)->symtbl;
2258
  nsyms = ((struct coff_symfile_info *) objfile->sym_private)->symtbl_num_syms;
2259
  ssymnum = 0;
2260
  while (ssymnum < nsyms)
2261
    {
2262
      int sclass = ((struct external_syment *) sraw_symbol)->e_sclass[0] & 0xff;
2263
      /* This is the type we pass to partial-stab.h.  A less kludgy solution
2264
         would be to break out partial-stab.h into its various parts--shuffle
2265
         off the DBXREAD_ONLY stuff to dbxread.c, and make separate
2266
         pstab-norm.h (for most types), pstab-sol.h (for N_SOL), etc.  */
2267
      int stype;
2268
 
2269
      QUIT;
2270
 
2271
      switch (sclass)
2272
        {
2273
        case C_EXT:
2274
        case C_HIDEXT:
2275
          {
2276
            /* The CSECT auxent--always the last auxent.  */
2277
            union internal_auxent csect_aux;
2278
            unsigned int symnum_before = ssymnum;
2279
 
2280
            swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
2281
                      &ssymnum, objfile);
2282
            if (symbol.n_numaux > 1)
2283
              {
2284
                bfd_coff_swap_aux_in
2285
                  (objfile->obfd,
2286
                   sraw_symbol - coff_data (abfd)->local_symesz,
2287
                   symbol.n_type,
2288
                   symbol.n_sclass,
2289
                   symbol.n_numaux - 1,
2290
                   symbol.n_numaux,
2291
                   &csect_aux);
2292
              }
2293
            else
2294
              csect_aux = main_aux[0];
2295
 
2296
            /* If symbol name starts with ".$" or "$", ignore it.  */
2297
            if (namestring[0] == '$'
2298
                || (namestring[0] == '.' && namestring[1] == '$'))
2299
              break;
2300
 
2301
            switch (csect_aux.x_csect.x_smtyp & 0x7)
2302
              {
2303
              case XTY_SD:
2304
                switch (csect_aux.x_csect.x_smclas)
2305
                  {
2306
                  case XMC_PR:
2307
                    if (last_csect_name)
2308
                      {
2309
                        /* If no misc. function recorded in the last
2310
                           seen csect, enter it as a function. This
2311
                           will take care of functions like strcmp()
2312
                           compiled by xlc.  */
2313
 
2314
                        if (!misc_func_recorded)
2315
                          {
2316
                            RECORD_MINIMAL_SYMBOL
2317
                              (last_csect_name, last_csect_val,
2318
                               mst_text, last_csect_sec,
2319
                               objfile);
2320
                          }
2321
 
2322
                        if (pst != NULL)
2323
                          {
2324
                            /* We have to allocate one psymtab for
2325
                               each program csect, because their text
2326
                               sections need not be adjacent.  */
2327
                            xcoff_end_psymtab
2328
                              (pst, psymtab_include_list, includes_used,
2329
                               symnum_before, dependency_list,
2330
                               dependencies_used, textlow_not_set);
2331
                            includes_used = 0;
2332
                            dependencies_used = 0;
2333
                            /* Give all psymtabs for this source file the same
2334
                               name.  */
2335
                            pst = xcoff_start_psymtab
2336
                              (objfile,
2337
                               filestring,
2338
                               symnum_before,
2339
                               objfile->global_psymbols.next,
2340
                               objfile->static_psymbols.next);
2341
                          }
2342
                      }
2343
                    if (namestring && namestring[0] == '.')
2344
                      {
2345
                        last_csect_name = namestring;
2346
                        last_csect_val = symbol.n_value;
2347
                        last_csect_sec =
2348
                          secnum_to_section (symbol.n_scnum, objfile);
2349
                      }
2350
                    if (pst != NULL)
2351
                      {
2352
                        CORE_ADDR highval =
2353
                        symbol.n_value + csect_aux.x_csect.x_scnlen.l;
2354
                        if (highval > pst->texthigh)
2355
                          pst->texthigh = highval;
2356
                        if (pst->textlow == 0 || symbol.n_value < pst->textlow)
2357
                          pst->textlow = symbol.n_value;
2358
                      }
2359
                    misc_func_recorded = 0;
2360
                    break;
2361
 
2362
                  case XMC_RW:
2363
                    /* Data variables are recorded in the minimal symbol
2364
                       table, except for section symbols.  */
2365
                    if (*namestring != '.')
2366
                      prim_record_minimal_symbol_and_info
2367
                        (namestring, symbol.n_value,
2368
                         sclass == C_HIDEXT ? mst_file_data : mst_data,
2369
                         NULL, secnum_to_section (symbol.n_scnum, objfile),
2370
                         NULL, objfile);
2371
                    break;
2372
 
2373
                  case XMC_TC0:
2374
                    if (toc_offset)
2375
                      warning ("More than one XMC_TC0 symbol found.");
2376
                    toc_offset = symbol.n_value;
2377
 
2378
                    /* Make TOC offset relative to start address of section.  */
2379
                    bfd_sect = secnum_to_bfd_section (symbol.n_scnum, objfile);
2380
                    if (bfd_sect)
2381
                      toc_offset -= bfd_section_vma (objfile->obfd, bfd_sect);
2382
                    break;
2383
 
2384
                  case XMC_TC:
2385
                    /* These symbols tell us where the TOC entry for a
2386
                       variable is, not the variable itself.  */
2387
                    break;
2388
 
2389
                  default:
2390
                    break;
2391
                  }
2392
                break;
2393
 
2394
              case XTY_LD:
2395
                switch (csect_aux.x_csect.x_smclas)
2396
                  {
2397
                  case XMC_PR:
2398
                    /* A function entry point.  */
2399
 
2400
                    if (first_fun_line_offset == 0 && symbol.n_numaux > 1)
2401
                      first_fun_line_offset =
2402
                        main_aux[0].x_sym.x_fcnary.x_fcn.x_lnnoptr;
2403
                    RECORD_MINIMAL_SYMBOL
2404
                      (namestring, symbol.n_value,
2405
                       sclass == C_HIDEXT ? mst_file_text : mst_text,
2406
                       secnum_to_section (symbol.n_scnum, objfile),
2407
                       objfile);
2408
                    break;
2409
 
2410
                  case XMC_GL:
2411
                    /* shared library function trampoline code entry
2412
                       point. */
2413
 
2414
                    /* record trampoline code entries as
2415
                       mst_solib_trampoline symbol.  When we lookup mst
2416
                       symbols, we will choose mst_text over
2417
                       mst_solib_trampoline. */
2418
                    RECORD_MINIMAL_SYMBOL
2419
                      (namestring, symbol.n_value,
2420
                       mst_solib_trampoline,
2421
                       secnum_to_section (symbol.n_scnum, objfile),
2422
                       objfile);
2423
                    break;
2424
 
2425
                  case XMC_DS:
2426
                    /* The symbols often have the same names as
2427
                       debug symbols for functions, and confuse
2428
                       lookup_symbol.  */
2429
                    break;
2430
 
2431
                  default:
2432
 
2433
                    /* xlc puts each variable in a separate csect,
2434
                       so we get an XTY_SD for each variable.  But
2435
                       gcc puts several variables in a csect, so
2436
                       that each variable only gets an XTY_LD.  We
2437
                       still need to record them.  This will
2438
                       typically be XMC_RW; I suspect XMC_RO and
2439
                       XMC_BS might be possible too.  */
2440
                    if (*namestring != '.')
2441
                      prim_record_minimal_symbol_and_info
2442
                        (namestring, symbol.n_value,
2443
                         sclass == C_HIDEXT ? mst_file_data : mst_data,
2444
                         NULL, secnum_to_section (symbol.n_scnum, objfile),
2445
                         NULL, objfile);
2446
                    break;
2447
                  }
2448
                break;
2449
 
2450
              case XTY_CM:
2451
                switch (csect_aux.x_csect.x_smclas)
2452
                  {
2453
                  case XMC_RW:
2454
                  case XMC_BS:
2455
                    /* Common variables are recorded in the minimal symbol
2456
                       table, except for section symbols.  */
2457
                    if (*namestring != '.')
2458
                      prim_record_minimal_symbol_and_info
2459
                        (namestring, symbol.n_value,
2460
                         sclass == C_HIDEXT ? mst_file_bss : mst_bss,
2461
                         NULL, secnum_to_section (symbol.n_scnum, objfile),
2462
                         NULL, objfile);
2463
                    break;
2464
                  }
2465
                break;
2466
 
2467
              default:
2468
                break;
2469
              }
2470
          }
2471
          break;
2472
        case C_FILE:
2473
          {
2474
            unsigned int symnum_before;
2475
 
2476
            symnum_before = ssymnum;
2477
            swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
2478
                      &ssymnum, objfile);
2479
 
2480
            /* See if the last csect needs to be recorded.  */
2481
 
2482
            if (last_csect_name && !misc_func_recorded)
2483
              {
2484
 
2485
                /* If no misc. function recorded in the last seen csect, enter
2486
                   it as a function.  This will take care of functions like
2487
                   strcmp() compiled by xlc.  */
2488
 
2489
                RECORD_MINIMAL_SYMBOL
2490
                  (last_csect_name, last_csect_val,
2491
                   mst_text, last_csect_sec, objfile);
2492
              }
2493
 
2494
            if (pst)
2495
              {
2496
                xcoff_end_psymtab (pst, psymtab_include_list, includes_used,
2497
                                   symnum_before, dependency_list,
2498
                                   dependencies_used, textlow_not_set);
2499
                includes_used = 0;
2500
                dependencies_used = 0;
2501
              }
2502
            first_fun_line_offset = 0;
2503
 
2504
            /* XCOFF, according to the AIX 3.2 documentation, puts the
2505
               filename in cs->c_name.  But xlc 1.3.0.2 has decided to
2506
               do things the standard COFF way and put it in the auxent.
2507
               We use the auxent if the symbol is ".file" and an auxent
2508
               exists, otherwise use the symbol itself.  */
2509
            if (!strcmp (namestring, ".file") && symbol.n_numaux > 0)
2510
              {
2511
                filestring = coff_getfilename (&main_aux[0], objfile);
2512
              }
2513
            else
2514
              filestring = namestring;
2515
 
2516
            pst = xcoff_start_psymtab (objfile,
2517
                                       filestring,
2518
                                       symnum_before,
2519
                                       objfile->global_psymbols.next,
2520
                                       objfile->static_psymbols.next);
2521
            last_csect_name = NULL;
2522
          }
2523
          break;
2524
 
2525
        default:
2526
          {
2527
            static struct complaint msg =
2528
            {"Storage class %d not recognized during scan", 0, 0};
2529
            complain (&msg, sclass);
2530
          }
2531
          /* FALLTHROUGH */
2532
 
2533
          /* C_FCN is .bf and .ef symbols.  I think it is sufficient
2534
             to handle only the C_FUN and C_EXT.  */
2535
        case C_FCN:
2536
 
2537
        case C_BSTAT:
2538
        case C_ESTAT:
2539
        case C_ARG:
2540
        case C_REGPARM:
2541
        case C_REG:
2542
        case C_TPDEF:
2543
        case C_STRTAG:
2544
        case C_UNTAG:
2545
        case C_ENTAG:
2546
        case C_LABEL:
2547
        case C_NULL:
2548
 
2549
          /* C_EINCL means we are switching back to the main file.  But there
2550
             is no reason to care; the only thing we want to know about
2551
             includes is the names of all the included (.h) files.  */
2552
        case C_EINCL:
2553
 
2554
        case C_BLOCK:
2555
 
2556
          /* I don't think C_STAT is used in xcoff; C_HIDEXT appears to be
2557
             used instead.  */
2558
        case C_STAT:
2559
 
2560
          /* I don't think the name of the common block (as opposed to the
2561
             variables within it) is something which is user visible
2562
             currently.  */
2563
        case C_BCOMM:
2564
        case C_ECOMM:
2565
 
2566
        case C_PSYM:
2567
        case C_RPSYM:
2568
 
2569
          /* I think we can ignore C_LSYM; types on xcoff seem to use C_DECL
2570
             so C_LSYM would appear to be only for locals.  */
2571
        case C_LSYM:
2572
 
2573
        case C_AUTO:
2574
        case C_RSYM:
2575
          {
2576
            /* We probably could save a few instructions by assuming that
2577
               C_LSYM, C_PSYM, etc., never have auxents.  */
2578
            int naux1 =
2579
            ((struct external_syment *) sraw_symbol)->e_numaux[0] + 1;
2580
            ssymnum += naux1;
2581
            sraw_symbol += sizeof (struct external_syment) * naux1;
2582
          }
2583
          break;
2584
 
2585
        case C_BINCL:
2586
          stype = N_SOL;
2587
          goto pstab;
2588
 
2589
        case C_FUN:
2590
          /* The value of the C_FUN is not the address of the function (it
2591
             appears to be the address before linking), but as long as it
2592
             is smaller than the actual address, then find_pc_partial_function
2593
             will use the minimal symbols instead.  I hope.  */
2594
 
2595
        case C_GSYM:
2596
        case C_ECOML:
2597
        case C_DECL:
2598
        case C_STSYM:
2599
          stype = N_LSYM;
2600
        pstab:;
2601
          swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
2602
                    &ssymnum, objfile);
2603
#define CUR_SYMBOL_TYPE stype
2604
#define CUR_SYMBOL_VALUE symbol.n_value
2605
 
2606
/* START_PSYMTAB and END_PSYMTAB are never used, because they are only
2607
   called from DBXREAD_ONLY or N_SO code.  Likewise for the symnum
2608
   variable.  */
2609
#define START_PSYMTAB(ofile,fname,low,symoff,global_syms,static_syms) 0
2610
#define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
2611
  do {} while (0)
2612
/* We have already set the namestring.  */
2613
#define SET_NAMESTRING()        /* */
2614
 
2615
#include "partial-stab.h"
2616
        }
2617
    }
2618
 
2619
  if (pst)
2620
    {
2621
      xcoff_end_psymtab (pst, psymtab_include_list, includes_used,
2622
                         ssymnum, dependency_list,
2623
                         dependencies_used, textlow_not_set);
2624
    }
2625
 
2626
  /* Record the toc offset value of this symbol table into objfile structure.
2627
     If no XMC_TC0 is found, toc_offset should be zero. Another place to obtain
2628
     this information would be file auxiliary header. */
2629
 
2630
  ((struct coff_symfile_info *) objfile->sym_private)->toc_offset = toc_offset;
2631
}
2632
 
2633
/* Return the toc offset value for a given objfile.  */
2634
 
2635
CORE_ADDR
2636
get_toc_offset (objfile)
2637
     struct objfile *objfile;
2638
{
2639
  if (objfile)
2640
    return ((struct coff_symfile_info *) objfile->sym_private)->toc_offset;
2641
  return 0;
2642
}
2643
 
2644
/* Scan and build partial symbols for a symbol file.
2645
   We have been initialized by a call to dbx_symfile_init, which
2646
   put all the relevant info into a "struct dbx_symfile_info",
2647
   hung off the objfile structure.
2648
 
2649
   SECTION_OFFSETS contains offsets relative to which the symbols in the
2650
   various sections are (depending where the sections were actually loaded).
2651
   MAINLINE is true if we are reading the main symbol
2652
   table (as opposed to a shared lib or dynamically loaded file).  */
2653
 
2654
static void
2655
xcoff_initial_scan (objfile, mainline)
2656
     struct objfile *objfile;
2657
     int mainline;              /* FIXME comments above */
2658
{
2659
  bfd *abfd;
2660
  int val;
2661
  struct cleanup *back_to;
2662
  int num_symbols;              /* # of symbols */
2663
  file_ptr symtab_offset;       /* symbol table and */
2664
  file_ptr stringtab_offset;    /* string table file offsets */
2665
  struct coff_symfile_info *info;
2666
  char *name;
2667
  unsigned int size;
2668
 
2669
  info = (struct coff_symfile_info *) objfile->sym_private;
2670
  symfile_bfd = abfd = objfile->obfd;
2671
  name = objfile->name;
2672
 
2673
  num_symbols = bfd_get_symcount (abfd);        /* # of symbols */
2674
  symtab_offset = obj_sym_filepos (abfd);       /* symbol table file offset */
2675
  stringtab_offset = symtab_offset +
2676
    num_symbols * coff_data (abfd)->local_symesz;
2677
 
2678
  info->min_lineno_offset = 0;
2679
  info->max_lineno_offset = 0;
2680
  bfd_map_over_sections (abfd, find_linenos, info);
2681
 
2682
  if (num_symbols > 0)
2683
    {
2684
      /* Read the string table.  */
2685
      init_stringtab (abfd, stringtab_offset, objfile);
2686
 
2687
      /* Read the .debug section, if present.  */
2688
      {
2689
        sec_ptr secp;
2690
        bfd_size_type length;
2691
        char *debugsec = NULL;
2692
 
2693
        secp = bfd_get_section_by_name (abfd, ".debug");
2694
        if (secp)
2695
          {
2696
            length = bfd_section_size (abfd, secp);
2697
            if (length)
2698
              {
2699
                debugsec =
2700
                  (char *) obstack_alloc (&objfile->symbol_obstack, length);
2701
 
2702
                if (!bfd_get_section_contents (abfd, secp, debugsec,
2703
                                               (file_ptr) 0, length))
2704
                  {
2705
                    error ("Error reading .debug section of `%s': %s",
2706
                           name, bfd_errmsg (bfd_get_error ()));
2707
                  }
2708
              }
2709
          }
2710
        ((struct coff_symfile_info *) objfile->sym_private)->debugsec =
2711
          debugsec;
2712
      }
2713
    }
2714
 
2715
  /* Read the symbols.  We keep them in core because we will want to
2716
     access them randomly in read_symbol*.  */
2717
  val = bfd_seek (abfd, symtab_offset, SEEK_SET);
2718
  if (val < 0)
2719
    error ("Error reading symbols from %s: %s",
2720
           name, bfd_errmsg (bfd_get_error ()));
2721
  size = coff_data (abfd)->local_symesz * num_symbols;
2722
  ((struct coff_symfile_info *) objfile->sym_private)->symtbl =
2723
    obstack_alloc (&objfile->symbol_obstack, size);
2724
  ((struct coff_symfile_info *) objfile->sym_private)->symtbl_num_syms =
2725
    num_symbols;
2726
 
2727
  val = bfd_read (((struct coff_symfile_info *) objfile->sym_private)->symtbl,
2728
                  size, 1, abfd);
2729
  if (val != size)
2730
    perror_with_name ("reading symbol table");
2731
 
2732
  /* If we are reinitializing, or if we have never loaded syms yet, init */
2733
  if (mainline
2734
      || objfile->global_psymbols.size == 0
2735
      || objfile->static_psymbols.size == 0)
2736
    /* I'm not sure how how good num_symbols is; the rule of thumb in
2737
       init_psymbol_list was developed for a.out.  On the one hand,
2738
       num_symbols includes auxents.  On the other hand, it doesn't
2739
       include N_SLINE.  */
2740
    init_psymbol_list (objfile, num_symbols);
2741
 
2742
  free_pending_blocks ();
2743
  back_to = make_cleanup (really_free_pendings, 0);
2744
 
2745
  init_minimal_symbol_collection ();
2746
  make_cleanup ((make_cleanup_func) discard_minimal_symbols, 0);
2747
 
2748
  /* Now that the symbol table data of the executable file are all in core,
2749
     process them and define symbols accordingly.  */
2750
 
2751
  scan_xcoff_symtab (objfile);
2752
 
2753
  /* Install any minimal symbols that have been collected as the current
2754
     minimal symbols for this objfile. */
2755
 
2756
  install_minimal_symbols (objfile);
2757
 
2758
  do_cleanups (back_to);
2759
}
2760
 
2761
static void
2762
xcoff_symfile_offsets (objfile, addrs)
2763
     struct objfile *objfile;
2764
     struct section_addr_info *addrs;
2765
{
2766
  int i;
2767
 
2768
  objfile->num_sections = SECT_OFF_MAX;
2769
  objfile->section_offsets = (struct section_offsets *)
2770
    obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
2771
 
2772
  /* syms_from_objfile kindly subtracts from addr the bfd_section_vma
2773
     of the .text section.  This strikes me as wrong--whether the
2774
     offset to be applied to symbol reading is relative to the start
2775
     address of the section depends on the symbol format.  In any
2776
     event, this whole "addr" concept is pretty broken (it doesn't
2777
     handle any section but .text sensibly), so just ignore the addr
2778
     parameter and use 0.  rs6000-nat.c will set the correct section
2779
     offsets via objfile_relocate.  */
2780
  for (i = 0; i < objfile->num_sections; ++i)
2781
    ANOFFSET (objfile->section_offsets, i) = 0;
2782
}
2783
 
2784
/* Register our ability to parse symbols for xcoff BFD files.  */
2785
 
2786
static struct sym_fns xcoff_sym_fns =
2787
{
2788
 
2789
  /* Because the bfd uses coff_flavour, we need to specially kludge
2790
     the flavour.  It is possible that coff and xcoff should be merged as
2791
     they do have fundamental similarities (for example, the extra storage
2792
     classes used for stabs could presumably be recognized in any COFF file).
2793
     However, in addition to obvious things like all the csect hair, there are
2794
     some subtler differences between xcoffread.c and coffread.c, notably
2795
     the fact that coffread.c has no need to read in all the symbols, but
2796
     xcoffread.c reads all the symbols and does in fact randomly access them
2797
     (in C_BSTAT and line number processing).  */
2798
 
2799
  (enum bfd_flavour) -1,
2800
 
2801
  xcoff_new_init,               /* sym_new_init: init anything gbl to entire symtab */
2802
  xcoff_symfile_init,           /* sym_init: read initial info, setup for sym_read() */
2803
  xcoff_initial_scan,           /* sym_read: read a symbol file into symtab */
2804
  xcoff_symfile_finish,         /* sym_finish: finished with file, cleanup */
2805
  xcoff_symfile_offsets,        /* sym_offsets: xlate offsets ext->int form */
2806
  NULL                          /* next: pointer to next struct sym_fns */
2807
};
2808
 
2809
void
2810
_initialize_xcoffread ()
2811
{
2812
  add_symtab_fns (&xcoff_sym_fns);
2813
 
2814
  func_symbol_type = init_type (TYPE_CODE_FUNC, 1, 0,
2815
                                "<function, no debug info>", NULL);
2816
  TYPE_TARGET_TYPE (func_symbol_type) = builtin_type_int;
2817
  var_symbol_type =
2818
    init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
2819
               "<variable, no debug info>", NULL);
2820
}

powered by: WebSVN 2.1.0

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