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