DWARF: handle non-local references in nested functions
[deliverable/binutils-gdb.git] / gdb / xcoffread.c
CommitLineData
c906108c 1/* Read AIX xcoff symbol tables and convert to internal format, for GDB.
32d0add0 2 Copyright (C) 1986-2015 Free Software Foundation, Inc.
c906108c
SS
3 Derived from coffread.c, dbxread.c, and a lot of hacking.
4 Contributed by IBM Corporation.
5
c5aa993b 6 This file is part of GDB.
c906108c 7
c5aa993b
JM
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
a9762ec7 10 the Free Software Foundation; either version 3 of the License, or
c5aa993b 11 (at your option) any later version.
c906108c 12
c5aa993b
JM
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
c906108c 17
c5aa993b 18 You should have received a copy of the GNU General Public License
a9762ec7 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
20
21#include "defs.h"
22#include "bfd.h"
23
24#include <sys/types.h>
25#include <fcntl.h>
26#include <ctype.h>
c0ccb908 27#ifdef HAVE_SYS_FILE_H
c906108c
SS
28#include <sys/file.h>
29#endif
53ce3c39 30#include <sys/stat.h>
c906108c
SS
31
32#include "coff/internal.h"
33#include "libcoff.h" /* FIXME, internal data from BFD */
11ed25ac
KB
34#include "coff/xcoff.h"
35#include "libxcoff.h"
c906108c 36#include "coff/rs6000.h"
63807e1d 37#include "xcoffread.h"
c906108c
SS
38
39#include "symtab.h"
40#include "gdbtypes.h"
9ab9195f 41/* FIXME: ezannoni/2004-02-13 Verify if the include below is really needed. */
c906108c
SS
42#include "symfile.h"
43#include "objfiles.h"
44#include "buildsym.h"
45#include "stabsread.h"
46#include "expression.h"
c906108c 47#include "complaints.h"
ccefe4c4 48#include "psympriv.h"
c906108c
SS
49
50#include "gdb-stabs.h"
51
52/* For interface with stabsread.c. */
53#include "aout/stab_gnu.h"
54
c906108c 55\f
b8b98ad1
TT
56/* Key for XCOFF-associated data. */
57
58static const struct objfile_data *xcoff_objfile_data_key;
59
c906108c
SS
60/* We put a pointer to this structure in the read_symtab_private field
61 of the psymtab. */
62
c5aa993b
JM
63struct symloc
64 {
c906108c 65
c5aa993b 66 /* First symbol number for this file. */
c906108c 67
c5aa993b 68 int first_symnum;
c906108c 69
c5aa993b
JM
70 /* Number of symbols in the section of the symbol table devoted to
71 this file's symbols (actually, the section bracketed may contain
72 more than just this file's symbols). If numsyms is 0, the only
73 reason for this thing's existence is the dependency list. Nothing
74 else will happen when it is read in. */
c906108c 75
c5aa993b 76 int numsyms;
c906108c 77
3e43a32a
MS
78 /* Position of the start of the line number information for this
79 psymtab. */
c5aa993b
JM
80 unsigned int lineno_off;
81 };
c906108c 82
581e13c1 83/* Remember what we deduced to be the source language of this psymtab. */
c906108c
SS
84
85static enum language psymtab_language = language_unknown;
c906108c 86\f
c5aa993b 87
581e13c1 88/* Simplified internal version of coff symbol table information. */
c906108c 89
c5aa993b
JM
90struct coff_symbol
91 {
92 char *c_name;
581e13c1
MS
93 int c_symnum; /* Symbol number of this entry. */
94 int c_naux; /* 0 if syment only, 1 if syment + auxent. */
086850b2 95 CORE_ADDR c_value;
c5aa993b
JM
96 unsigned char c_sclass;
97 int c_secnum;
98 unsigned int c_type;
99 };
c906108c 100
581e13c1 101/* Last function's saved coff symbol `cs'. */
c906108c
SS
102
103static struct coff_symbol fcn_cs_saved;
104
105static bfd *symfile_bfd;
106
107/* Core address of start and end of text of current source file.
108 This is calculated from the first function seen after a C_FILE
581e13c1 109 symbol. */
c906108c
SS
110
111
112static CORE_ADDR cur_src_end_addr;
113
114/* Core address of the end of the first object file. */
115
116static CORE_ADDR first_object_file_end;
117
581e13c1 118/* Initial symbol-table-debug-string vector length. */
c906108c
SS
119
120#define INITIAL_STABVECTOR_LENGTH 40
121
c906108c
SS
122/* Size of a COFF symbol. I think it is always 18, so I'm not sure
123 there is any reason not to just use a #define, but might as well
124 ask BFD for the size and store it here, I guess. */
125
c5aa993b 126static unsigned local_symesz;
c906108c 127
c5aa993b
JM
128struct coff_symfile_info
129 {
581e13c1
MS
130 file_ptr min_lineno_offset; /* Where in file lowest line#s are. */
131 file_ptr max_lineno_offset; /* 1+last byte of line#s in file. */
c906108c 132
c5aa993b
JM
133 /* Pointer to the string table. */
134 char *strtbl;
c906108c 135
c5aa993b
JM
136 /* Pointer to debug section. */
137 char *debugsec;
c906108c 138
c5aa993b
JM
139 /* Pointer to the a.out symbol table. */
140 char *symtbl;
c906108c 141
c5aa993b
JM
142 /* Number of symbols in symtbl. */
143 int symtbl_num_syms;
c906108c 144
c5aa993b
JM
145 /* Offset in data section to TOC anchor. */
146 CORE_ADDR toc_offset;
147 };
c906108c 148
b8b98ad1
TT
149/* Convenience macro to access the per-objfile XCOFF data. */
150
151#define XCOFF_DATA(objfile) \
152 ((struct coff_symfile_info *) objfile_data ((objfile), \
153 xcoff_objfile_data_key))
154
316a8b21
TG
155/* XCOFF names for dwarf sections. There is no compressed sections. */
156
157static const struct dwarf2_debug_sections dwarf2_xcoff_names = {
158 { ".dwinfo", NULL },
159 { ".dwabrev", NULL },
160 { ".dwline", NULL },
161 { ".dwloc", NULL },
162 { NULL, NULL }, /* debug_macinfo */
24d3216f 163 { NULL, NULL }, /* debug_macro */
316a8b21
TG
164 { ".dwstr", NULL },
165 { ".dwrnges", NULL },
166 { NULL, NULL }, /* debug_types */
3019eac3 167 { NULL, NULL }, /* debug_addr */
316a8b21
TG
168 { ".dwframe", NULL },
169 { NULL, NULL }, /* eh_frame */
24d3216f
TT
170 { NULL, NULL }, /* gdb_index */
171 23
316a8b21
TG
172};
173
23136709
KB
174static void
175bf_notfound_complaint (void)
176{
3e43a32a
MS
177 complaint (&symfile_complaints,
178 _("line numbers off, `.bf' symbol not found"));
23136709 179}
c906108c 180
23136709
KB
181static void
182ef_complaint (int arg1)
183{
184 complaint (&symfile_complaints,
e2e0b3e5 185 _("Mismatched .ef symbol ignored starting at symnum %d"), arg1);
23136709 186}
c906108c 187
23136709
KB
188static void
189eb_complaint (int arg1)
190{
191 complaint (&symfile_complaints,
e2e0b3e5 192 _("Mismatched .eb symbol ignored starting at symnum %d"), arg1);
23136709 193}
c906108c 194
a14ed312 195static void xcoff_initial_scan (struct objfile *, int);
c906108c 196
a14ed312 197static void scan_xcoff_symtab (struct objfile *);
c906108c 198
a14ed312 199static char *xcoff_next_symbol_text (struct objfile *);
c906108c 200
a14ed312 201static void record_include_begin (struct coff_symbol *);
c906108c
SS
202
203static void
a14ed312
KB
204enter_line_range (struct subfile *, unsigned, unsigned,
205 CORE_ADDR, CORE_ADDR, unsigned *);
c906108c 206
a14ed312 207static void init_stringtab (bfd *, file_ptr, struct objfile *);
c906108c 208
a14ed312 209static void xcoff_symfile_init (struct objfile *);
c906108c 210
a14ed312 211static void xcoff_new_init (struct objfile *);
c906108c 212
a14ed312 213static void xcoff_symfile_finish (struct objfile *);
c906108c 214
a14ed312 215static char *coff_getfilename (union internal_auxent *, struct objfile *);
c906108c 216
a14ed312 217static void read_symbol (struct internal_syment *, int);
c906108c 218
a14ed312 219static int read_symbol_lineno (int);
c906108c 220
470d5666 221static CORE_ADDR read_symbol_nvalue (int);
c906108c 222
a14ed312
KB
223static struct symbol *process_xcoff_symbol (struct coff_symbol *,
224 struct objfile *);
c906108c 225
5c80ed9d 226static void read_xcoff_symtab (struct objfile *, struct partial_symtab *);
c906108c
SS
227
228#if 0
a14ed312 229static void add_stab_to_list (char *, struct pending_stabs **);
c906108c
SS
230#endif
231
a14ed312 232static int compare_lte (const void *, const void *);
c906108c 233
a14ed312 234static struct linetable *arrange_linetable (struct linetable *);
c906108c 235
a14ed312 236static void record_include_end (struct coff_symbol *);
c906108c 237
a14ed312 238static void process_linenos (CORE_ADDR, CORE_ADDR);
c906108c 239\f
c5aa993b 240
c906108c
SS
241/* Translate from a COFF section number (target_index) to a SECT_OFF_*
242 code. */
a14ed312
KB
243static int secnum_to_section (int, struct objfile *);
244static asection *secnum_to_bfd_section (int, struct objfile *);
c906108c 245
c5aa993b
JM
246struct find_targ_sec_arg
247 {
248 int targ_index;
249 int *resultp;
250 asection **bfd_sect;
b8fbeb18 251 struct objfile *objfile;
c5aa993b 252 };
c906108c 253
a14ed312 254static void find_targ_sec (bfd *, asection *, void *);
c906108c 255
c5aa993b 256static void
4efb68b1 257find_targ_sec (bfd *abfd, asection *sect, void *obj)
c906108c 258{
c5aa993b 259 struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
b8fbeb18 260 struct objfile *objfile = args->objfile;
a109c7c1 261
c906108c
SS
262 if (sect->target_index == args->targ_index)
263 {
264 /* This is the section. Figure out what SECT_OFF_* code it is. */
265 if (bfd_get_section_flags (abfd, sect) & SEC_CODE)
b8fbeb18 266 *args->resultp = SECT_OFF_TEXT (objfile);
c906108c 267 else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
b8fbeb18 268 *args->resultp = SECT_OFF_DATA (objfile);
c906108c 269 else
65cf3563 270 *args->resultp = gdb_bfd_section_index (abfd, sect);
c906108c
SS
271 *args->bfd_sect = sect;
272 }
273}
274
ec92004f
JB
275/* Search all BFD sections for the section whose target_index is
276 equal to N_SCNUM. Set *BFD_SECT to that section. The section's
277 associated index in the objfile's section_offset table is also
278 stored in *SECNUM.
279
280 If no match is found, *BFD_SECT is set to NULL, and *SECNUM
281 is set to the text section's number. */
a109c7c1 282
ec92004f
JB
283static void
284xcoff_secnum_to_sections (int n_scnum, struct objfile *objfile,
285 asection **bfd_sect, int *secnum)
286{
c906108c 287 struct find_targ_sec_arg args;
ec92004f
JB
288
289 args.targ_index = n_scnum;
290 args.resultp = secnum;
291 args.bfd_sect = bfd_sect;
b8fbeb18 292 args.objfile = objfile;
ec92004f
JB
293
294 *bfd_sect = NULL;
295 *secnum = SECT_OFF_TEXT (objfile);
296
c906108c 297 bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
c906108c
SS
298}
299
ec92004f
JB
300/* Return the section number (SECT_OFF_*) that N_SCNUM points to. */
301
302static int
303secnum_to_section (int n_scnum, struct objfile *objfile)
304{
305 int secnum;
306 asection *ignored;
307
308 xcoff_secnum_to_sections (n_scnum, objfile, &ignored, &secnum);
309 return secnum;
310}
311
312/* Return the BFD section that N_SCNUM points to. */
313
c906108c 314static asection *
ec92004f 315secnum_to_bfd_section (int n_scnum, struct objfile *objfile)
c906108c 316{
ec92004f
JB
317 int ignored;
318 asection *bfd_sect;
a109c7c1 319
ec92004f
JB
320 xcoff_secnum_to_sections (n_scnum, objfile, &bfd_sect, &ignored);
321 return bfd_sect;
c906108c
SS
322}
323\f
581e13c1 324/* add a given stab string into given stab vector. */
c906108c
SS
325
326#if 0
327
328static void
fba45db2 329add_stab_to_list (char *stabname, struct pending_stabs **stabvector)
c906108c 330{
c5aa993b
JM
331 if (*stabvector == NULL)
332 {
333 *stabvector = (struct pending_stabs *)
334 xmalloc (sizeof (struct pending_stabs) +
335 INITIAL_STABVECTOR_LENGTH * sizeof (char *));
336 (*stabvector)->count = 0;
337 (*stabvector)->length = INITIAL_STABVECTOR_LENGTH;
338 }
339 else if ((*stabvector)->count >= (*stabvector)->length)
340 {
341 (*stabvector)->length += INITIAL_STABVECTOR_LENGTH;
342 *stabvector = (struct pending_stabs *)
343 xrealloc ((char *) *stabvector, sizeof (struct pending_stabs) +
3e43a32a 344 (*stabvector)->length * sizeof (char *));
c5aa993b
JM
345 }
346 (*stabvector)->stab[(*stabvector)->count++] = stabname;
c906108c
SS
347}
348
349#endif
c5aa993b 350\f/* *INDENT-OFF* */
c906108c
SS
351/* Linenos are processed on a file-by-file basis.
352
353 Two reasons:
354
c5aa993b 355 1) xlc (IBM's native c compiler) postpones static function code
581e13c1 356 emission to the end of a compilation unit. This way it can
c5aa993b 357 determine if those functions (statics) are needed or not, and
581e13c1 358 can do some garbage collection (I think). This makes line
c5aa993b
JM
359 numbers and corresponding addresses unordered, and we end up
360 with a line table like:
361
362
363 lineno addr
364 foo() 10 0x100
365 20 0x200
366 30 0x300
367
368 foo3() 70 0x400
369 80 0x500
370 90 0x600
371
372 static foo2()
373 40 0x700
374 50 0x800
375 60 0x900
376
377 and that breaks gdb's binary search on line numbers, if the
581e13c1 378 above table is not sorted on line numbers. And that sort
c5aa993b
JM
379 should be on function based, since gcc can emit line numbers
380 like:
381
382 10 0x100 - for the init/test part of a for stmt.
383 20 0x200
384 30 0x300
385 10 0x400 - for the increment part of a for stmt.
386
581e13c1 387 arrange_linetable() will do this sorting.
c5aa993b
JM
388
389 2) aix symbol table might look like:
390
391 c_file // beginning of a new file
392 .bi // beginning of include file
393 .ei // end of include file
394 .bi
395 .ei
396
397 basically, .bi/.ei pairs do not necessarily encapsulate
581e13c1 398 their scope. They need to be recorded, and processed later
c5aa993b
JM
399 on when we come the end of the compilation unit.
400 Include table (inclTable) and process_linenos() handle
401 that. */
9846de1b 402/* *INDENT-ON* */
c906108c 403
c5aa993b
JM
404
405
581e13c1 406/* compare line table entry addresses. */
c906108c
SS
407
408static int
fba45db2 409compare_lte (const void *lte1p, const void *lte2p)
c906108c
SS
410{
411 struct linetable_entry *lte1 = (struct linetable_entry *) lte1p;
412 struct linetable_entry *lte2 = (struct linetable_entry *) lte2p;
a109c7c1 413
c906108c
SS
414 return lte1->pc - lte2->pc;
415}
416
581e13c1
MS
417/* Given a line table with function entries are marked, arrange its
418 functions in ascending order and strip off function entry markers
419 and return it in a newly created table. If the old one is good
420 enough, return the old one. */
c906108c
SS
421/* FIXME: I think all this stuff can be replaced by just passing
422 sort_linevec = 1 to end_symtab. */
423
424static struct linetable *
b095261a 425arrange_linetable (struct linetable *oldLineTb)
c906108c 426{
c5aa993b
JM
427 int ii, jj, newline, /* new line count */
428 function_count; /* # of functions */
c906108c 429
c5aa993b
JM
430 struct linetable_entry *fentry; /* function entry vector */
431 int fentry_size; /* # of function entries */
432 struct linetable *newLineTb; /* new line table */
a85c52f2 433 int extra_lines = 0;
c906108c
SS
434
435#define NUM_OF_FUNCTIONS 20
436
437 fentry_size = NUM_OF_FUNCTIONS;
c5aa993b 438 fentry = (struct linetable_entry *)
c906108c
SS
439 xmalloc (fentry_size * sizeof (struct linetable_entry));
440
c5aa993b
JM
441 for (function_count = 0, ii = 0; ii < oldLineTb->nitems; ++ii)
442 {
c5aa993b 443 if (oldLineTb->item[ii].line == 0)
581e13c1 444 { /* Function entry found. */
c5aa993b 445 if (function_count >= fentry_size)
581e13c1 446 { /* Make sure you have room. */
c5aa993b
JM
447 fentry_size *= 2;
448 fentry = (struct linetable_entry *)
3e43a32a
MS
449 xrealloc (fentry,
450 fentry_size * sizeof (struct linetable_entry));
c5aa993b
JM
451 }
452 fentry[function_count].line = ii;
453 fentry[function_count].pc = oldLineTb->item[ii].pc;
454 ++function_count;
a85c52f2
UW
455
456 /* If the function was compiled with XLC, we may have to add an
457 extra line entry later. Reserve space for that. */
458 if (ii + 1 < oldLineTb->nitems
459 && oldLineTb->item[ii].pc != oldLineTb->item[ii + 1].pc)
460 extra_lines++;
c5aa993b 461 }
c906108c 462 }
c906108c 463
c5aa993b
JM
464 if (function_count == 0)
465 {
b8c9b27d 466 xfree (fentry);
c5aa993b
JM
467 return oldLineTb;
468 }
c906108c 469 else if (function_count > 1)
3e43a32a
MS
470 qsort (fentry, function_count,
471 sizeof (struct linetable_entry), compare_lte);
c906108c 472
581e13c1 473 /* Allocate a new line table. */
c906108c
SS
474 newLineTb = (struct linetable *)
475 xmalloc
c5aa993b 476 (sizeof (struct linetable) +
a85c52f2 477 (oldLineTb->nitems - function_count + extra_lines) * sizeof (struct linetable_entry));
c906108c 478
581e13c1
MS
479 /* If line table does not start with a function beginning, copy up until
480 a function begin. */
c906108c
SS
481
482 newline = 0;
483 if (oldLineTb->item[0].line != 0)
c5aa993b
JM
484 for (newline = 0;
485 newline < oldLineTb->nitems && oldLineTb->item[newline].line; ++newline)
c906108c
SS
486 newLineTb->item[newline] = oldLineTb->item[newline];
487
581e13c1 488 /* Now copy function lines one by one. */
c906108c 489
c5aa993b
JM
490 for (ii = 0; ii < function_count; ++ii)
491 {
a85c52f2
UW
492 /* If the function was compiled with XLC, we may have to add an
493 extra line to cover the function prologue. */
494 jj = fentry[ii].line;
495 if (jj + 1 < oldLineTb->nitems
496 && oldLineTb->item[jj].pc != oldLineTb->item[jj + 1].pc)
497 {
498 newLineTb->item[newline] = oldLineTb->item[jj];
499 newLineTb->item[newline].line = oldLineTb->item[jj + 1].line;
500 newline++;
501 }
502
c5aa993b
JM
503 for (jj = fentry[ii].line + 1;
504 jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0;
505 ++jj, ++newline)
506 newLineTb->item[newline] = oldLineTb->item[jj];
507 }
b8c9b27d 508 xfree (fentry);
a85c52f2
UW
509 /* The number of items in the line table must include these
510 extra lines which were added in case of XLC compiled functions. */
511 newLineTb->nitems = oldLineTb->nitems - function_count + extra_lines;
c5aa993b
JM
512 return newLineTb;
513}
c906108c
SS
514
515/* include file support: C_BINCL/C_EINCL pairs will be kept in the
581e13c1 516 following `IncludeChain'. At the end of each symtab (end_symtab),
c906108c 517 we will determine if we should create additional symtab's to
581e13c1 518 represent if (the include files. */
c906108c
SS
519
520
c5aa993b
JM
521typedef struct _inclTable
522{
523 char *name; /* include filename */
c906108c
SS
524
525 /* Offsets to the line table. end points to the last entry which is
526 part of this include file. */
c5aa993b
JM
527 int begin, end;
528
c906108c 529 struct subfile *subfile;
581e13c1 530 unsigned funStartLine; /* Start line # of its function. */
c5aa993b
JM
531}
532InclTable;
c906108c
SS
533
534#define INITIAL_INCLUDE_TABLE_LENGTH 20
c5aa993b
JM
535static InclTable *inclTable; /* global include table */
536static int inclIndx; /* last entry to table */
537static int inclLength; /* table length */
538static int inclDepth; /* nested include depth */
c906108c 539
a14ed312 540static void allocate_include_entry (void);
c906108c
SS
541
542static void
fba45db2 543record_include_begin (struct coff_symbol *cs)
c906108c
SS
544{
545 if (inclDepth)
546 {
547 /* In xcoff, we assume include files cannot be nested (not in .c files
c5aa993b 548 of course, but in corresponding .s files.). */
c906108c
SS
549
550 /* This can happen with old versions of GCC.
c5aa993b
JM
551 GCC 2.3.3-930426 does not exhibit this on a test case which
552 a user said produced the message for him. */
e2e0b3e5 553 complaint (&symfile_complaints, _("Nested C_BINCL symbols"));
c906108c
SS
554 }
555 ++inclDepth;
556
557 allocate_include_entry ();
558
c5aa993b
JM
559 inclTable[inclIndx].name = cs->c_name;
560 inclTable[inclIndx].begin = cs->c_value;
c906108c
SS
561}
562
563static void
fba45db2 564record_include_end (struct coff_symbol *cs)
c906108c 565{
c5aa993b 566 InclTable *pTbl;
c906108c
SS
567
568 if (inclDepth == 0)
569 {
e2e0b3e5 570 complaint (&symfile_complaints, _("Mismatched C_BINCL/C_EINCL pair"));
c906108c
SS
571 }
572
573 allocate_include_entry ();
574
c5aa993b 575 pTbl = &inclTable[inclIndx];
c906108c
SS
576 pTbl->end = cs->c_value;
577
578 --inclDepth;
579 ++inclIndx;
580}
581
582static void
fba45db2 583allocate_include_entry (void)
c906108c
SS
584{
585 if (inclTable == NULL)
586 {
c5aa993b 587 inclTable = (InclTable *)
c906108c
SS
588 xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
589 memset (inclTable,
590 '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
591 inclLength = INITIAL_INCLUDE_TABLE_LENGTH;
592 inclIndx = 0;
593 }
594 else if (inclIndx >= inclLength)
595 {
596 inclLength += INITIAL_INCLUDE_TABLE_LENGTH;
c5aa993b 597 inclTable = (InclTable *)
c906108c 598 xrealloc (inclTable, sizeof (InclTable) * inclLength);
c5aa993b
JM
599 memset (inclTable + inclLength - INITIAL_INCLUDE_TABLE_LENGTH,
600 '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
c906108c
SS
601 }
602}
603
604/* Global variable to pass the psymtab down to all the routines involved
605 in psymtab to symtab processing. */
606static struct partial_symtab *this_symtab_psymtab;
607
5c80ed9d
TT
608/* Objfile related to this_symtab_psymtab; set at the same time. */
609static struct objfile *this_symtab_objfile;
610
c906108c 611/* given the start and end addresses of a compilation unit (or a csect,
581e13c1 612 at times) process its lines and create appropriate line vectors. */
c906108c
SS
613
614static void
fba45db2 615process_linenos (CORE_ADDR start, CORE_ADDR end)
c906108c
SS
616{
617 int offset, ii;
b8b98ad1 618 file_ptr max_offset
5c80ed9d 619 = XCOFF_DATA (this_symtab_objfile)->max_lineno_offset;
c906108c
SS
620
621 /* subfile structure for the main compilation unit. */
622 struct subfile main_subfile;
623
624 /* In the main source file, any time we see a function entry, we
625 reset this variable to function's absolute starting line number.
626 All the following line numbers in the function are relative to
627 this, and we record absolute line numbers in record_line(). */
628
629 unsigned int main_source_baseline = 0;
630
631 unsigned *firstLine;
632
633 offset =
c5aa993b 634 ((struct symloc *) this_symtab_psymtab->read_symtab_private)->lineno_off;
c906108c
SS
635 if (offset == 0)
636 goto return_after_cleanup;
637
638 memset (&main_subfile, '\0', sizeof (main_subfile));
639
640 if (inclIndx == 0)
581e13c1
MS
641 /* All source lines were in the main source file. None in include
642 files. */
c906108c 643
c5aa993b
JM
644 enter_line_range (&main_subfile, offset, 0, start, end,
645 &main_source_baseline);
c906108c
SS
646
647 else
648 {
649 /* There was source with line numbers in include files. */
7a78ae4e
ND
650
651 int linesz =
5c80ed9d 652 coff_data (this_symtab_objfile->obfd)->local_linesz;
c906108c 653 main_source_baseline = 0;
7a78ae4e 654
c5aa993b 655 for (ii = 0; ii < inclIndx; ++ii)
c906108c
SS
656 {
657 struct subfile *tmpSubfile;
658
659 /* If there is main file source before include file, enter it. */
660 if (offset < inclTable[ii].begin)
661 {
662 enter_line_range
7a78ae4e 663 (&main_subfile, offset, inclTable[ii].begin - linesz,
c906108c
SS
664 start, 0, &main_source_baseline);
665 }
666
46212e0b 667 if (strcmp (inclTable[ii].name, get_last_source_file ()) == 0)
c5933f6d
JB
668 {
669 /* The entry in the include table refers to the main source
581e13c1 670 file. Add the lines to the main subfile. */
c5933f6d
JB
671
672 main_source_baseline = inclTable[ii].funStartLine;
673 enter_line_range
674 (&main_subfile, inclTable[ii].begin, inclTable[ii].end,
675 start, 0, &main_source_baseline);
676 inclTable[ii].subfile = &main_subfile;
677 }
678 else
679 {
c5933f6d 680 /* Have a new subfile for the include file. */
c906108c 681
c5933f6d
JB
682 tmpSubfile = inclTable[ii].subfile =
683 (struct subfile *) xmalloc (sizeof (struct subfile));
c906108c 684
c5933f6d
JB
685 memset (tmpSubfile, '\0', sizeof (struct subfile));
686 firstLine = &(inclTable[ii].funStartLine);
687
688 /* Enter include file's lines now. */
689 enter_line_range (tmpSubfile, inclTable[ii].begin,
690 inclTable[ii].end, start, 0, firstLine);
691 }
c906108c
SS
692
693 if (offset <= inclTable[ii].end)
7a78ae4e 694 offset = inclTable[ii].end + linesz;
c906108c
SS
695 }
696
697 /* All the include files' line have been processed at this point. Now,
c5aa993b 698 enter remaining lines of the main file, if any left. */
7a78ae4e 699 if (offset < max_offset + 1 - linesz)
c906108c 700 {
c5aa993b 701 enter_line_range (&main_subfile, offset, 0, start, end,
c906108c
SS
702 &main_source_baseline);
703 }
704 }
705
706 /* Process main file's line numbers. */
707 if (main_subfile.line_vector)
708 {
709 struct linetable *lineTb, *lv;
710
711 lv = main_subfile.line_vector;
712
581e13c1
MS
713 /* Line numbers are not necessarily ordered. xlc compilation will
714 put static function to the end. */
c906108c
SS
715
716 lineTb = arrange_linetable (lv);
717 if (lv == lineTb)
718 {
719 current_subfile->line_vector = (struct linetable *)
720 xrealloc (lv, (sizeof (struct linetable)
721 + lv->nitems * sizeof (struct linetable_entry)));
722 }
723 else
724 {
b8c9b27d 725 xfree (lv);
c906108c
SS
726 current_subfile->line_vector = lineTb;
727 }
728
c5aa993b 729 current_subfile->line_vector_length =
c906108c
SS
730 current_subfile->line_vector->nitems;
731 }
732
733 /* Now, process included files' line numbers. */
734
c5aa993b 735 for (ii = 0; ii < inclIndx; ++ii)
c906108c 736 {
c5933f6d 737 if (inclTable[ii].subfile != ((struct subfile *) &main_subfile)
3e43a32a
MS
738 && (inclTable[ii].subfile)->line_vector) /* Useless if!!!
739 FIXMEmgo */
c906108c
SS
740 {
741 struct linetable *lineTb, *lv;
742
743 lv = (inclTable[ii].subfile)->line_vector;
744
581e13c1
MS
745 /* Line numbers are not necessarily ordered. xlc compilation will
746 put static function to the end. */
c906108c
SS
747
748 lineTb = arrange_linetable (lv);
749
750 push_subfile ();
751
752 /* For the same include file, we might want to have more than one
753 subfile. This happens if we have something like:
754
c5aa993b
JM
755 ......
756 #include "foo.h"
757 ......
758 #include "foo.h"
759 ......
c906108c 760
581e13c1 761 while foo.h including code in it. (stupid but possible)
c906108c
SS
762 Since start_subfile() looks at the name and uses an
763 existing one if finds, we need to provide a fake name and
764 fool it. */
765
766#if 0
4d663531 767 start_subfile (inclTable[ii].name);
c906108c
SS
768#else
769 {
770 /* Pick a fake name that will produce the same results as this
771 one when passed to deduce_language_from_filename. Kludge on
772 top of kludge. */
773 char *fakename = strrchr (inclTable[ii].name, '.');
a109c7c1 774
c906108c
SS
775 if (fakename == NULL)
776 fakename = " ?";
4d663531 777 start_subfile (fakename);
b8c9b27d 778 xfree (current_subfile->name);
c906108c 779 }
c2d11a7d 780 current_subfile->name = xstrdup (inclTable[ii].name);
c906108c
SS
781#endif
782
783 if (lv == lineTb)
784 {
785 current_subfile->line_vector =
786 (struct linetable *) xrealloc
c5aa993b
JM
787 (lv, (sizeof (struct linetable)
788 + lv->nitems * sizeof (struct linetable_entry)));
c906108c
SS
789
790 }
791 else
792 {
b8c9b27d 793 xfree (lv);
c906108c
SS
794 current_subfile->line_vector = lineTb;
795 }
796
c5aa993b 797 current_subfile->line_vector_length =
c906108c 798 current_subfile->line_vector->nitems;
4d663531 799 start_subfile (pop_subfile ());
c906108c
SS
800 }
801 }
802
c5aa993b 803return_after_cleanup:
c906108c
SS
804
805 /* We don't want to keep alloc/free'ing the global include file table. */
806 inclIndx = 0;
c906108c
SS
807}
808
c295b2e5 809static void
f56ce883 810aix_process_linenos (struct objfile *objfile)
c906108c 811{
316a8b21
TG
812 /* There is no linenos to read if there are only dwarf info. */
813 if (this_symtab_psymtab == NULL)
814 return;
815
581e13c1 816 /* Process line numbers and enter them into line vector. */
c906108c
SS
817 process_linenos (last_source_start_addr, cur_src_end_addr);
818}
819
820
821/* Enter a given range of lines into the line vector.
822 can be called in the following two ways:
3e43a32a
MS
823 enter_line_range (subfile, beginoffset, endoffset,
824 startaddr, 0, firstLine) or
825 enter_line_range (subfile, beginoffset, 0,
826 startaddr, endaddr, firstLine)
c906108c
SS
827
828 endoffset points to the last line table entry that we should pay
829 attention to. */
830
831static void
3e43a32a
MS
832enter_line_range (struct subfile *subfile, unsigned beginoffset,
833 unsigned endoffset, /* offsets to line table */
fba45db2
KB
834 CORE_ADDR startaddr, /* offsets to line table */
835 CORE_ADDR endaddr, unsigned *firstLine)
c906108c 836{
5c80ed9d 837 struct objfile *objfile = this_symtab_objfile;
fbf65064 838 struct gdbarch *gdbarch = get_objfile_arch (objfile);
c906108c
SS
839 unsigned int curoffset;
840 CORE_ADDR addr;
7a78ae4e 841 void *ext_lnno;
c906108c
SS
842 struct internal_lineno int_lnno;
843 unsigned int limit_offset;
844 bfd *abfd;
7a78ae4e 845 int linesz;
c906108c
SS
846
847 if (endoffset == 0 && startaddr == 0 && endaddr == 0)
848 return;
849 curoffset = beginoffset;
b8b98ad1 850 limit_offset = XCOFF_DATA (objfile)->max_lineno_offset;
c906108c
SS
851
852 if (endoffset != 0)
853 {
854 if (endoffset >= limit_offset)
855 {
23136709 856 complaint (&symfile_complaints,
e2e0b3e5 857 _("Bad line table offset in C_EINCL directive"));
c906108c
SS
858 return;
859 }
860 limit_offset = endoffset;
861 }
862 else
863 limit_offset -= 1;
7a78ae4e 864
fbf65064 865 abfd = objfile->obfd;
7a78ae4e
ND
866 linesz = coff_data (abfd)->local_linesz;
867 ext_lnno = alloca (linesz);
c906108c
SS
868
869 while (curoffset <= limit_offset)
870 {
871 bfd_seek (abfd, curoffset, SEEK_SET);
3a42e9d0 872 bfd_bread (ext_lnno, linesz, abfd);
7a78ae4e 873 bfd_coff_swap_lineno_in (abfd, ext_lnno, &int_lnno);
c906108c
SS
874
875 /* Find the address this line represents. */
876 addr = (int_lnno.l_lnno
877 ? int_lnno.l_addr.l_paddr
878 : read_symbol_nvalue (int_lnno.l_addr.l_symndx));
fbf65064 879 addr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
c906108c
SS
880
881 if (addr < startaddr || (endaddr && addr >= endaddr))
882 return;
883
884 if (int_lnno.l_lnno == 0)
885 {
886 *firstLine = read_symbol_lineno (int_lnno.l_addr.l_symndx);
fbf65064 887 record_line (subfile, 0, gdbarch_addr_bits_remove (gdbarch, addr));
c906108c
SS
888 --(*firstLine);
889 }
890 else
fbf65064
UW
891 record_line (subfile, *firstLine + int_lnno.l_lnno,
892 gdbarch_addr_bits_remove (gdbarch, addr));
7a78ae4e 893 curoffset += linesz;
c906108c
SS
894 }
895}
896
897
898/* Save the vital information for use when closing off the current file.
899 NAME is the file name the symbols came from, START_ADDR is the first
900 text address for the file, and SIZE is the number of bytes of text. */
901
902#define complete_symtab(name, start_addr) { \
46212e0b 903 set_last_source_file (name); \
1b36a34b 904 last_source_start_addr = start_addr; \
c906108c
SS
905}
906
907
908/* Refill the symbol table input buffer
909 and set the variables that control fetching entries from it.
910 Reports an error if no data available.
911 This function can read past the end of the symbol table
912 (into the string table) but this does no harm. */
913
ec92004f
JB
914/* Create a new minimal symbol (using prim_record_minimal_symbol_and_info).
915
4d1eb6b4
JB
916 Creation of all new minimal symbols should go through this function
917 rather than calling the various prim_record_[...] functions in order
918 to make sure that all symbol addresses get properly relocated.
919
ec92004f
JB
920 Arguments are:
921
922 NAME - the symbol's name (but if NAME starts with a period, that
923 leading period is discarded).
4d1eb6b4
JB
924 ADDRESS - the symbol's address, prior to relocation. This function
925 relocates the address before recording the minimal symbol.
ec92004f
JB
926 MS_TYPE - the symbol's type.
927 N_SCNUM - the symbol's XCOFF section number.
928 OBJFILE - the objfile associated with the minimal symbol. */
c906108c 929
ec92004f
JB
930static void
931record_minimal_symbol (const char *name, CORE_ADDR address,
932 enum minimal_symbol_type ms_type,
933 int n_scnum,
934 struct objfile *objfile)
935{
4d1eb6b4
JB
936 int section = secnum_to_section (n_scnum, objfile);
937
ec92004f
JB
938 if (name[0] == '.')
939 ++name;
940
ec92004f 941 prim_record_minimal_symbol_and_info (name, address, ms_type,
e6dc44a8
TT
942 secnum_to_section (n_scnum, objfile),
943 objfile);
ec92004f 944}
c906108c 945
581e13c1
MS
946/* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
947 nested. At any given time, a symbol can only be in one static block.
948 This is the base address of current static block, zero if non exists. */
c5aa993b 949
c906108c
SS
950static int static_block_base = 0;
951
952/* Section number for the current static block. */
953
954static int static_block_section = -1;
955
581e13c1 956/* true if space for symbol name has been allocated. */
c906108c
SS
957
958static int symname_alloced = 0;
959
960/* Next symbol to read. Pointer into raw seething symbol table. */
961
962static char *raw_symbol;
963
964/* This is the function which stabsread.c calls to get symbol
965 continuations. */
966
967static char *
fba45db2 968xcoff_next_symbol_text (struct objfile *objfile)
c906108c
SS
969{
970 struct internal_syment symbol;
c906108c 971 char *retval;
a109c7c1 972
581e13c1 973 /* FIXME: is this the same as the passed arg? */
5c80ed9d
TT
974 if (this_symtab_objfile)
975 objfile = this_symtab_objfile;
c906108c
SS
976
977 bfd_coff_swap_sym_in (objfile->obfd, raw_symbol, &symbol);
978 if (symbol.n_zeroes)
979 {
e2e0b3e5 980 complaint (&symfile_complaints, _("Unexpected symbol continuation"));
c906108c
SS
981
982 /* Return something which points to '\0' and hope the symbol reading
c5aa993b 983 code does something reasonable. */
c906108c
SS
984 retval = "";
985 }
986 else if (symbol.n_sclass & 0x80)
987 {
b8b98ad1 988 retval = XCOFF_DATA (objfile)->debugsec + symbol.n_offset;
3e43a32a 989 raw_symbol += coff_data (objfile->obfd)->local_symesz;
c906108c
SS
990 ++symnum;
991 }
992 else
993 {
e2e0b3e5 994 complaint (&symfile_complaints, _("Unexpected symbol continuation"));
c906108c
SS
995
996 /* Return something which points to '\0' and hope the symbol reading
c5aa993b 997 code does something reasonable. */
c906108c
SS
998 retval = "";
999 }
1000 return retval;
1001}
1002
1003/* Read symbols for a given partial symbol table. */
1004
1005static void
5c80ed9d 1006read_xcoff_symtab (struct objfile *objfile, struct partial_symtab *pst)
c906108c 1007{
c906108c 1008 bfd *abfd = objfile->obfd;
581e13c1 1009 char *raw_auxptr; /* Pointer to first raw aux entry for sym. */
b8b98ad1
TT
1010 struct coff_symfile_info *xcoff = XCOFF_DATA (objfile);
1011 char *strtbl = xcoff->strtbl;
1012 char *debugsec = xcoff->debugsec;
554d387d 1013 const char *debugfmt = bfd_xcoff_is_xcoff64 (abfd) ? "XCOFF64" : "XCOFF";
c906108c
SS
1014
1015 struct internal_syment symbol[1];
1016 union internal_auxent main_aux;
1017 struct coff_symbol cs[1];
1018 CORE_ADDR file_start_addr = 0;
1019 CORE_ADDR file_end_addr = 0;
1020
1021 int next_file_symnum = -1;
1022 unsigned int max_symnum;
1023 int just_started = 1;
1024 int depth = 0;
086850b2 1025 CORE_ADDR fcn_start_addr = 0;
c906108c 1026
238ae9af 1027 struct coff_symbol fcn_stab_saved = { 0 };
c906108c 1028
581e13c1 1029 /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
3672b1be 1030 union internal_auxent fcn_aux_saved = main_aux;
fe978cb0 1031 struct context_stack *newobj;
c906108c 1032
581e13c1 1033 char *filestring = " _start_ "; /* Name of the current file. */
c906108c 1034
40301fb7 1035 const char *last_csect_name; /* Last seen csect's name. */
c906108c
SS
1036
1037 this_symtab_psymtab = pst;
5c80ed9d 1038 this_symtab_objfile = objfile;
c906108c
SS
1039
1040 /* Get the appropriate COFF "constants" related to the file we're
581e13c1 1041 handling. */
c906108c
SS
1042 local_symesz = coff_data (abfd)->local_symesz;
1043
46212e0b 1044 set_last_source_file (NULL);
c906108c 1045 last_csect_name = 0;
c906108c
SS
1046
1047 start_stabs ();
4d663531 1048 start_symtab (objfile, filestring, (char *) NULL, file_start_addr);
7a78ae4e 1049 record_debugformat (debugfmt);
c5aa993b 1050 symnum = ((struct symloc *) pst->read_symtab_private)->first_symnum;
c906108c 1051 max_symnum =
c5aa993b 1052 symnum + ((struct symloc *) pst->read_symtab_private)->numsyms;
c906108c
SS
1053 first_object_file_end = 0;
1054
b8b98ad1 1055 raw_symbol = xcoff->symtbl + symnum * local_symesz;
c906108c
SS
1056
1057 while (symnum < max_symnum)
1058 {
c906108c
SS
1059 QUIT; /* make this command interruptable. */
1060
1061 /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
581e13c1 1062 /* read one symbol into `cs' structure. After processing the
c5aa993b 1063 whole symbol table, only string table will be kept in memory,
581e13c1 1064 symbol table and debug section of xcoff will be freed. Thus
c5aa993b 1065 we can mark symbols with names in string table as
581e13c1 1066 `alloced'. */
c906108c
SS
1067 {
1068 int ii;
1069
1070 /* Swap and align the symbol into a reasonable C structure. */
1071 bfd_coff_swap_sym_in (abfd, raw_symbol, symbol);
1072
1073 cs->c_symnum = symnum;
1074 cs->c_naux = symbol->n_numaux;
1075 if (symbol->n_zeroes)
1076 {
1077 symname_alloced = 0;
1078 /* We must use the original, unswapped, name here so the name field
1079 pointed to by cs->c_name will persist throughout xcoffread. If
1080 we use the new field, it gets overwritten for each symbol. */
c5aa993b 1081 cs->c_name = ((struct external_syment *) raw_symbol)->e.e_name;
c906108c
SS
1082 /* If it's exactly E_SYMNMLEN characters long it isn't
1083 '\0'-terminated. */
1084 if (cs->c_name[E_SYMNMLEN - 1] != '\0')
1085 {
1086 char *p;
a109c7c1 1087
4a146b47 1088 p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1);
c906108c
SS
1089 strncpy (p, cs->c_name, E_SYMNMLEN);
1090 p[E_SYMNMLEN] = '\0';
1091 cs->c_name = p;
1092 symname_alloced = 1;
1093 }
1094 }
1095 else if (symbol->n_sclass & 0x80)
1096 {
1097 cs->c_name = debugsec + symbol->n_offset;
1098 symname_alloced = 0;
1099 }
1100 else
1101 {
1102 /* in string table */
c5aa993b 1103 cs->c_name = strtbl + (int) symbol->n_offset;
c906108c
SS
1104 symname_alloced = 1;
1105 }
1106 cs->c_value = symbol->n_value;
1107 cs->c_sclass = symbol->n_sclass;
1108 cs->c_secnum = symbol->n_scnum;
c5aa993b 1109 cs->c_type = (unsigned) symbol->n_type;
c906108c 1110
7a78ae4e 1111 raw_symbol += local_symesz;
c906108c
SS
1112 ++symnum;
1113
1114 /* Save addr of first aux entry. */
1115 raw_auxptr = raw_symbol;
1116
1117 /* Skip all the auxents associated with this symbol. */
1118 for (ii = symbol->n_numaux; ii; --ii)
1119 {
1120 raw_symbol += coff_data (abfd)->local_auxesz;
1121 ++symnum;
1122 }
1123 }
1124
581e13c1 1125 /* if symbol name starts with ".$" or "$", ignore it. */
c906108c
SS
1126 if (cs->c_name[0] == '$'
1127 || (cs->c_name[1] == '$' && cs->c_name[0] == '.'))
1128 continue;
1129
1130 if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
1131 {
46212e0b 1132 if (get_last_source_file ())
c906108c 1133 {
43f3e411
DE
1134 pst->compunit_symtab = end_symtab (cur_src_end_addr,
1135 SECT_OFF_TEXT (objfile));
c906108c
SS
1136 end_stabs ();
1137 }
1138
1139 start_stabs ();
4d663531 1140 start_symtab (objfile, "_globals_", (char *) NULL, (CORE_ADDR) 0);
7a78ae4e 1141 record_debugformat (debugfmt);
c906108c 1142 cur_src_end_addr = first_object_file_end;
581e13c1 1143 /* Done with all files, everything from here on is globals. */
c906108c
SS
1144 }
1145
c906108c
SS
1146 if ((cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT)
1147 && cs->c_naux == 1)
1148 {
1149 /* Dealing with a symbol with a csect entry. */
1150
1151#define CSECT(PP) ((PP)->x_csect)
1152#define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
1153#define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1154#define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1155#define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1156
1157 /* Convert the auxent to something we can access. */
1158 bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1159 0, cs->c_naux, &main_aux);
1160
1161 switch (CSECT_SMTYP (&main_aux))
1162 {
1163
1164 case XTY_ER:
1165 /* Ignore all external references. */
1166 continue;
1167
1168 case XTY_SD:
1169 /* A section description. */
1170 {
1171 switch (CSECT_SCLAS (&main_aux))
1172 {
1173
1174 case XMC_PR:
1175 {
1176
1177 /* A program csect is seen. We have to allocate one
c5aa993b
JM
1178 symbol table for each program csect. Normally gdb
1179 prefers one symtab for each source file. In case
1180 of AIX, one source file might include more than one
1181 [PR] csect, and they don't have to be adjacent in
581e13c1 1182 terms of the space they occupy in memory. Thus, one
c5aa993b
JM
1183 single source file might get fragmented in the
1184 memory and gdb's file start and end address
1185 approach does not work! GCC (and I think xlc) seem
1186 to put all the code in the unnamed program csect. */
c906108c
SS
1187
1188 if (last_csect_name)
1189 {
1190 complete_symtab (filestring, file_start_addr);
1191 cur_src_end_addr = file_end_addr;
43f3e411 1192 end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
c906108c
SS
1193 end_stabs ();
1194 start_stabs ();
1195 /* Give all csects for this source file the same
1196 name. */
4d663531
DE
1197 start_symtab (objfile, filestring, NULL,
1198 (CORE_ADDR) 0);
7a78ae4e 1199 record_debugformat (debugfmt);
c906108c
SS
1200 }
1201
1202 /* If this is the very first csect seen,
581e13c1 1203 basically `__start'. */
c906108c
SS
1204 if (just_started)
1205 {
1206 first_object_file_end
1207 = cs->c_value + CSECT_LEN (&main_aux);
1208 just_started = 0;
1209 }
1210
1211 file_start_addr =
1212 cs->c_value + ANOFFSET (objfile->section_offsets,
b8fbeb18 1213 SECT_OFF_TEXT (objfile));
c906108c
SS
1214 file_end_addr = file_start_addr + CSECT_LEN (&main_aux);
1215
40301fb7
JB
1216 if (cs->c_name && (cs->c_name[0] == '.' || cs->c_name[0] == '@'))
1217 last_csect_name = cs->c_name;
c906108c
SS
1218 }
1219 continue;
1220
1221 /* All other symbols are put into the minimal symbol
1222 table only. */
1223
1224 case XMC_RW:
1225 continue;
1226
1227 case XMC_TC0:
1228 continue;
1229
1230 case XMC_TC:
1231 continue;
1232
1233 default:
1234 /* Ignore the symbol. */
1235 continue;
1236 }
1237 }
1238 break;
1239
1240 case XTY_LD:
1241
1242 switch (CSECT_SCLAS (&main_aux))
1243 {
1244 case XMC_PR:
581e13c1 1245 /* a function entry point. */
c906108c
SS
1246 function_entry_point:
1247
1248 fcn_start_addr = cs->c_value;
1249
1250 /* save the function header info, which will be used
581e13c1 1251 when `.bf' is seen. */
c906108c
SS
1252 fcn_cs_saved = *cs;
1253 fcn_aux_saved = main_aux;
1254 continue;
1255
1256 case XMC_GL:
581e13c1 1257 /* shared library function trampoline code entry point. */
c906108c
SS
1258 continue;
1259
1260 case XMC_DS:
1261 /* The symbols often have the same names as debug symbols for
1262 functions, and confuse lookup_symbol. */
1263 continue;
1264
1265 default:
1266 /* xlc puts each variable in a separate csect, so we get
1267 an XTY_SD for each variable. But gcc puts several
1268 variables in a csect, so that each variable only gets
581e13c1 1269 an XTY_LD. This will typically be XMC_RW; I suspect
c906108c
SS
1270 XMC_RO and XMC_BS might be possible too.
1271 These variables are put in the minimal symbol table
1272 only. */
1273 continue;
1274 }
1275 break;
1276
1277 case XTY_CM:
1278 /* Common symbols are put into the minimal symbol table only. */
1279 continue;
1280
1281 default:
1282 break;
1283 }
1284 }
1285
977adac5
ND
1286 /* If explicitly specified as a function, treat is as one. This check
1287 evaluates to true for @FIX* bigtoc CSECT symbols, so it must occur
1288 after the above CSECT check. */
1289 if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
1290 {
1291 bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1292 0, cs->c_naux, &main_aux);
1293 goto function_entry_point;
1294 }
1295
c906108c
SS
1296 switch (cs->c_sclass)
1297 {
c906108c
SS
1298 case C_FILE:
1299
1300 /* c_value field contains symnum of next .file entry in table
581e13c1 1301 or symnum of first global after last .file. */
c906108c
SS
1302
1303 next_file_symnum = cs->c_value;
1304
1305 /* Complete symbol table for last object file containing
581e13c1 1306 debugging information. */
c906108c
SS
1307
1308 /* Whether or not there was a csect in the previous file, we
1309 have to call `end_stabs' and `start_stabs' to reset
1310 type_vector, line_vector, etc. structures. */
1311
1312 complete_symtab (filestring, file_start_addr);
1313 cur_src_end_addr = file_end_addr;
4d663531 1314 end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
c906108c
SS
1315 end_stabs ();
1316
3e43a32a
MS
1317 /* XCOFF, according to the AIX 3.2 documentation, puts the
1318 filename in cs->c_name. But xlc 1.3.0.2 has decided to
1319 do things the standard COFF way and put it in the auxent.
1320 We use the auxent if the symbol is ".file" and an auxent
1321 exists, otherwise use the symbol itself. Simple
1322 enough. */
c906108c
SS
1323 if (!strcmp (cs->c_name, ".file") && cs->c_naux > 0)
1324 {
1325 bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1326 0, cs->c_naux, &main_aux);
1327 filestring = coff_getfilename (&main_aux, objfile);
1328 }
1329 else
1330 filestring = cs->c_name;
1331
1332 start_stabs ();
4d663531 1333 start_symtab (objfile, filestring, (char *) NULL, (CORE_ADDR) 0);
7a78ae4e 1334 record_debugformat (debugfmt);
c906108c
SS
1335 last_csect_name = 0;
1336
581e13c1 1337 /* reset file start and end addresses. A compilation unit
3e43a32a 1338 with no text (only data) should have zero file
581e13c1 1339 boundaries. */
c906108c
SS
1340 file_start_addr = file_end_addr = 0;
1341 break;
1342
1343 case C_FUN:
1344 fcn_stab_saved = *cs;
1345 break;
1346
1347 case C_FCN:
7ecb6532 1348 if (strcmp (cs->c_name, ".bf") == 0)
c906108c
SS
1349 {
1350 CORE_ADDR off = ANOFFSET (objfile->section_offsets,
b8fbeb18 1351 SECT_OFF_TEXT (objfile));
a109c7c1 1352
c906108c
SS
1353 bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1354 0, cs->c_naux, &main_aux);
1355
1356 within_function = 1;
1357
fe978cb0 1358 newobj = push_context (0, fcn_start_addr + off);
c906108c 1359
fe978cb0 1360 newobj->name = define_symbol
c906108c
SS
1361 (fcn_cs_saved.c_value + off,
1362 fcn_stab_saved.c_name, 0, 0, objfile);
fe978cb0
PA
1363 if (newobj->name != NULL)
1364 SYMBOL_SECTION (newobj->name) = SECT_OFF_TEXT (objfile);
c906108c 1365 }
7ecb6532 1366 else if (strcmp (cs->c_name, ".ef") == 0)
c906108c 1367 {
c906108c
SS
1368 bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1369 0, cs->c_naux, &main_aux);
1370
1371 /* The value of .ef is the address of epilogue code;
c5aa993b 1372 not useful for gdb. */
c906108c 1373 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
c5aa993b 1374 contains number of lines to '}' */
c906108c
SS
1375
1376 if (context_stack_depth <= 0)
581e13c1 1377 { /* We attempted to pop an empty context stack. */
23136709 1378 ef_complaint (cs->c_symnum);
c906108c
SS
1379 within_function = 0;
1380 break;
1381 }
fe978cb0 1382 newobj = pop_context ();
c906108c 1383 /* Stack must be empty now. */
fe978cb0 1384 if (context_stack_depth > 0 || newobj == NULL)
c906108c 1385 {
23136709 1386 ef_complaint (cs->c_symnum);
c906108c
SS
1387 within_function = 0;
1388 break;
1389 }
1390
fe978cb0 1391 finish_block (newobj->name, &local_symbols, newobj->old_blocks,
63e43d3a 1392 NULL, newobj->start_addr,
c906108c
SS
1393 (fcn_cs_saved.c_value
1394 + fcn_aux_saved.x_sym.x_misc.x_fsize
1395 + ANOFFSET (objfile->section_offsets,
4d663531 1396 SECT_OFF_TEXT (objfile))));
c906108c
SS
1397 within_function = 0;
1398 }
1399 break;
1400
1401 case C_BSTAT:
1402 /* Begin static block. */
1403 {
1404 struct internal_syment symbol;
1405
1406 read_symbol (&symbol, cs->c_value);
1407 static_block_base = symbol.n_value;
1408 static_block_section =
1409 secnum_to_section (symbol.n_scnum, objfile);
1410 }
1411 break;
1412
1413 case C_ESTAT:
1414 /* End of static block. */
1415 static_block_base = 0;
1416 static_block_section = -1;
1417 break;
1418
1419 case C_ARG:
1420 case C_REGPARM:
1421 case C_REG:
1422 case C_TPDEF:
1423 case C_STRTAG:
1424 case C_UNTAG:
1425 case C_ENTAG:
1426 {
3e43a32a
MS
1427 complaint (&symfile_complaints,
1428 _("Unrecognized storage class %d."),
23136709 1429 cs->c_sclass);
c906108c
SS
1430 }
1431 break;
1432
1433 case C_LABEL:
1434 case C_NULL:
1435 /* Ignore these. */
1436 break;
1437
1438 case C_HIDEXT:
1439 case C_STAT:
1440 break;
1441
1442 case C_BINCL:
1443 /* beginning of include file */
1444 /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
581e13c1
MS
1445 order. Thus, when wee see them, we might not know enough info
1446 to process them. Thus, we'll be saving them into a table
1447 (inclTable) and postpone their processing. */
c906108c
SS
1448
1449 record_include_begin (cs);
1450 break;
1451
1452 case C_EINCL:
1453 /* End of include file. */
1454 /* See the comment after case C_BINCL. */
1455 record_include_end (cs);
1456 break;
1457
1458 case C_BLOCK:
7ecb6532 1459 if (strcmp (cs->c_name, ".bb") == 0)
c906108c
SS
1460 {
1461 depth++;
fe978cb0 1462 newobj = push_context (depth,
c906108c
SS
1463 (cs->c_value
1464 + ANOFFSET (objfile->section_offsets,
b8fbeb18 1465 SECT_OFF_TEXT (objfile))));
c906108c 1466 }
7ecb6532 1467 else if (strcmp (cs->c_name, ".eb") == 0)
c906108c
SS
1468 {
1469 if (context_stack_depth <= 0)
581e13c1 1470 { /* We attempted to pop an empty context stack. */
23136709 1471 eb_complaint (cs->c_symnum);
c906108c
SS
1472 break;
1473 }
fe978cb0
PA
1474 newobj = pop_context ();
1475 if (depth-- != newobj->depth)
c906108c 1476 {
23136709 1477 eb_complaint (cs->c_symnum);
c906108c
SS
1478 break;
1479 }
1480 if (local_symbols && context_stack_depth > 0)
1481 {
1482 /* Make a block for the local symbols within. */
63e43d3a
PMR
1483 finish_block (newobj->name, &local_symbols,
1484 newobj->old_blocks, NULL,
fe978cb0 1485 newobj->start_addr,
c906108c
SS
1486 (cs->c_value
1487 + ANOFFSET (objfile->section_offsets,
4d663531 1488 SECT_OFF_TEXT (objfile))));
c906108c 1489 }
fe978cb0 1490 local_symbols = newobj->locals;
c906108c
SS
1491 }
1492 break;
1493
1494 default:
1495 process_xcoff_symbol (cs, objfile);
1496 break;
1497 }
1498 }
1499
46212e0b 1500 if (get_last_source_file ())
c906108c 1501 {
43f3e411 1502 struct compunit_symtab *cust;
c906108c
SS
1503
1504 complete_symtab (filestring, file_start_addr);
1505 cur_src_end_addr = file_end_addr;
43f3e411 1506 cust = end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
c906108c 1507 /* When reading symbols for the last C_FILE of the objfile, try
43f3e411 1508 to make sure that we set pst->compunit_symtab to the symtab for the
c906108c
SS
1509 file, not to the _globals_ symtab. I'm not sure whether this
1510 actually works right or when/if it comes up. */
43f3e411
DE
1511 if (pst->compunit_symtab == NULL)
1512 pst->compunit_symtab = cust;
c906108c
SS
1513 end_stabs ();
1514 }
1515}
1516
1517#define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1518 (SYMBOL2) = (struct symbol *) \
4a146b47 1519 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); \
c906108c 1520 *(SYMBOL2) = *(SYMBOL1);
c5aa993b
JM
1521
1522
c906108c 1523#define SYMNAME_ALLOC(NAME, ALLOCED) \
10f0c4bb
TT
1524 ((ALLOCED) ? (NAME) : obstack_copy0 (&objfile->objfile_obstack, \
1525 (NAME), strlen (NAME)))
c906108c
SS
1526
1527
581e13c1 1528/* process one xcoff symbol. */
c906108c
SS
1529
1530static struct symbol *
aa1ee363 1531process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile)
c906108c
SS
1532{
1533 struct symbol onesymbol;
52f0bd74 1534 struct symbol *sym = &onesymbol;
c906108c
SS
1535 struct symbol *sym2 = NULL;
1536 char *name, *pp;
1537
1538 int sec;
1539 CORE_ADDR off;
1540
1541 if (cs->c_secnum < 0)
1542 {
1543 /* The value is a register number, offset within a frame, etc.,
c5aa993b 1544 and does not get relocated. */
c906108c
SS
1545 off = 0;
1546 sec = -1;
1547 }
1548 else
1549 {
1550 sec = secnum_to_section (cs->c_secnum, objfile);
1551 off = ANOFFSET (objfile->section_offsets, sec);
1552 }
1553
1554 name = cs->c_name;
1555 if (name[0] == '.')
1556 ++name;
1557
38bf1463 1558 initialize_objfile_symbol (sym);
c906108c
SS
1559
1560 /* default assumptions */
7a78ae4e 1561 SYMBOL_VALUE_ADDRESS (sym) = cs->c_value + off;
176620f1 1562 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
c906108c
SS
1563 SYMBOL_SECTION (sym) = secnum_to_section (cs->c_secnum, objfile);
1564
1565 if (ISFCN (cs->c_type))
1566 {
1567 /* At this point, we don't know the type of the function. This
c5aa993b
JM
1568 will be patched with the type from its stab entry later on in
1569 patch_block_stabs (), unless the file was compiled without -g. */
c906108c 1570
3567439c 1571 SYMBOL_SET_LINKAGE_NAME (sym, SYMNAME_ALLOC (name, symname_alloced));
46bf5051 1572 SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_text_symbol;
c906108c 1573
f1e6e072 1574 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
c906108c
SS
1575 SYMBOL_DUP (sym, sym2);
1576
1577 if (cs->c_sclass == C_EXT)
1578 add_symbol_to_list (sym2, &global_symbols);
1579 else if (cs->c_sclass == C_HIDEXT || cs->c_sclass == C_STAT)
1580 add_symbol_to_list (sym2, &file_symbols);
1581 }
1582 else
1583 {
581e13c1 1584 /* In case we can't figure out the type, provide default. */
46bf5051 1585 SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_data_symbol;
c906108c
SS
1586
1587 switch (cs->c_sclass)
1588 {
1589#if 0
c5aa993b
JM
1590 /* The values of functions and global symbols are now resolved
1591 via the global_sym_chain in stabsread.c. */
c906108c
SS
1592 case C_FUN:
1593 if (fcn_cs_saved.c_sclass == C_EXT)
1594 add_stab_to_list (name, &global_stabs);
1595 else
1596 add_stab_to_list (name, &file_stabs);
1597 break;
1598
1599 case C_GSYM:
1600 add_stab_to_list (name, &global_stabs);
1601 break;
1602#endif
1603
1604 case C_BCOMM:
1605 common_block_start (cs->c_name, objfile);
1606 break;
1607
1608 case C_ECOMM:
1609 common_block_end (objfile);
1610 break;
1611
1612 default:
e2e0b3e5 1613 complaint (&symfile_complaints, _("Unexpected storage class: %d"),
23136709 1614 cs->c_sclass);
c906108c
SS
1615 /* FALLTHROUGH */
1616
1617 case C_DECL:
1618 case C_PSYM:
1619 case C_RPSYM:
1620 case C_ECOML:
1621 case C_LSYM:
1622 case C_RSYM:
1623 case C_GSYM:
1624
1625 {
1626 sym = define_symbol (cs->c_value + off, cs->c_name, 0, 0, objfile);
1627 if (sym != NULL)
1628 {
1629 SYMBOL_SECTION (sym) = sec;
1630 }
1631 return sym;
1632 }
1633
1634 case C_STSYM:
1635
1636 /* For xlc (not GCC), the 'V' symbol descriptor is used for
1637 all statics and we need to distinguish file-scope versus
1638 function-scope using within_function. We do this by
1639 changing the string we pass to define_symbol to use 'S'
1640 where we need to, which is not necessarily super-clean,
1641 but seems workable enough. */
1642
9b13a2db
PM
1643 if (*name == ':')
1644 return NULL;
1645
ed4b0e6a 1646 pp = strchr (name, ':');
9b13a2db 1647 if (pp == NULL)
c906108c
SS
1648 return NULL;
1649
1650 ++pp;
1651 if (*pp == 'V' && !within_function)
1652 *pp = 'S';
1653 sym = define_symbol ((cs->c_value
1654 + ANOFFSET (objfile->section_offsets,
1655 static_block_section)),
1656 cs->c_name, 0, 0, objfile);
1657 if (sym != NULL)
1658 {
7a78ae4e 1659 SYMBOL_VALUE_ADDRESS (sym) += static_block_base;
c906108c
SS
1660 SYMBOL_SECTION (sym) = static_block_section;
1661 }
1662 return sym;
1663
1664 }
1665 }
1666 return sym2;
1667}
1668
1669/* Extract the file name from the aux entry of a C_FILE symbol.
1670 Result is in static storage and is only good for temporary use. */
1671
1672static char *
fba45db2 1673coff_getfilename (union internal_auxent *aux_entry, struct objfile *objfile)
c906108c
SS
1674{
1675 static char buffer[BUFSIZ];
1676
1677 if (aux_entry->x_file.x_n.x_zeroes == 0)
b8b98ad1
TT
1678 strcpy (buffer, (XCOFF_DATA (objfile)->strtbl
1679 + aux_entry->x_file.x_n.x_offset));
c906108c
SS
1680 else
1681 {
1682 strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
1683 buffer[FILNMLEN] = '\0';
1684 }
1685 return (buffer);
1686}
1687
1688/* Set *SYMBOL to symbol number symno in symtbl. */
1689static void
fba45db2 1690read_symbol (struct internal_syment *symbol, int symno)
c906108c 1691{
5c80ed9d 1692 struct coff_symfile_info *xcoff = XCOFF_DATA (this_symtab_objfile);
b8b98ad1
TT
1693 int nsyms = xcoff->symtbl_num_syms;
1694 char *stbl = xcoff->symtbl;
a109c7c1 1695
c906108c
SS
1696 if (symno < 0 || symno >= nsyms)
1697 {
e2e0b3e5 1698 complaint (&symfile_complaints, _("Invalid symbol offset"));
c906108c
SS
1699 symbol->n_value = 0;
1700 symbol->n_scnum = -1;
1701 return;
1702 }
5c80ed9d 1703 bfd_coff_swap_sym_in (this_symtab_objfile->obfd,
c5aa993b 1704 stbl + (symno * local_symesz),
c906108c
SS
1705 symbol);
1706}
c5aa993b 1707
c906108c
SS
1708/* Get value corresponding to symbol number symno in symtbl. */
1709
470d5666 1710static CORE_ADDR
fba45db2 1711read_symbol_nvalue (int symno)
c906108c
SS
1712{
1713 struct internal_syment symbol[1];
1714
1715 read_symbol (symbol, symno);
c5aa993b 1716 return symbol->n_value;
c906108c
SS
1717}
1718
1719
1720/* Find the address of the function corresponding to symno, where
1721 symno is the symbol pointed to by the linetable. */
1722
1723static int
fba45db2 1724read_symbol_lineno (int symno)
c906108c 1725{
5c80ed9d 1726 struct objfile *objfile = this_symtab_objfile;
7af35dad 1727 int xcoff64 = bfd_xcoff_is_xcoff64 (objfile->obfd);
7a78ae4e 1728
b8b98ad1 1729 struct coff_symfile_info *info = XCOFF_DATA (objfile);
7a78ae4e
ND
1730 int nsyms = info->symtbl_num_syms;
1731 char *stbl = info->symtbl;
1732 char *strtbl = info->strtbl;
1733
c906108c
SS
1734 struct internal_syment symbol[1];
1735 union internal_auxent main_aux[1];
1736
1737 if (symno < 0)
1738 {
23136709 1739 bf_notfound_complaint ();
c906108c
SS
1740 return 0;
1741 }
1742
1743 /* Note that just searching for a short distance (e.g. 50 symbols)
1744 is not enough, at least in the following case.
1745
1746 .extern foo
1747 [many .stabx entries]
1748 [a few functions, referring to foo]
1749 .globl foo
1750 .bf
1751
1752 What happens here is that the assembler moves the .stabx entries
1753 to right before the ".bf" for foo, but the symbol for "foo" is before
1754 all the stabx entries. See PR gdb/2222. */
1755
1756 /* Maintaining a table of .bf entries might be preferable to this search.
1757 If I understand things correctly it would need to be done only for
1758 the duration of a single psymtab to symtab conversion. */
1759 while (symno < nsyms)
1760 {
1761 bfd_coff_swap_sym_in (symfile_bfd,
1762 stbl + (symno * local_symesz), symbol);
7a78ae4e
ND
1763 if (symbol->n_sclass == C_FCN)
1764 {
1765 char *name = xcoff64 ? strtbl + symbol->n_offset : symbol->n_name;
a109c7c1 1766
7ecb6532 1767 if (strcmp (name, ".bf") == 0)
7a78ae4e
ND
1768 goto gotit;
1769 }
c906108c
SS
1770 symno += symbol->n_numaux + 1;
1771 }
1772
23136709 1773 bf_notfound_complaint ();
c906108c
SS
1774 return 0;
1775
1776gotit:
581e13c1 1777 /* Take aux entry and return its lineno. */
c906108c 1778 symno++;
7a78ae4e 1779 bfd_coff_swap_aux_in (objfile->obfd, stbl + symno * local_symesz,
c906108c
SS
1780 symbol->n_type, symbol->n_sclass,
1781 0, symbol->n_numaux, main_aux);
1782
1783 return main_aux->x_sym.x_misc.x_lnsz.x_lnno;
1784}
1785
581e13c1 1786/* Support for line number handling. */
c906108c
SS
1787
1788/* This function is called for every section; it finds the outer limits
1789 * of the line table (minimum and maximum file offset) so that the
1790 * mainline code can read the whole thing for efficiency.
1791 */
1792static void
7be0c536 1793find_linenos (struct bfd *abfd, struct bfd_section *asect, void *vpinfo)
c906108c
SS
1794{
1795 struct coff_symfile_info *info;
1796 int size, count;
1797 file_ptr offset, maxoff;
1798
1799 count = asect->lineno_count;
1800
7ecb6532 1801 if (strcmp (asect->name, ".text") != 0 || count == 0)
c906108c
SS
1802 return;
1803
1804 size = count * coff_data (abfd)->local_linesz;
c5aa993b 1805 info = (struct coff_symfile_info *) vpinfo;
c906108c
SS
1806 offset = asect->line_filepos;
1807 maxoff = offset + size;
1808
1809 if (offset < info->min_lineno_offset || info->min_lineno_offset == 0)
1810 info->min_lineno_offset = offset;
1811
1812 if (maxoff > info->max_lineno_offset)
1813 info->max_lineno_offset = maxoff;
1814}
1815\f
c906108c 1816static void
5c80ed9d 1817xcoff_psymtab_to_symtab_1 (struct objfile *objfile, struct partial_symtab *pst)
c906108c
SS
1818{
1819 struct cleanup *old_chain;
1820 int i;
c5aa993b 1821
c906108c
SS
1822 if (!pst)
1823 return;
1824
1825 if (pst->readin)
1826 {
1827 fprintf_unfiltered
1828 (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1829 pst->filename);
1830 return;
1831 }
1832
581e13c1 1833 /* Read in all partial symtabs on which this one is dependent. */
c906108c
SS
1834 for (i = 0; i < pst->number_of_dependencies; i++)
1835 if (!pst->dependencies[i]->readin)
1836 {
1837 /* Inform about additional files that need to be read in. */
1838 if (info_verbose)
1839 {
1840 fputs_filtered (" ", gdb_stdout);
1841 wrap_here ("");
1842 fputs_filtered ("and ", gdb_stdout);
1843 wrap_here ("");
1844 printf_filtered ("%s...", pst->dependencies[i]->filename);
c5aa993b 1845 wrap_here (""); /* Flush output */
c906108c
SS
1846 gdb_flush (gdb_stdout);
1847 }
5c80ed9d 1848 xcoff_psymtab_to_symtab_1 (objfile, pst->dependencies[i]);
c906108c
SS
1849 }
1850
c5aa993b 1851 if (((struct symloc *) pst->read_symtab_private)->numsyms != 0)
c906108c
SS
1852 {
1853 /* Init stuff necessary for reading in symbols. */
1854 stabsread_init ();
1855 buildsym_init ();
a0b3c4fd 1856 old_chain = make_cleanup (really_free_pendings, 0);
c906108c 1857
5c80ed9d 1858 read_xcoff_symtab (objfile, pst);
c906108c
SS
1859
1860 do_cleanups (old_chain);
1861 }
1862
1863 pst->readin = 1;
1864}
1865
c906108c 1866/* Read in all of the symbols for a given psymtab for real.
257e7a09 1867 Be verbose about it if the user wants that. SELF is not NULL. */
c906108c
SS
1868
1869static void
257e7a09 1870xcoff_read_symtab (struct partial_symtab *self, struct objfile *objfile)
c906108c 1871{
257e7a09 1872 if (self->readin)
c906108c
SS
1873 {
1874 fprintf_unfiltered
1875 (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
257e7a09 1876 self->filename);
c906108c
SS
1877 return;
1878 }
1879
257e7a09
YQ
1880 if (((struct symloc *) self->read_symtab_private)->numsyms != 0
1881 || self->number_of_dependencies)
c906108c
SS
1882 {
1883 /* Print the message now, before reading the string table,
c5aa993b 1884 to avoid disconcerting pauses. */
c906108c
SS
1885 if (info_verbose)
1886 {
257e7a09 1887 printf_filtered ("Reading in symbols for %s...", self->filename);
c906108c
SS
1888 gdb_flush (gdb_stdout);
1889 }
1890
c906108c
SS
1891 next_symbol_text_func = xcoff_next_symbol_text;
1892
257e7a09 1893 xcoff_psymtab_to_symtab_1 (objfile, self);
c906108c
SS
1894
1895 /* Match with global symbols. This only needs to be done once,
1896 after all of the symtabs and dependencies have been read in. */
5c80ed9d 1897 scan_file_globals (objfile);
c906108c
SS
1898
1899 /* Finish up the debug error message. */
1900 if (info_verbose)
1901 printf_filtered ("done.\n");
1902 }
1903}
1904\f
1905static void
fba45db2 1906xcoff_new_init (struct objfile *objfile)
c906108c
SS
1907{
1908 stabsread_new_init ();
1909 buildsym_new_init ();
1910}
1911
1912/* Do initialization in preparation for reading symbols from OBJFILE.
c5aa993b 1913
c906108c
SS
1914 We will only be called if this is an XCOFF or XCOFF-like file.
1915 BFD handles figuring out the format of the file, and code in symfile.c
1916 uses BFD's determination to vector to us. */
1917
1918static void
fba45db2 1919xcoff_symfile_init (struct objfile *objfile)
c906108c 1920{
b8b98ad1
TT
1921 struct coff_symfile_info *xcoff;
1922
581e13c1 1923 /* Allocate struct to keep track of the symfile. */
b8b98ad1
TT
1924 xcoff = XNEW (struct coff_symfile_info);
1925 set_objfile_data (objfile, xcoff_objfile_data_key, xcoff);
c906108c
SS
1926
1927 /* XCOFF objects may be reordered, so set OBJF_REORDERED. If we
1928 find this causes a significant slowdown in gdb then we could
1929 set it in the debug symbol readers only when necessary. */
1930 objfile->flags |= OBJF_REORDERED;
c906108c
SS
1931}
1932
1933/* Perform any local cleanups required when we are done with a particular
1934 objfile. I.E, we are in the process of discarding all symbol information
1935 for an objfile, freeing up all memory held for it, and unlinking the
581e13c1 1936 objfile struct from the global list of known objfiles. */
c906108c
SS
1937
1938static void
fba45db2 1939xcoff_symfile_finish (struct objfile *objfile)
c906108c 1940{
c906108c
SS
1941 /* Start with a fresh include table for the next objfile. */
1942 if (inclTable)
1943 {
b8c9b27d 1944 xfree (inclTable);
c906108c
SS
1945 inclTable = NULL;
1946 }
1947 inclIndx = inclLength = inclDepth = 0;
316a8b21
TG
1948
1949 dwarf2_free_objfile (objfile);
c906108c
SS
1950}
1951
1952
1953static void
fba45db2 1954init_stringtab (bfd *abfd, file_ptr offset, struct objfile *objfile)
c906108c
SS
1955{
1956 long length;
1957 int val;
1958 unsigned char lengthbuf[4];
1959 char *strtbl;
b8b98ad1 1960 struct coff_symfile_info *xcoff = XCOFF_DATA (objfile);
c906108c 1961
b8b98ad1 1962 xcoff->strtbl = NULL;
c906108c
SS
1963
1964 if (bfd_seek (abfd, offset, SEEK_SET) < 0)
8a3fe4f8 1965 error (_("cannot seek to string table in %s: %s"),
c906108c
SS
1966 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
1967
3a42e9d0 1968 val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd);
c906108c
SS
1969 length = bfd_h_get_32 (abfd, lengthbuf);
1970
1971 /* If no string table is needed, then the file may end immediately
1972 after the symbols. Just return with `strtbl' set to NULL. */
1973
1974 if (val != sizeof lengthbuf || length < sizeof lengthbuf)
1975 return;
1976
581e13c1
MS
1977 /* Allocate string table from objfile_obstack. We will need this table
1978 as long as we have its symbol table around. */
c906108c 1979
4a146b47 1980 strtbl = (char *) obstack_alloc (&objfile->objfile_obstack, length);
b8b98ad1 1981 xcoff->strtbl = strtbl;
c906108c
SS
1982
1983 /* Copy length buffer, the first byte is usually zero and is
1984 used for stabs with a name length of zero. */
1985 memcpy (strtbl, lengthbuf, sizeof lengthbuf);
1986 if (length == sizeof lengthbuf)
1987 return;
1988
3a42e9d0 1989 val = bfd_bread (strtbl + sizeof lengthbuf, length - sizeof lengthbuf, abfd);
c906108c
SS
1990
1991 if (val != length - sizeof lengthbuf)
8a3fe4f8 1992 error (_("cannot read string table from %s: %s"),
c906108c
SS
1993 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
1994 if (strtbl[length - 1] != '\0')
3e43a32a
MS
1995 error (_("bad symbol file: string table "
1996 "does not end with null character"));
c906108c
SS
1997
1998 return;
1999}
2000\f
2001/* If we have not yet seen a function for this psymtab, this is 0. If we
2002 have seen one, it is the offset in the line numbers of the line numbers
2003 for the psymtab. */
2004static unsigned int first_fun_line_offset;
2005
c906108c
SS
2006/* Allocate and partially fill a partial symtab. It will be
2007 completely filled at the end of the symbol list.
2008
2009 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2010 is the address relative to which its symbols are (incremental) or 0
581e13c1 2011 (normal). */
c906108c
SS
2012
2013static struct partial_symtab *
0d5cff50
DE
2014xcoff_start_psymtab (struct objfile *objfile,
2015 const char *filename, int first_symnum,
fba45db2
KB
2016 struct partial_symbol **global_syms,
2017 struct partial_symbol **static_syms)
c906108c
SS
2018{
2019 struct partial_symtab *result =
18a94d75 2020 start_psymtab_common (objfile,
a109c7c1
MS
2021 filename,
2022 /* We fill in textlow later. */
2023 0,
2024 global_syms, static_syms);
c906108c 2025
e38df1d0
TT
2026 result->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
2027 sizeof (struct symloc));
c5aa993b 2028 ((struct symloc *) result->read_symtab_private)->first_symnum = first_symnum;
257e7a09 2029 result->read_symtab = xcoff_read_symtab;
c906108c 2030
581e13c1 2031 /* Deduce the source language from the filename for this psymtab. */
c906108c
SS
2032 psymtab_language = deduce_language_from_filename (filename);
2033
2034 return result;
2035}
2036
581e13c1 2037/* Close off the current usage of PST.
c906108c
SS
2038 Returns PST, or NULL if the partial symtab was empty and thrown away.
2039
2040 CAPPING_SYMBOL_NUMBER is the end of pst (exclusive).
2041
2042 INCLUDE_LIST, NUM_INCLUDES, DEPENDENCY_LIST, and NUMBER_DEPENDENCIES
2043 are the information for includes and dependencies. */
2044
2045static struct partial_symtab *
5c80ed9d
TT
2046xcoff_end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
2047 const char **include_list, int num_includes,
2048 int capping_symbol_number,
fba45db2
KB
2049 struct partial_symtab **dependency_list,
2050 int number_dependencies, int textlow_not_set)
c906108c
SS
2051{
2052 int i;
c906108c
SS
2053
2054 if (capping_symbol_number != -1)
c5aa993b 2055 ((struct symloc *) pst->read_symtab_private)->numsyms =
c906108c 2056 capping_symbol_number
c5aa993b
JM
2057 - ((struct symloc *) pst->read_symtab_private)->first_symnum;
2058 ((struct symloc *) pst->read_symtab_private)->lineno_off =
c906108c
SS
2059 first_fun_line_offset;
2060 first_fun_line_offset = 0;
8763cede
DE
2061
2062 end_psymtab_common (objfile, pst);
c906108c
SS
2063
2064 pst->number_of_dependencies = number_dependencies;
2065 if (number_dependencies)
2066 {
2067 pst->dependencies = (struct partial_symtab **)
8b92e4d5 2068 obstack_alloc (&objfile->objfile_obstack,
c5aa993b 2069 number_dependencies * sizeof (struct partial_symtab *));
c906108c 2070 memcpy (pst->dependencies, dependency_list,
c5aa993b 2071 number_dependencies * sizeof (struct partial_symtab *));
c906108c
SS
2072 }
2073 else
2074 pst->dependencies = 0;
2075
2076 for (i = 0; i < num_includes; i++)
2077 {
2078 struct partial_symtab *subpst =
a109c7c1 2079 allocate_psymtab (include_list[i], objfile);
c906108c 2080
e38df1d0
TT
2081 subpst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
2082 sizeof (struct symloc));
c5aa993b
JM
2083 ((struct symloc *) subpst->read_symtab_private)->first_symnum = 0;
2084 ((struct symloc *) subpst->read_symtab_private)->numsyms = 0;
c906108c
SS
2085 subpst->textlow = 0;
2086 subpst->texthigh = 0;
2087
2088 /* We could save slight bits of space by only making one of these,
c5aa993b 2089 shared by the entire set of include files. FIXME-someday. */
c906108c 2090 subpst->dependencies = (struct partial_symtab **)
8b92e4d5 2091 obstack_alloc (&objfile->objfile_obstack,
c906108c
SS
2092 sizeof (struct partial_symtab *));
2093 subpst->dependencies[0] = pst;
2094 subpst->number_of_dependencies = 1;
2095
2096 subpst->globals_offset =
2097 subpst->n_global_syms =
c5aa993b
JM
2098 subpst->statics_offset =
2099 subpst->n_static_syms = 0;
c906108c
SS
2100
2101 subpst->readin = 0;
43f3e411 2102 subpst->compunit_symtab = NULL;
c906108c
SS
2103 subpst->read_symtab = pst->read_symtab;
2104 }
2105
c906108c
SS
2106 if (num_includes == 0
2107 && number_dependencies == 0
2108 && pst->n_global_syms == 0
2109 && pst->n_static_syms == 0)
2110 {
2111 /* Throw away this psymtab, it's empty. We can't deallocate it, since
c5aa993b 2112 it is on the obstack, but we can forget to chain it on the list. */
c906108c 2113 /* Empty psymtabs happen as a result of header files which don't have
c5aa993b 2114 any symbols in them. There can be a lot of them. */
c906108c 2115
5c80ed9d 2116 discard_psymtab (objfile, pst);
c906108c
SS
2117
2118 /* Indicate that psymtab was thrown away. */
c5aa993b 2119 pst = (struct partial_symtab *) NULL;
c906108c
SS
2120 }
2121 return pst;
2122}
2123
c906108c
SS
2124/* Swap raw symbol at *RAW and put the name in *NAME, the symbol in
2125 *SYMBOL, the first auxent in *AUX. Advance *RAW and *SYMNUMP over
2126 the symbol and its auxents. */
2127
2128static void
fba45db2 2129swap_sym (struct internal_syment *symbol, union internal_auxent *aux,
0d5cff50 2130 const char **name, char **raw, unsigned int *symnump,
fba45db2 2131 struct objfile *objfile)
c906108c
SS
2132{
2133 bfd_coff_swap_sym_in (objfile->obfd, *raw, symbol);
2134 if (symbol->n_zeroes)
2135 {
2136 /* If it's exactly E_SYMNMLEN characters long it isn't
c5aa993b 2137 '\0'-terminated. */
c906108c
SS
2138 if (symbol->n_name[E_SYMNMLEN - 1] != '\0')
2139 {
2140 /* FIXME: wastes memory for symbols which we don't end up putting
2141 into the minimal symbols. */
2142 char *p;
a109c7c1 2143
8b92e4d5 2144 p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1);
c906108c
SS
2145 strncpy (p, symbol->n_name, E_SYMNMLEN);
2146 p[E_SYMNMLEN] = '\0';
2147 *name = p;
2148 }
2149 else
2150 /* Point to the unswapped name as that persists as long as the
2151 objfile does. */
c5aa993b 2152 *name = ((struct external_syment *) *raw)->e.e_name;
c906108c
SS
2153 }
2154 else if (symbol->n_sclass & 0x80)
2155 {
b8b98ad1 2156 *name = XCOFF_DATA (objfile)->debugsec + symbol->n_offset;
c906108c
SS
2157 }
2158 else
2159 {
b8b98ad1 2160 *name = XCOFF_DATA (objfile)->strtbl + symbol->n_offset;
c906108c
SS
2161 }
2162 ++*symnump;
2163 *raw += coff_data (objfile->obfd)->local_symesz;
2164 if (symbol->n_numaux > 0)
2165 {
2166 bfd_coff_swap_aux_in (objfile->obfd, *raw, symbol->n_type,
2167 symbol->n_sclass, 0, symbol->n_numaux, aux);
2168
2169 *symnump += symbol->n_numaux;
2170 *raw += coff_data (objfile->obfd)->local_symesz * symbol->n_numaux;
2171 }
2172}
2173
23136709
KB
2174static void
2175function_outside_compilation_unit_complaint (const char *arg1)
2176{
2177 complaint (&symfile_complaints,
3e43a32a
MS
2178 _("function `%s' appears to be defined "
2179 "outside of all compilation units"),
23136709
KB
2180 arg1);
2181}
2182
c906108c 2183static void
fba45db2 2184scan_xcoff_symtab (struct objfile *objfile)
c906108c 2185{
40c58d95 2186 struct gdbarch *gdbarch = get_objfile_arch (objfile);
581e13c1 2187 CORE_ADDR toc_offset = 0; /* toc offset value in data section. */
0d5cff50 2188 const char *filestring = NULL;
c906108c 2189
0d5cff50 2190 const char *namestring;
c906108c
SS
2191 int past_first_source_file = 0;
2192 bfd *abfd;
2193 asection *bfd_sect;
2194 unsigned int nsyms;
2195
2196 /* Current partial symtab */
2197 struct partial_symtab *pst;
2198
581e13c1 2199 /* List of current psymtab's include files. */
0d5cff50 2200 const char **psymtab_include_list;
c906108c
SS
2201 int includes_allocated;
2202 int includes_used;
2203
581e13c1 2204 /* Index within current psymtab dependency list. */
c906108c
SS
2205 struct partial_symtab **dependency_list;
2206 int dependencies_used, dependencies_allocated;
2207
2208 char *sraw_symbol;
2209 struct internal_syment symbol;
96baa820 2210 union internal_auxent main_aux[5];
c906108c
SS
2211 unsigned int ssymnum;
2212
0d5cff50 2213 const char *last_csect_name = NULL; /* Last seen csect's name and value. */
c906108c
SS
2214 CORE_ADDR last_csect_val = 0;
2215 int last_csect_sec = 0;
581e13c1 2216 int misc_func_recorded = 0; /* true if any misc. function. */
c906108c
SS
2217 int textlow_not_set = 1;
2218
2219 pst = (struct partial_symtab *) 0;
2220
2221 includes_allocated = 30;
2222 includes_used = 0;
0d5cff50
DE
2223 psymtab_include_list = (const char **) alloca (includes_allocated *
2224 sizeof (const char *));
c906108c
SS
2225
2226 dependencies_allocated = 30;
2227 dependencies_used = 0;
2228 dependency_list =
2229 (struct partial_symtab **) alloca (dependencies_allocated *
2230 sizeof (struct partial_symtab *));
2231
46212e0b 2232 set_last_source_file (NULL);
c906108c
SS
2233
2234 abfd = objfile->obfd;
13c763f4 2235 next_symbol_text_func = xcoff_next_symbol_text;
c906108c 2236
b8b98ad1
TT
2237 sraw_symbol = XCOFF_DATA (objfile)->symtbl;
2238 nsyms = XCOFF_DATA (objfile)->symtbl_num_syms;
c906108c
SS
2239 ssymnum = 0;
2240 while (ssymnum < nsyms)
2241 {
7a78ae4e 2242 int sclass;
c906108c
SS
2243
2244 QUIT;
2245
7a78ae4e
ND
2246 bfd_coff_swap_sym_in (abfd, sraw_symbol, &symbol);
2247 sclass = symbol.n_sclass;
2248
c906108c
SS
2249 switch (sclass)
2250 {
2251 case C_EXT:
2252 case C_HIDEXT:
2253 {
2254 /* The CSECT auxent--always the last auxent. */
2255 union internal_auxent csect_aux;
2256 unsigned int symnum_before = ssymnum;
2257
96baa820 2258 swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
c906108c
SS
2259 &ssymnum, objfile);
2260 if (symbol.n_numaux > 1)
2261 {
2262 bfd_coff_swap_aux_in
2263 (objfile->obfd,
c5aa993b 2264 sraw_symbol - coff_data (abfd)->local_symesz,
c906108c
SS
2265 symbol.n_type,
2266 symbol.n_sclass,
2267 symbol.n_numaux - 1,
2268 symbol.n_numaux,
2269 &csect_aux);
2270 }
2271 else
96baa820 2272 csect_aux = main_aux[0];
c906108c 2273
977adac5
ND
2274 /* If symbol name starts with ".$" or "$", ignore it. */
2275 if (namestring[0] == '$'
c906108c
SS
2276 || (namestring[0] == '.' && namestring[1] == '$'))
2277 break;
2278
2279 switch (csect_aux.x_csect.x_smtyp & 0x7)
2280 {
2281 case XTY_SD:
2282 switch (csect_aux.x_csect.x_smclas)
2283 {
2284 case XMC_PR:
2285 if (last_csect_name)
2286 {
2287 /* If no misc. function recorded in the last
581e13c1 2288 seen csect, enter it as a function. This
c906108c
SS
2289 will take care of functions like strcmp()
2290 compiled by xlc. */
2291
2292 if (!misc_func_recorded)
2293 {
ec92004f 2294 record_minimal_symbol
c906108c 2295 (last_csect_name, last_csect_val,
ec92004f
JB
2296 mst_text, last_csect_sec, objfile);
2297 misc_func_recorded = 1;
c906108c
SS
2298 }
2299
2300 if (pst != NULL)
2301 {
2302 /* We have to allocate one psymtab for
2303 each program csect, because their text
2304 sections need not be adjacent. */
2305 xcoff_end_psymtab
5c80ed9d
TT
2306 (objfile, pst, psymtab_include_list,
2307 includes_used, symnum_before, dependency_list,
c906108c
SS
2308 dependencies_used, textlow_not_set);
2309 includes_used = 0;
2310 dependencies_used = 0;
2311 /* Give all psymtabs for this source file the same
2312 name. */
2313 pst = xcoff_start_psymtab
d4f3574e 2314 (objfile,
c906108c
SS
2315 filestring,
2316 symnum_before,
2317 objfile->global_psymbols.next,
2318 objfile->static_psymbols.next);
2319 }
2320 }
977adac5
ND
2321 /* Activate the misc_func_recorded mechanism for
2322 compiler- and linker-generated CSECTs like ".strcmp"
2323 and "@FIX1". */
2324 if (namestring && (namestring[0] == '.'
2325 || namestring[0] == '@'))
c906108c
SS
2326 {
2327 last_csect_name = namestring;
2328 last_csect_val = symbol.n_value;
ec92004f 2329 last_csect_sec = symbol.n_scnum;
c906108c
SS
2330 }
2331 if (pst != NULL)
2332 {
2333 CORE_ADDR highval =
a109c7c1
MS
2334 symbol.n_value + csect_aux.x_csect.x_scnlen.l;
2335
c906108c
SS
2336 if (highval > pst->texthigh)
2337 pst->texthigh = highval;
2338 if (pst->textlow == 0 || symbol.n_value < pst->textlow)
2339 pst->textlow = symbol.n_value;
2340 }
2341 misc_func_recorded = 0;
2342 break;
2343
2344 case XMC_RW:
6904b546 2345 case XMC_TD:
c906108c
SS
2346 /* Data variables are recorded in the minimal symbol
2347 table, except for section symbols. */
2348 if (*namestring != '.')
4d1eb6b4 2349 record_minimal_symbol
c906108c
SS
2350 (namestring, symbol.n_value,
2351 sclass == C_HIDEXT ? mst_file_data : mst_data,
4d1eb6b4 2352 symbol.n_scnum, objfile);
c906108c
SS
2353 break;
2354
2355 case XMC_TC0:
2356 if (toc_offset)
8a3fe4f8 2357 warning (_("More than one XMC_TC0 symbol found."));
c906108c
SS
2358 toc_offset = symbol.n_value;
2359
3e43a32a
MS
2360 /* Make TOC offset relative to start address of
2361 section. */
c906108c
SS
2362 bfd_sect = secnum_to_bfd_section (symbol.n_scnum, objfile);
2363 if (bfd_sect)
2364 toc_offset -= bfd_section_vma (objfile->obfd, bfd_sect);
2365 break;
2366
2367 case XMC_TC:
2368 /* These symbols tell us where the TOC entry for a
2369 variable is, not the variable itself. */
2370 break;
2371
2372 default:
2373 break;
2374 }
2375 break;
2376
2377 case XTY_LD:
2378 switch (csect_aux.x_csect.x_smclas)
2379 {
2380 case XMC_PR:
2381 /* A function entry point. */
2382
2383 if (first_fun_line_offset == 0 && symbol.n_numaux > 1)
2384 first_fun_line_offset =
96baa820 2385 main_aux[0].x_sym.x_fcnary.x_fcn.x_lnnoptr;
ec92004f
JB
2386 {
2387 record_minimal_symbol
2388 (namestring, symbol.n_value,
2389 sclass == C_HIDEXT ? mst_file_text : mst_text,
2390 symbol.n_scnum, objfile);
2391 misc_func_recorded = 1;
2392 }
c906108c
SS
2393 break;
2394
2395 case XMC_GL:
2396 /* shared library function trampoline code entry
581e13c1 2397 point. */
c906108c
SS
2398
2399 /* record trampoline code entries as
2400 mst_solib_trampoline symbol. When we lookup mst
2401 symbols, we will choose mst_text over
581e13c1 2402 mst_solib_trampoline. */
ec92004f 2403 record_minimal_symbol
c906108c 2404 (namestring, symbol.n_value,
ec92004f
JB
2405 mst_solib_trampoline, symbol.n_scnum, objfile);
2406 misc_func_recorded = 1;
c906108c
SS
2407 break;
2408
2409 case XMC_DS:
2410 /* The symbols often have the same names as
2411 debug symbols for functions, and confuse
2412 lookup_symbol. */
2413 break;
2414
2415 default:
2416
2417 /* xlc puts each variable in a separate csect,
2418 so we get an XTY_SD for each variable. But
2419 gcc puts several variables in a csect, so
2420 that each variable only gets an XTY_LD. We
2421 still need to record them. This will
2422 typically be XMC_RW; I suspect XMC_RO and
2423 XMC_BS might be possible too. */
2424 if (*namestring != '.')
4d1eb6b4 2425 record_minimal_symbol
c906108c
SS
2426 (namestring, symbol.n_value,
2427 sclass == C_HIDEXT ? mst_file_data : mst_data,
4d1eb6b4 2428 symbol.n_scnum, objfile);
c906108c
SS
2429 break;
2430 }
2431 break;
2432
2433 case XTY_CM:
2434 switch (csect_aux.x_csect.x_smclas)
2435 {
2436 case XMC_RW:
2437 case XMC_BS:
2438 /* Common variables are recorded in the minimal symbol
2439 table, except for section symbols. */
2440 if (*namestring != '.')
4d1eb6b4 2441 record_minimal_symbol
c906108c
SS
2442 (namestring, symbol.n_value,
2443 sclass == C_HIDEXT ? mst_file_bss : mst_bss,
4d1eb6b4 2444 symbol.n_scnum, objfile);
c906108c
SS
2445 break;
2446 }
2447 break;
2448
2449 default:
2450 break;
2451 }
2452 }
2453 break;
2454 case C_FILE:
2455 {
2456 unsigned int symnum_before;
2457
2458 symnum_before = ssymnum;
96baa820 2459 swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
c906108c
SS
2460 &ssymnum, objfile);
2461
2462 /* See if the last csect needs to be recorded. */
2463
2464 if (last_csect_name && !misc_func_recorded)
2465 {
c906108c
SS
2466 /* If no misc. function recorded in the last seen csect, enter
2467 it as a function. This will take care of functions like
2468 strcmp() compiled by xlc. */
2469
ec92004f
JB
2470 record_minimal_symbol (last_csect_name, last_csect_val,
2471 mst_text, last_csect_sec, objfile);
2472 misc_func_recorded = 1;
c906108c
SS
2473 }
2474
2475 if (pst)
2476 {
5c80ed9d
TT
2477 xcoff_end_psymtab (objfile, pst, psymtab_include_list,
2478 includes_used, symnum_before,
2479 dependency_list, dependencies_used,
2480 textlow_not_set);
c906108c
SS
2481 includes_used = 0;
2482 dependencies_used = 0;
2483 }
2484 first_fun_line_offset = 0;
2485
2486 /* XCOFF, according to the AIX 3.2 documentation, puts the
2487 filename in cs->c_name. But xlc 1.3.0.2 has decided to
2488 do things the standard COFF way and put it in the auxent.
2489 We use the auxent if the symbol is ".file" and an auxent
2490 exists, otherwise use the symbol itself. */
2491 if (!strcmp (namestring, ".file") && symbol.n_numaux > 0)
2492 {
96baa820 2493 filestring = coff_getfilename (&main_aux[0], objfile);
c906108c
SS
2494 }
2495 else
2496 filestring = namestring;
2497
d4f3574e 2498 pst = xcoff_start_psymtab (objfile,
c906108c
SS
2499 filestring,
2500 symnum_before,
2501 objfile->global_psymbols.next,
2502 objfile->static_psymbols.next);
2503 last_csect_name = NULL;
2504 }
2505 break;
2506
2507 default:
2508 {
23136709 2509 complaint (&symfile_complaints,
3e43a32a
MS
2510 _("Storage class %d not recognized during scan"),
2511 sclass);
c906108c
SS
2512 }
2513 /* FALLTHROUGH */
2514
2515 /* C_FCN is .bf and .ef symbols. I think it is sufficient
2516 to handle only the C_FUN and C_EXT. */
2517 case C_FCN:
2518
2519 case C_BSTAT:
2520 case C_ESTAT:
2521 case C_ARG:
2522 case C_REGPARM:
2523 case C_REG:
2524 case C_TPDEF:
2525 case C_STRTAG:
2526 case C_UNTAG:
2527 case C_ENTAG:
2528 case C_LABEL:
2529 case C_NULL:
2530
2531 /* C_EINCL means we are switching back to the main file. But there
2532 is no reason to care; the only thing we want to know about
2533 includes is the names of all the included (.h) files. */
2534 case C_EINCL:
2535
2536 case C_BLOCK:
2537
2538 /* I don't think C_STAT is used in xcoff; C_HIDEXT appears to be
2539 used instead. */
2540 case C_STAT:
2541
2542 /* I don't think the name of the common block (as opposed to the
2543 variables within it) is something which is user visible
2544 currently. */
2545 case C_BCOMM:
2546 case C_ECOMM:
2547
2548 case C_PSYM:
2549 case C_RPSYM:
2550
2551 /* I think we can ignore C_LSYM; types on xcoff seem to use C_DECL
2552 so C_LSYM would appear to be only for locals. */
2553 case C_LSYM:
2554
2555 case C_AUTO:
2556 case C_RSYM:
2557 {
2558 /* We probably could save a few instructions by assuming that
2559 C_LSYM, C_PSYM, etc., never have auxents. */
7a78ae4e 2560 int naux1 = symbol.n_numaux + 1;
a109c7c1 2561
c906108c 2562 ssymnum += naux1;
7a78ae4e 2563 sraw_symbol += bfd_coff_symesz (abfd) * naux1;
c906108c
SS
2564 }
2565 break;
2566
2567 case C_BINCL:
d5d0a62f 2568 {
581e13c1 2569 /* Mark down an include file in the current psymtab. */
d5d0a62f 2570 enum language tmp_language;
a109c7c1 2571
d5d0a62f
EZ
2572 swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
2573 &ssymnum, objfile);
2574
2575 tmp_language = deduce_language_from_filename (namestring);
2576
2577 /* Only change the psymtab's language if we've learned
2578 something useful (eg. tmp_language is not language_unknown).
2579 In addition, to match what start_subfile does, never change
2580 from C++ to C. */
2581 if (tmp_language != language_unknown
2582 && (tmp_language != language_c
2583 || psymtab_language != language_cplus))
2584 psymtab_language = tmp_language;
2585
2586 /* In C++, one may expect the same filename to come round many
2587 times, when code is coming alternately from the main file
581e13c1 2588 and from inline functions in other files. So I check to see
d5d0a62f
EZ
2589 if this is a file we've seen before -- either the main
2590 source file, or a previously included file.
2591
2592 This seems to be a lot of time to be spending on N_SOL, but
2593 things like "break c-exp.y:435" need to work (I
2594 suppose the psymtab_include_list could be hashed or put
2595 in a binary tree, if profiling shows this is a major hog). */
7ecb6532 2596 if (pst && strcmp (namestring, pst->filename) == 0)
d5d0a62f 2597 continue;
a109c7c1 2598
d5d0a62f 2599 {
aa1ee363 2600 int i;
a109c7c1 2601
d5d0a62f 2602 for (i = 0; i < includes_used; i++)
7ecb6532 2603 if (strcmp (namestring, psymtab_include_list[i]) == 0)
d5d0a62f
EZ
2604 {
2605 i = -1;
2606 break;
2607 }
2608 if (i == -1)
2609 continue;
2610 }
2611 psymtab_include_list[includes_used++] = namestring;
2612 if (includes_used >= includes_allocated)
2613 {
0d5cff50 2614 const char **orig = psymtab_include_list;
c906108c 2615
0d5cff50 2616 psymtab_include_list = (const char **)
d5d0a62f 2617 alloca ((includes_allocated *= 2) *
0d5cff50 2618 sizeof (const char *));
4efb68b1 2619 memcpy (psymtab_include_list, orig,
0d5cff50 2620 includes_used * sizeof (const char *));
d5d0a62f
EZ
2621 }
2622 continue;
2623 }
c906108c
SS
2624 case C_FUN:
2625 /* The value of the C_FUN is not the address of the function (it
2626 appears to be the address before linking), but as long as it
2627 is smaller than the actual address, then find_pc_partial_function
2628 will use the minimal symbols instead. I hope. */
2629
2630 case C_GSYM:
2631 case C_ECOML:
2632 case C_DECL:
2633 case C_STSYM:
d5d0a62f 2634 {
e28566f7 2635 const char *p;
a109c7c1 2636
d5d0a62f
EZ
2637 swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
2638 &ssymnum, objfile);
2639
ed4b0e6a 2640 p = strchr (namestring, ':');
d5d0a62f
EZ
2641 if (!p)
2642 continue; /* Not a debugging symbol. */
2643
2644 /* Main processing section for debugging symbols which
2645 the initial read through the symbol tables needs to worry
2646 about. If we reach this point, the symbol which we are
2647 considering is definitely one we are interested in.
2648 p must also contain the (valid) index into the namestring
2649 which indicates the debugging type symbol. */
2650
2651 switch (p[1])
2652 {
2653 case 'S':
3e43a32a
MS
2654 symbol.n_value += ANOFFSET (objfile->section_offsets,
2655 SECT_OFF_DATA (objfile));
149ad273 2656
5e2b427d 2657 if (gdbarch_static_transform_name_p (gdbarch))
149ad273 2658 namestring = gdbarch_static_transform_name
5e2b427d 2659 (gdbarch, namestring);
149ad273 2660
04a679b8 2661 add_psymbol_to_list (namestring, p - namestring, 1,
176620f1 2662 VAR_DOMAIN, LOC_STATIC,
d5d0a62f 2663 &objfile->static_psymbols,
1762568f 2664 symbol.n_value,
d5d0a62f
EZ
2665 psymtab_language, objfile);
2666 continue;
2667
2668 case 'G':
3e43a32a
MS
2669 symbol.n_value += ANOFFSET (objfile->section_offsets,
2670 SECT_OFF_DATA (objfile));
d5d0a62f 2671 /* The addresses in these entries are reported to be
581e13c1 2672 wrong. See the code that reads 'G's for symtabs. */
04a679b8 2673 add_psymbol_to_list (namestring, p - namestring, 1,
176620f1 2674 VAR_DOMAIN, LOC_STATIC,
d5d0a62f 2675 &objfile->global_psymbols,
1762568f 2676 symbol.n_value,
d5d0a62f
EZ
2677 psymtab_language, objfile);
2678 continue;
2679
2680 case 'T':
2681 /* When a 'T' entry is defining an anonymous enum, it
2682 may have a name which is the empty string, or a
2683 single space. Since they're not really defining a
2684 symbol, those shouldn't go in the partial symbol
2685 table. We do pick up the elements of such enums at
2686 'check_enum:', below. */
2687 if (p >= namestring + 2
2688 || (p == namestring + 1
2689 && namestring[0] != ' '))
2690 {
04a679b8 2691 add_psymbol_to_list (namestring, p - namestring, 1,
176620f1 2692 STRUCT_DOMAIN, LOC_TYPEDEF,
d5d0a62f 2693 &objfile->static_psymbols,
1762568f 2694 0, psymtab_language, objfile);
d5d0a62f
EZ
2695 if (p[2] == 't')
2696 {
2697 /* Also a typedef with the same name. */
04a679b8 2698 add_psymbol_to_list (namestring, p - namestring, 1,
176620f1 2699 VAR_DOMAIN, LOC_TYPEDEF,
d5d0a62f 2700 &objfile->static_psymbols,
1762568f 2701 0, psymtab_language, objfile);
d5d0a62f
EZ
2702 p += 1;
2703 }
d5d0a62f
EZ
2704 }
2705 goto check_enum;
2706
2707 case 't':
581e13c1 2708 if (p != namestring) /* a name is there, not just :T... */
d5d0a62f 2709 {
04a679b8 2710 add_psymbol_to_list (namestring, p - namestring, 1,
176620f1 2711 VAR_DOMAIN, LOC_TYPEDEF,
d5d0a62f 2712 &objfile->static_psymbols,
1762568f 2713 0, psymtab_language, objfile);
d5d0a62f
EZ
2714 }
2715 check_enum:
2716 /* If this is an enumerated type, we need to
2717 add all the enum constants to the partial symbol
2718 table. This does not cover enums without names, e.g.
2719 "enum {a, b} c;" in C, but fortunately those are
2720 rare. There is no way for GDB to find those from the
2721 enum type without spending too much time on it. Thus
2722 to solve this problem, the compiler needs to put out the
2723 enum in a nameless type. GCC2 does this. */
2724
2725 /* We are looking for something of the form
2726 <name> ":" ("t" | "T") [<number> "="] "e"
2727 {<constant> ":" <value> ","} ";". */
2728
2729 /* Skip over the colon and the 't' or 'T'. */
2730 p += 2;
2731 /* This type may be given a number. Also, numbers can come
2732 in pairs like (0,26). Skip over it. */
2733 while ((*p >= '0' && *p <= '9')
2734 || *p == '(' || *p == ',' || *p == ')'
2735 || *p == '=')
2736 p++;
2737
2738 if (*p++ == 'e')
2739 {
3e43a32a
MS
2740 /* The aix4 compiler emits extra crud before the
2741 members. */
d5d0a62f
EZ
2742 if (*p == '-')
2743 {
2744 /* Skip over the type (?). */
2745 while (*p != ':')
2746 p++;
2747
2748 /* Skip over the colon. */
2749 p++;
2750 }
2751
2752 /* We have found an enumerated type. */
2753 /* According to comments in read_enum_type
2754 a comma could end it instead of a semicolon.
2755 I don't know where that happens.
2756 Accept either. */
2757 while (*p && *p != ';' && *p != ',')
2758 {
e28566f7 2759 const char *q;
d5d0a62f
EZ
2760
2761 /* Check for and handle cretinous dbx symbol name
2762 continuation! */
2763 if (*p == '\\' || (*p == '?' && p[1] == '\0'))
2764 p = next_symbol_text (objfile);
2765
2766 /* Point to the character after the name
2767 of the enum constant. */
2768 for (q = p; *q && *q != ':'; q++)
2769 ;
2770 /* Note that the value doesn't matter for
2771 enum constants in psymtabs, just in symtabs. */
04a679b8 2772 add_psymbol_to_list (p, q - p, 1,
176620f1 2773 VAR_DOMAIN, LOC_CONST,
1762568f 2774 &objfile->static_psymbols,
d5d0a62f
EZ
2775 0, psymtab_language, objfile);
2776 /* Point past the name. */
2777 p = q;
2778 /* Skip over the value. */
2779 while (*p && *p != ',')
2780 p++;
2781 /* Advance past the comma. */
2782 if (*p)
2783 p++;
2784 }
2785 }
2786 continue;
2787
2788 case 'c':
2789 /* Constant, e.g. from "const" in Pascal. */
04a679b8 2790 add_psymbol_to_list (namestring, p - namestring, 1,
176620f1 2791 VAR_DOMAIN, LOC_CONST,
1762568f 2792 &objfile->static_psymbols,
d5d0a62f
EZ
2793 0, psymtab_language, objfile);
2794 continue;
2795
2796 case 'f':
2797 if (! pst)
2798 {
2799 int name_len = p - namestring;
2800 char *name = xmalloc (name_len + 1);
a109c7c1 2801
d5d0a62f
EZ
2802 memcpy (name, namestring, name_len);
2803 name[name_len] = '\0';
23136709 2804 function_outside_compilation_unit_complaint (name);
d5d0a62f
EZ
2805 xfree (name);
2806 }
3e43a32a
MS
2807 symbol.n_value += ANOFFSET (objfile->section_offsets,
2808 SECT_OFF_TEXT (objfile));
04a679b8 2809 add_psymbol_to_list (namestring, p - namestring, 1,
176620f1 2810 VAR_DOMAIN, LOC_BLOCK,
d5d0a62f 2811 &objfile->static_psymbols,
1762568f 2812 symbol.n_value,
d5d0a62f
EZ
2813 psymtab_language, objfile);
2814 continue;
2815
2816 /* Global functions were ignored here, but now they
2817 are put into the global psymtab like one would expect.
2818 They're also in the minimal symbol table. */
2819 case 'F':
2820 if (! pst)
2821 {
2822 int name_len = p - namestring;
2823 char *name = xmalloc (name_len + 1);
a109c7c1 2824
d5d0a62f
EZ
2825 memcpy (name, namestring, name_len);
2826 name[name_len] = '\0';
23136709 2827 function_outside_compilation_unit_complaint (name);
d5d0a62f
EZ
2828 xfree (name);
2829 }
9f1d5432
PH
2830
2831 /* We need only the minimal symbols for these
581e13c1 2832 loader-generated definitions. Keeping the global
9f1d5432 2833 symbols leads to "in psymbols but not in symbols"
581e13c1 2834 errors. */
61012eef 2835 if (startswith (namestring, "@FIX"))
9f1d5432
PH
2836 continue;
2837
3e43a32a
MS
2838 symbol.n_value += ANOFFSET (objfile->section_offsets,
2839 SECT_OFF_TEXT (objfile));
04a679b8 2840 add_psymbol_to_list (namestring, p - namestring, 1,
176620f1 2841 VAR_DOMAIN, LOC_BLOCK,
d5d0a62f 2842 &objfile->global_psymbols,
1762568f 2843 symbol.n_value,
d5d0a62f
EZ
2844 psymtab_language, objfile);
2845 continue;
2846
2847 /* Two things show up here (hopefully); static symbols of
2848 local scope (static used inside braces) or extensions
2849 of structure symbols. We can ignore both. */
2850 case 'V':
2851 case '(':
2852 case '0':
2853 case '1':
2854 case '2':
2855 case '3':
2856 case '4':
2857 case '5':
2858 case '6':
2859 case '7':
2860 case '8':
2861 case '9':
2862 case '-':
3e43a32a
MS
2863 case '#': /* For symbol identification (used in
2864 live ranges). */
d5d0a62f
EZ
2865 continue;
2866
2867 case ':':
2868 /* It is a C++ nested symbol. We don't need to record it
2869 (I don't think); if we try to look up foo::bar::baz,
2870 then symbols for the symtab containing foo should get
2871 read in, I think. */
2872 /* Someone says sun cc puts out symbols like
2873 /foo/baz/maclib::/usr/local/bin/maclib,
2874 which would get here with a symbol type of ':'. */
2875 continue;
2876
2877 default:
3e43a32a
MS
2878 /* Unexpected symbol descriptor. The second and
2879 subsequent stabs of a continued stab can show up
2880 here. The question is whether they ever can mimic
2881 a normal stab--it would be nice if not, since we
2882 certainly don't want to spend the time searching to
2883 the end of every string looking for a
2884 backslash. */
d5d0a62f 2885
23136709 2886 complaint (&symfile_complaints,
e2e0b3e5 2887 _("unknown symbol descriptor `%c'"), p[1]);
d5d0a62f
EZ
2888
2889 /* Ignore it; perhaps it is an extension that we don't
2890 know about. */
2891 continue;
2892 }
2893 }
c906108c
SS
2894 }
2895 }
2896
2897 if (pst)
2898 {
5c80ed9d 2899 xcoff_end_psymtab (objfile, pst, psymtab_include_list, includes_used,
c906108c
SS
2900 ssymnum, dependency_list,
2901 dependencies_used, textlow_not_set);
2902 }
2903
581e13c1
MS
2904 /* Record the toc offset value of this symbol table into objfile
2905 structure. If no XMC_TC0 is found, toc_offset should be zero.
2906 Another place to obtain this information would be file auxiliary
2907 header. */
c906108c 2908
b8b98ad1 2909 XCOFF_DATA (objfile)->toc_offset = toc_offset;
c906108c
SS
2910}
2911
2912/* Return the toc offset value for a given objfile. */
2913
2914CORE_ADDR
63807e1d 2915xcoff_get_toc_offset (struct objfile *objfile)
c906108c
SS
2916{
2917 if (objfile)
b8b98ad1 2918 return XCOFF_DATA (objfile)->toc_offset;
c906108c
SS
2919 return 0;
2920}
2921
2922/* Scan and build partial symbols for a symbol file.
2923 We have been initialized by a call to dbx_symfile_init, which
2924 put all the relevant info into a "struct dbx_symfile_info",
2925 hung off the objfile structure.
2926
2927 SECTION_OFFSETS contains offsets relative to which the symbols in the
581e13c1
MS
2928 various sections are (depending where the sections were actually
2929 loaded). */
c906108c
SS
2930
2931static void
f4352531 2932xcoff_initial_scan (struct objfile *objfile, int symfile_flags)
c906108c
SS
2933{
2934 bfd *abfd;
2935 int val;
2936 struct cleanup *back_to;
c5aa993b
JM
2937 int num_symbols; /* # of symbols */
2938 file_ptr symtab_offset; /* symbol table and */
2939 file_ptr stringtab_offset; /* string table file offsets */
c906108c 2940 struct coff_symfile_info *info;
4262abfb 2941 const char *name;
c906108c
SS
2942 unsigned int size;
2943
b8b98ad1 2944 info = XCOFF_DATA (objfile);
c906108c 2945 symfile_bfd = abfd = objfile->obfd;
4262abfb 2946 name = objfile_name (objfile);
c906108c
SS
2947
2948 num_symbols = bfd_get_symcount (abfd); /* # of symbols */
2949 symtab_offset = obj_sym_filepos (abfd); /* symbol table file offset */
2950 stringtab_offset = symtab_offset +
c5aa993b 2951 num_symbols * coff_data (abfd)->local_symesz;
c906108c
SS
2952
2953 info->min_lineno_offset = 0;
2954 info->max_lineno_offset = 0;
2955 bfd_map_over_sections (abfd, find_linenos, info);
2956
2957 if (num_symbols > 0)
2958 {
2959 /* Read the string table. */
2960 init_stringtab (abfd, stringtab_offset, objfile);
2961
2962 /* Read the .debug section, if present. */
2963 {
7be0c536 2964 struct bfd_section *secp;
c906108c 2965 bfd_size_type length;
ea9f10bb 2966 bfd_byte *debugsec = NULL;
c906108c
SS
2967
2968 secp = bfd_get_section_by_name (abfd, ".debug");
2969 if (secp)
2970 {
2971 length = bfd_section_size (abfd, secp);
2972 if (length)
2973 {
ea9f10bb 2974 debugsec = obstack_alloc (&objfile->objfile_obstack, length);
c906108c 2975
ea9f10bb 2976 if (!bfd_get_full_section_contents (abfd, secp, &debugsec))
c906108c 2977 {
8a3fe4f8 2978 error (_("Error reading .debug section of `%s': %s"),
c906108c
SS
2979 name, bfd_errmsg (bfd_get_error ()));
2980 }
2981 }
2982 }
745eb4fd 2983 info->debugsec = (char *) debugsec;
c906108c
SS
2984 }
2985 }
2986
2987 /* Read the symbols. We keep them in core because we will want to
2988 access them randomly in read_symbol*. */
2989 val = bfd_seek (abfd, symtab_offset, SEEK_SET);
2990 if (val < 0)
8a3fe4f8 2991 error (_("Error reading symbols from %s: %s"),
c906108c
SS
2992 name, bfd_errmsg (bfd_get_error ()));
2993 size = coff_data (abfd)->local_symesz * num_symbols;
b8b98ad1
TT
2994 info->symtbl = obstack_alloc (&objfile->objfile_obstack, size);
2995 info->symtbl_num_syms = num_symbols;
2996
2997 val = bfd_bread (info->symtbl, size, abfd);
c906108c 2998 if (val != size)
e2e0b3e5 2999 perror_with_name (_("reading symbol table"));
c906108c 3000
581e13c1 3001 /* If we are reinitializing, or if we have never loaded syms yet, init. */
de1d8fb9 3002 if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
c906108c
SS
3003 /* I'm not sure how how good num_symbols is; the rule of thumb in
3004 init_psymbol_list was developed for a.out. On the one hand,
3005 num_symbols includes auxents. On the other hand, it doesn't
3006 include N_SLINE. */
3007 init_psymbol_list (objfile, num_symbols);
3008
3009 free_pending_blocks ();
a0b3c4fd 3010 back_to = make_cleanup (really_free_pendings, 0);
c906108c
SS
3011
3012 init_minimal_symbol_collection ();
56e290f4 3013 make_cleanup_discard_minimal_symbols ();
c906108c
SS
3014
3015 /* Now that the symbol table data of the executable file are all in core,
3016 process them and define symbols accordingly. */
3017
d4f3574e 3018 scan_xcoff_symtab (objfile);
c906108c
SS
3019
3020 /* Install any minimal symbols that have been collected as the current
581e13c1 3021 minimal symbols for this objfile. */
c906108c
SS
3022
3023 install_minimal_symbols (objfile);
3024
316a8b21
TG
3025 /* DWARF2 sections. */
3026
3027 if (dwarf2_has_info (objfile, &dwarf2_xcoff_names))
3028 dwarf2_build_psymtabs (objfile);
3029
3030 dwarf2_build_frame_info (objfile);
3031
c906108c
SS
3032 do_cleanups (back_to);
3033}
3034\f
d4f3574e 3035static void
3e43a32a 3036xcoff_symfile_offsets (struct objfile *objfile,
66f65e2b 3037 const struct section_addr_info *addrs)
c906108c 3038{
4d1eb6b4 3039 const char *first_section_name;
c906108c 3040
4d1eb6b4 3041 default_symfile_offsets (objfile, addrs);
c906108c 3042
4d1eb6b4
JB
3043 /* Oneof the weird side-effects of default_symfile_offsets is that
3044 it sometimes sets some section indices to zero for sections that,
3045 in fact do not exist. See the body of default_symfile_offsets
3046 for more info on when that happens. Undo that, as this then allows
3047 us to test whether the associated section exists or not, and then
3048 access it quickly (without searching it again). */
b8fbeb18 3049
4d1eb6b4
JB
3050 if (objfile->num_sections == 0)
3051 return; /* Is that even possible? Better safe than sorry. */
b8fbeb18 3052
4d1eb6b4
JB
3053 first_section_name
3054 = bfd_section_name (objfile->obfd, objfile->sections[0].the_bfd_section);
b8fbeb18 3055
4d1eb6b4
JB
3056 if (objfile->sect_index_text == 0
3057 && strcmp (first_section_name, ".text") != 0)
3058 objfile->sect_index_text = -1;
b8fbeb18 3059
4d1eb6b4
JB
3060 if (objfile->sect_index_data == 0
3061 && strcmp (first_section_name, ".data") != 0)
3062 objfile->sect_index_data = -1;
3063
3064 if (objfile->sect_index_bss == 0
3065 && strcmp (first_section_name, ".bss") != 0)
3066 objfile->sect_index_bss = -1;
3067
3068 if (objfile->sect_index_rodata == 0
3069 && strcmp (first_section_name, ".rodata") != 0)
3070 objfile->sect_index_rodata = -1;
c906108c
SS
3071}
3072
3073/* Register our ability to parse symbols for xcoff BFD files. */
3074
00b5771c 3075static const struct sym_fns xcoff_sym_fns =
c906108c
SS
3076{
3077
7a78ae4e 3078 /* It is possible that coff and xcoff should be merged as
c906108c
SS
3079 they do have fundamental similarities (for example, the extra storage
3080 classes used for stabs could presumably be recognized in any COFF file).
3081 However, in addition to obvious things like all the csect hair, there are
3082 some subtler differences between xcoffread.c and coffread.c, notably
3083 the fact that coffread.c has no need to read in all the symbols, but
3084 xcoffread.c reads all the symbols and does in fact randomly access them
3085 (in C_BSTAT and line number processing). */
3086
3e43a32a
MS
3087 xcoff_new_init, /* init anything gbl to entire symtab */
3088 xcoff_symfile_init, /* read initial info, setup for sym_read() */
3089 xcoff_initial_scan, /* read a symbol file into symtab */
b11896a5 3090 NULL, /* sym_read_psymbols */
3e43a32a
MS
3091 xcoff_symfile_finish, /* finished with file, cleanup */
3092 xcoff_symfile_offsets, /* xlate offsets ext->int form */
3093 default_symfile_segments, /* Get segment information from a file. */
3094 aix_process_linenos,
3095 default_symfile_relocate, /* Relocate a debug section. */
55aa24fb 3096 NULL, /* sym_probe_fns */
00b5771c 3097 &psym_functions
c906108c
SS
3098};
3099
d5367fe1
JB
3100/* Same as xcoff_get_n_import_files, but for core files. */
3101
3102static int
3103xcoff_get_core_n_import_files (bfd *abfd)
3104{
3105 asection *sect = bfd_get_section_by_name (abfd, ".ldinfo");
3106 gdb_byte buf[4];
3107 file_ptr offset = 0;
3108 int n_entries = 0;
3109
3110 if (sect == NULL)
3111 return -1; /* Not a core file. */
3112
3113 for (offset = 0; offset < bfd_get_section_size (sect);)
3114 {
3115 int next;
3116
3117 n_entries++;
3118
3119 if (!bfd_get_section_contents (abfd, sect, buf, offset, 4))
3120 return -1;
3121 next = bfd_get_32 (abfd, buf);
3122 if (next == 0)
3123 break; /* This is the last entry. */
3124 offset += next;
3125 }
3126
3127 /* Return the number of entries, excluding the first one, which is
3128 the path to the executable that produced this core file. */
3129 return n_entries - 1;
3130}
3131
3132/* Return the number of import files (shared libraries) that the given
3133 BFD depends on. Return -1 if this number could not be computed. */
3134
3135int
3136xcoff_get_n_import_files (bfd *abfd)
3137{
3138 asection *sect = bfd_get_section_by_name (abfd, ".loader");
3139 gdb_byte buf[4];
3140 int l_nimpid;
3141
3142 /* If the ".loader" section does not exist, the objfile is probably
3143 not an executable. Might be a core file... */
3144 if (sect == NULL)
3145 return xcoff_get_core_n_import_files (abfd);
3146
3147 /* The number of entries in the Import Files Table is stored in
3148 field l_nimpid. This field is always at offset 16, and is
3149 always 4 bytes long. Read those 4 bytes. */
3150
3151 if (!bfd_get_section_contents (abfd, sect, buf, 16, 4))
3152 return -1;
3153 l_nimpid = bfd_get_32 (abfd, buf);
3154
3155 /* By convention, the first entry is the default LIBPATH value
3156 to be used by the system loader, so it does not count towards
3157 the number of import files. */
3158 return l_nimpid - 1;
3159}
3160
b8b98ad1
TT
3161/* Free the per-objfile xcoff data. */
3162
3163static void
3164xcoff_free_info (struct objfile *objfile, void *arg)
3165{
3166 xfree (arg);
3167}
3168
63807e1d
PA
3169/* Provide a prototype to silence -Wmissing-prototypes. */
3170extern initialize_file_ftype _initialize_xcoffread;
3171
c906108c 3172void
fba45db2 3173_initialize_xcoffread (void)
c906108c 3174{
c256e171 3175 add_symtab_fns (bfd_target_xcoff_flavour, &xcoff_sym_fns);
b8b98ad1
TT
3176
3177 xcoff_objfile_data_key = register_objfile_data_with_cleanup (NULL,
3178 xcoff_free_info);
c906108c 3179}
This page took 2.925399 seconds and 4 git commands to generate.