GDB (xrefs)

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