1 /* Read AIX xcoff symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1986-2020 Free Software Foundation, Inc.
3 Derived from coffread.c, dbxread.c, and a lot of hacking.
4 Contributed by IBM Corporation.
6 This file is part of GDB.
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.
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.
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/>. */
24 #include <sys/types.h>
27 #ifdef HAVE_SYS_FILE_H
33 #include "coff/internal.h"
34 #include "libcoff.h" /* FIXME, internal data from BFD */
35 #include "coff/xcoff.h"
37 #include "coff/rs6000.h"
38 #include "xcoffread.h"
42 /* FIXME: ezannoni/2004-02-13 Verify if the include below is really needed. */
45 #include "buildsym-legacy.h"
46 #include "stabsread.h"
47 #include "expression.h"
48 #include "complaints.h"
51 #include "gdb-stabs.h"
53 /* For interface with stabsread.c. */
54 #include "aout/stab_gnu.h"
57 /* We put a pointer to this structure in the read_symtab_private field
63 /* First symbol number for this file. */
67 /* Number of symbols in the section of the symbol table devoted to
68 this file's symbols (actually, the section bracketed may contain
69 more than just this file's symbols). If numsyms is 0, the only
70 reason for this thing's existence is the dependency list. Nothing
71 else will happen when it is read in. */
75 /* Position of the start of the line number information for this
77 unsigned int lineno_off
;
80 /* Remember what we deduced to be the source language of this psymtab. */
82 static enum language psymtab_language
= language_unknown
;
85 /* Simplified internal version of coff symbol table information. */
90 int c_symnum
; /* Symbol number of this entry. */
91 int c_naux
; /* 0 if syment only, 1 if syment + auxent. */
93 unsigned char c_sclass
;
98 /* Last function's saved coff symbol `cs'. */
100 static struct coff_symbol fcn_cs_saved
;
102 static bfd
*symfile_bfd
;
104 /* Core address of start and end of text of current source file.
105 This is calculated from the first function seen after a C_FILE
109 static CORE_ADDR cur_src_end_addr
;
111 /* Core address of the end of the first object file. */
113 static CORE_ADDR first_object_file_end
;
115 /* Initial symbol-table-debug-string vector length. */
117 #define INITIAL_STABVECTOR_LENGTH 40
119 /* Size of a COFF symbol. I think it is always 18, so I'm not sure
120 there is any reason not to just use a #define, but might as well
121 ask BFD for the size and store it here, I guess. */
123 static unsigned local_symesz
;
125 struct xcoff_symfile_info
127 file_ptr min_lineno_offset
{}; /* Where in file lowest line#s are. */
128 file_ptr max_lineno_offset
{}; /* 1+last byte of line#s in file. */
130 /* Pointer to the string table. */
131 char *strtbl
= nullptr;
133 /* Pointer to debug section. */
134 char *debugsec
= nullptr;
136 /* Pointer to the a.out symbol table. */
137 char *symtbl
= nullptr;
139 /* Number of symbols in symtbl. */
140 int symtbl_num_syms
= 0;
142 /* Offset in data section to TOC anchor. */
143 CORE_ADDR toc_offset
= 0;
146 /* Key for XCOFF-associated data. */
148 static const struct objfile_key
<xcoff_symfile_info
> xcoff_objfile_data_key
;
150 /* Convenience macro to access the per-objfile XCOFF data. */
152 #define XCOFF_DATA(objfile) \
153 xcoff_objfile_data_key.get (objfile)
155 /* XCOFF names for dwarf sections. There is no compressed sections. */
157 static const struct dwarf2_debug_sections dwarf2_xcoff_names
= {
159 { ".dwabrev", NULL
},
162 { NULL
, NULL
}, /* debug_loclists */
163 /* AIX XCOFF defines one, named DWARF section for macro debug information.
164 XLC does not generate debug_macinfo for DWARF4 and below.
165 The section is assigned to debug_macro for DWARF5 and above. */
169 { NULL
, NULL
}, /* debug_line_str */
170 { ".dwrnges", NULL
},
171 { NULL
, NULL
}, /* debug_rnglists */
172 { ".dwpbtyp", NULL
},
173 { NULL
, NULL
}, /* debug_addr */
174 { ".dwframe", NULL
},
175 { NULL
, NULL
}, /* eh_frame */
176 { NULL
, NULL
}, /* gdb_index */
177 { NULL
, NULL
}, /* debug_names */
178 { NULL
, NULL
}, /* debug_aranges */
183 bf_notfound_complaint (void)
185 complaint (_("line numbers off, `.bf' symbol not found"));
189 ef_complaint (int arg1
)
191 complaint (_("Mismatched .ef symbol ignored starting at symnum %d"), arg1
);
195 eb_complaint (int arg1
)
197 complaint (_("Mismatched .eb symbol ignored starting at symnum %d"), arg1
);
200 static void xcoff_initial_scan (struct objfile
*, symfile_add_flags
);
202 static void scan_xcoff_symtab (minimal_symbol_reader
&,
205 static const char *xcoff_next_symbol_text (struct objfile
*);
207 static void record_include_begin (struct coff_symbol
*);
210 enter_line_range (struct subfile
*, unsigned, unsigned,
211 CORE_ADDR
, CORE_ADDR
, unsigned *);
213 static void init_stringtab (bfd
*, file_ptr
, struct objfile
*);
215 static void xcoff_symfile_init (struct objfile
*);
217 static void xcoff_new_init (struct objfile
*);
219 static void xcoff_symfile_finish (struct objfile
*);
221 static char *coff_getfilename (union internal_auxent
*, struct objfile
*);
223 static void read_symbol (struct internal_syment
*, int);
225 static int read_symbol_lineno (int);
227 static CORE_ADDR
read_symbol_nvalue (int);
229 static struct symbol
*process_xcoff_symbol (struct coff_symbol
*,
232 static void read_xcoff_symtab (struct objfile
*, struct partial_symtab
*);
235 static void add_stab_to_list (char *, struct pending_stabs
**);
238 static struct linetable
*arrange_linetable (struct linetable
*);
240 static void record_include_end (struct coff_symbol
*);
242 static void process_linenos (CORE_ADDR
, CORE_ADDR
);
245 /* Translate from a COFF section number (target_index) to a SECT_OFF_*
247 static int secnum_to_section (int, struct objfile
*);
248 static asection
*secnum_to_bfd_section (int, struct objfile
*);
250 struct find_targ_sec_arg
255 struct objfile
*objfile
;
258 static void find_targ_sec (bfd
*, asection
*, void *);
261 find_targ_sec (bfd
*abfd
, asection
*sect
, void *obj
)
263 struct find_targ_sec_arg
*args
= (struct find_targ_sec_arg
*) obj
;
264 struct objfile
*objfile
= args
->objfile
;
266 if (sect
->target_index
== args
->targ_index
)
268 /* This is the section. Figure out what SECT_OFF_* code it is. */
269 if (bfd_section_flags (sect
) & SEC_CODE
)
270 *args
->resultp
= SECT_OFF_TEXT (objfile
);
271 else if (bfd_section_flags (sect
) & SEC_LOAD
)
272 *args
->resultp
= SECT_OFF_DATA (objfile
);
274 *args
->resultp
= gdb_bfd_section_index (abfd
, sect
);
275 *args
->bfd_sect
= sect
;
279 /* Search all BFD sections for the section whose target_index is
280 equal to N_SCNUM. Set *BFD_SECT to that section. The section's
281 associated index in the objfile's section_offset table is also
284 If no match is found, *BFD_SECT is set to NULL, and *SECNUM
285 is set to the text section's number. */
288 xcoff_secnum_to_sections (int n_scnum
, struct objfile
*objfile
,
289 asection
**bfd_sect
, int *secnum
)
291 struct find_targ_sec_arg args
;
293 args
.targ_index
= n_scnum
;
294 args
.resultp
= secnum
;
295 args
.bfd_sect
= bfd_sect
;
296 args
.objfile
= objfile
;
299 *secnum
= SECT_OFF_TEXT (objfile
);
301 bfd_map_over_sections (objfile
->obfd
, find_targ_sec
, &args
);
304 /* Return the section number (SECT_OFF_*) that N_SCNUM points to. */
307 secnum_to_section (int n_scnum
, struct objfile
*objfile
)
312 xcoff_secnum_to_sections (n_scnum
, objfile
, &ignored
, &secnum
);
316 /* Return the BFD section that N_SCNUM points to. */
319 secnum_to_bfd_section (int n_scnum
, struct objfile
*objfile
)
324 xcoff_secnum_to_sections (n_scnum
, objfile
, &bfd_sect
, &ignored
);
328 /* add a given stab string into given stab vector. */
333 add_stab_to_list (char *stabname
, struct pending_stabs
**stabvector
)
335 if (*stabvector
== NULL
)
337 *stabvector
= (struct pending_stabs
*)
338 xmalloc (sizeof (struct pending_stabs
) +
339 INITIAL_STABVECTOR_LENGTH
* sizeof (char *));
340 (*stabvector
)->count
= 0;
341 (*stabvector
)->length
= INITIAL_STABVECTOR_LENGTH
;
343 else if ((*stabvector
)->count
>= (*stabvector
)->length
)
345 (*stabvector
)->length
+= INITIAL_STABVECTOR_LENGTH
;
346 *stabvector
= (struct pending_stabs
*)
347 xrealloc ((char *) *stabvector
, sizeof (struct pending_stabs
) +
348 (*stabvector
)->length
* sizeof (char *));
350 (*stabvector
)->stab
[(*stabvector
)->count
++] = stabname
;
355 /* Linenos are processed on a file-by-file basis.
359 1) xlc (IBM's native c compiler) postpones static function code
360 emission to the end of a compilation unit. This way it can
361 determine if those functions (statics) are needed or not, and
362 can do some garbage collection (I think). This makes line
363 numbers and corresponding addresses unordered, and we end up
364 with a line table like:
381 and that breaks gdb's binary search on line numbers, if the
382 above table is not sorted on line numbers. And that sort
383 should be on function based, since gcc can emit line numbers
386 10 0x100 - for the init/test part of a for stmt.
389 10 0x400 - for the increment part of a for stmt.
391 arrange_linetable() will do this sorting.
393 2) aix symbol table might look like:
395 c_file // beginning of a new file
396 .bi // beginning of include file
397 .ei // end of include file
401 basically, .bi/.ei pairs do not necessarily encapsulate
402 their scope. They need to be recorded, and processed later
403 on when we come the end of the compilation unit.
404 Include table (inclTable) and process_linenos() handle
409 /* Given a line table with function entries are marked, arrange its
410 functions in ascending order and strip off function entry markers
411 and return it in a newly created table. If the old one is good
412 enough, return the old one. */
413 /* FIXME: I think all this stuff can be replaced by just passing
414 sort_linevec = 1 to end_symtab. */
416 static struct linetable
*
417 arrange_linetable (struct linetable
*oldLineTb
)
419 int ii
, jj
, newline
, /* new line count */
420 function_count
; /* # of functions */
422 struct linetable_entry
*fentry
; /* function entry vector */
423 int fentry_size
; /* # of function entries */
424 struct linetable
*newLineTb
; /* new line table */
427 #define NUM_OF_FUNCTIONS 20
429 fentry_size
= NUM_OF_FUNCTIONS
;
430 fentry
= XNEWVEC (struct linetable_entry
, fentry_size
);
432 for (function_count
= 0, ii
= 0; ii
< oldLineTb
->nitems
; ++ii
)
434 if (oldLineTb
->item
[ii
].line
== 0)
435 { /* Function entry found. */
436 if (function_count
>= fentry_size
)
437 { /* Make sure you have room. */
439 fentry
= (struct linetable_entry
*)
441 fentry_size
* sizeof (struct linetable_entry
));
443 fentry
[function_count
].line
= ii
;
444 fentry
[function_count
].pc
= oldLineTb
->item
[ii
].pc
;
447 /* If the function was compiled with XLC, we may have to add an
448 extra line entry later. Reserve space for that. */
449 if (ii
+ 1 < oldLineTb
->nitems
450 && oldLineTb
->item
[ii
].pc
!= oldLineTb
->item
[ii
+ 1].pc
)
455 if (function_count
== 0)
460 else if (function_count
> 1)
461 std::sort (fentry
, fentry
+ function_count
,
462 [] (const linetable_entry
<e1
, const linetable_entry
& lte2
)
463 { return lte1
.pc
< lte2
.pc
; });
465 /* Allocate a new line table. */
466 newLineTb
= (struct linetable
*)
468 (sizeof (struct linetable
) +
469 (oldLineTb
->nitems
- function_count
+ extra_lines
) * sizeof (struct linetable_entry
));
471 /* If line table does not start with a function beginning, copy up until
475 if (oldLineTb
->item
[0].line
!= 0)
477 newline
< oldLineTb
->nitems
&& oldLineTb
->item
[newline
].line
; ++newline
)
478 newLineTb
->item
[newline
] = oldLineTb
->item
[newline
];
480 /* Now copy function lines one by one. */
482 for (ii
= 0; ii
< function_count
; ++ii
)
484 /* If the function was compiled with XLC, we may have to add an
485 extra line to cover the function prologue. */
486 jj
= fentry
[ii
].line
;
487 if (jj
+ 1 < oldLineTb
->nitems
488 && oldLineTb
->item
[jj
].pc
!= oldLineTb
->item
[jj
+ 1].pc
)
490 newLineTb
->item
[newline
] = oldLineTb
->item
[jj
];
491 newLineTb
->item
[newline
].line
= oldLineTb
->item
[jj
+ 1].line
;
495 for (jj
= fentry
[ii
].line
+ 1;
496 jj
< oldLineTb
->nitems
&& oldLineTb
->item
[jj
].line
!= 0;
498 newLineTb
->item
[newline
] = oldLineTb
->item
[jj
];
501 /* The number of items in the line table must include these
502 extra lines which were added in case of XLC compiled functions. */
503 newLineTb
->nitems
= oldLineTb
->nitems
- function_count
+ extra_lines
;
507 /* include file support: C_BINCL/C_EINCL pairs will be kept in the
508 following `IncludeChain'. At the end of each symtab (end_symtab),
509 we will determine if we should create additional symtab's to
510 represent if (the include files. */
513 typedef struct _inclTable
515 char *name
; /* include filename */
517 /* Offsets to the line table. end points to the last entry which is
518 part of this include file. */
521 struct subfile
*subfile
;
522 unsigned funStartLine
; /* Start line # of its function. */
526 #define INITIAL_INCLUDE_TABLE_LENGTH 20
527 static InclTable
*inclTable
; /* global include table */
528 static int inclIndx
; /* last entry to table */
529 static int inclLength
; /* table length */
530 static int inclDepth
; /* nested include depth */
532 static void allocate_include_entry (void);
535 record_include_begin (struct coff_symbol
*cs
)
539 /* In xcoff, we assume include files cannot be nested (not in .c files
540 of course, but in corresponding .s files.). */
542 /* This can happen with old versions of GCC.
543 GCC 2.3.3-930426 does not exhibit this on a test case which
544 a user said produced the message for him. */
545 complaint (_("Nested C_BINCL symbols"));
549 allocate_include_entry ();
551 inclTable
[inclIndx
].name
= cs
->c_name
;
552 inclTable
[inclIndx
].begin
= cs
->c_value
;
556 record_include_end (struct coff_symbol
*cs
)
562 complaint (_("Mismatched C_BINCL/C_EINCL pair"));
565 allocate_include_entry ();
567 pTbl
= &inclTable
[inclIndx
];
568 pTbl
->end
= cs
->c_value
;
575 allocate_include_entry (void)
577 if (inclTable
== NULL
)
579 inclTable
= XCNEWVEC (InclTable
, INITIAL_INCLUDE_TABLE_LENGTH
);
580 inclLength
= INITIAL_INCLUDE_TABLE_LENGTH
;
583 else if (inclIndx
>= inclLength
)
585 inclLength
+= INITIAL_INCLUDE_TABLE_LENGTH
;
586 inclTable
= XRESIZEVEC (InclTable
, inclTable
, inclLength
);
587 memset (inclTable
+ inclLength
- INITIAL_INCLUDE_TABLE_LENGTH
,
588 '\0', sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
592 /* Global variable to pass the psymtab down to all the routines involved
593 in psymtab to symtab processing. */
594 static struct partial_symtab
*this_symtab_psymtab
;
596 /* Objfile related to this_symtab_psymtab; set at the same time. */
597 static struct objfile
*this_symtab_objfile
;
599 /* given the start and end addresses of a compilation unit (or a csect,
600 at times) process its lines and create appropriate line vectors. */
603 process_linenos (CORE_ADDR start
, CORE_ADDR end
)
607 = XCOFF_DATA (this_symtab_objfile
)->max_lineno_offset
;
609 /* subfile structure for the main compilation unit. */
610 struct subfile main_subfile
;
612 /* In the main source file, any time we see a function entry, we
613 reset this variable to function's absolute starting line number.
614 All the following line numbers in the function are relative to
615 this, and we record absolute line numbers in record_line(). */
617 unsigned int main_source_baseline
= 0;
622 ((struct symloc
*) this_symtab_psymtab
->read_symtab_private
)->lineno_off
;
624 goto return_after_cleanup
;
626 memset (&main_subfile
, '\0', sizeof (main_subfile
));
629 /* All source lines were in the main source file. None in include
632 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
633 &main_source_baseline
);
637 /* There was source with line numbers in include files. */
640 coff_data (this_symtab_objfile
->obfd
)->local_linesz
;
641 main_source_baseline
= 0;
643 for (ii
= 0; ii
< inclIndx
; ++ii
)
645 struct subfile
*tmpSubfile
;
647 /* If there is main file source before include file, enter it. */
648 if (offset
< inclTable
[ii
].begin
)
651 (&main_subfile
, offset
, inclTable
[ii
].begin
- linesz
,
652 start
, 0, &main_source_baseline
);
655 if (strcmp (inclTable
[ii
].name
, get_last_source_file ()) == 0)
657 /* The entry in the include table refers to the main source
658 file. Add the lines to the main subfile. */
660 main_source_baseline
= inclTable
[ii
].funStartLine
;
662 (&main_subfile
, inclTable
[ii
].begin
, inclTable
[ii
].end
,
663 start
, 0, &main_source_baseline
);
664 inclTable
[ii
].subfile
= &main_subfile
;
668 /* Have a new subfile for the include file. */
670 tmpSubfile
= inclTable
[ii
].subfile
= XNEW (struct subfile
);
672 memset (tmpSubfile
, '\0', sizeof (struct subfile
));
673 firstLine
= &(inclTable
[ii
].funStartLine
);
675 /* Enter include file's lines now. */
676 enter_line_range (tmpSubfile
, inclTable
[ii
].begin
,
677 inclTable
[ii
].end
, start
, 0, firstLine
);
680 if (offset
<= inclTable
[ii
].end
)
681 offset
= inclTable
[ii
].end
+ linesz
;
684 /* All the include files' line have been processed at this point. Now,
685 enter remaining lines of the main file, if any left. */
686 if (offset
< max_offset
+ 1 - linesz
)
688 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
689 &main_source_baseline
);
693 /* Process main file's line numbers. */
694 if (main_subfile
.line_vector
)
696 struct linetable
*lineTb
, *lv
;
698 lv
= main_subfile
.line_vector
;
700 /* Line numbers are not necessarily ordered. xlc compilation will
701 put static function to the end. */
703 struct subfile
*current_subfile
= get_current_subfile ();
704 lineTb
= arrange_linetable (lv
);
707 current_subfile
->line_vector
= (struct linetable
*)
708 xrealloc (lv
, (sizeof (struct linetable
)
709 + lv
->nitems
* sizeof (struct linetable_entry
)));
714 current_subfile
->line_vector
= lineTb
;
717 current_subfile
->line_vector_length
=
718 current_subfile
->line_vector
->nitems
;
721 /* Now, process included files' line numbers. */
723 for (ii
= 0; ii
< inclIndx
; ++ii
)
725 if (inclTable
[ii
].subfile
!= ((struct subfile
*) &main_subfile
)
726 && (inclTable
[ii
].subfile
)->line_vector
) /* Useless if!!!
729 struct linetable
*lineTb
, *lv
;
731 lv
= (inclTable
[ii
].subfile
)->line_vector
;
733 /* Line numbers are not necessarily ordered. xlc compilation will
734 put static function to the end. */
736 lineTb
= arrange_linetable (lv
);
740 /* For the same include file, we might want to have more than one
741 subfile. This happens if we have something like:
749 while foo.h including code in it. (stupid but possible)
750 Since start_subfile() looks at the name and uses an
751 existing one if finds, we need to provide a fake name and
755 start_subfile (inclTable
[ii
].name
);
758 /* Pick a fake name that will produce the same results as this
759 one when passed to deduce_language_from_filename. Kludge on
761 const char *fakename
= strrchr (inclTable
[ii
].name
, '.');
763 if (fakename
== NULL
)
765 start_subfile (fakename
);
766 xfree (get_current_subfile ()->name
);
768 struct subfile
*current_subfile
= get_current_subfile ();
769 current_subfile
->name
= xstrdup (inclTable
[ii
].name
);
774 current_subfile
->line_vector
=
775 (struct linetable
*) xrealloc
776 (lv
, (sizeof (struct linetable
)
777 + lv
->nitems
* sizeof (struct linetable_entry
)));
783 current_subfile
->line_vector
= lineTb
;
786 current_subfile
->line_vector_length
=
787 current_subfile
->line_vector
->nitems
;
788 start_subfile (pop_subfile ());
792 return_after_cleanup
:
794 /* We don't want to keep alloc/free'ing the global include file table. */
799 aix_process_linenos (struct objfile
*objfile
)
801 /* There is no linenos to read if there are only dwarf info. */
802 if (this_symtab_psymtab
== NULL
)
805 /* Process line numbers and enter them into line vector. */
806 process_linenos (get_last_source_start_addr (), cur_src_end_addr
);
810 /* Enter a given range of lines into the line vector.
811 can be called in the following two ways:
812 enter_line_range (subfile, beginoffset, endoffset,
813 startaddr, 0, firstLine) or
814 enter_line_range (subfile, beginoffset, 0,
815 startaddr, endaddr, firstLine)
817 endoffset points to the last line table entry that we should pay
821 enter_line_range (struct subfile
*subfile
, unsigned beginoffset
,
822 unsigned endoffset
, /* offsets to line table */
823 CORE_ADDR startaddr
, /* offsets to line table */
824 CORE_ADDR endaddr
, unsigned *firstLine
)
826 struct objfile
*objfile
= this_symtab_objfile
;
827 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
828 unsigned int curoffset
;
831 struct internal_lineno int_lnno
;
832 unsigned int limit_offset
;
836 if (endoffset
== 0 && startaddr
== 0 && endaddr
== 0)
838 curoffset
= beginoffset
;
839 limit_offset
= XCOFF_DATA (objfile
)->max_lineno_offset
;
843 if (endoffset
>= limit_offset
)
845 complaint (_("Bad line table offset in C_EINCL directive"));
848 limit_offset
= endoffset
;
853 abfd
= objfile
->obfd
;
854 linesz
= coff_data (abfd
)->local_linesz
;
855 ext_lnno
= alloca (linesz
);
857 while (curoffset
<= limit_offset
)
859 bfd_seek (abfd
, curoffset
, SEEK_SET
);
860 bfd_bread (ext_lnno
, linesz
, abfd
);
861 bfd_coff_swap_lineno_in (abfd
, ext_lnno
, &int_lnno
);
863 /* Find the address this line represents. */
864 addr
= (int_lnno
.l_lnno
865 ? int_lnno
.l_addr
.l_paddr
866 : read_symbol_nvalue (int_lnno
.l_addr
.l_symndx
));
867 addr
+= objfile
->section_offsets
[SECT_OFF_TEXT (objfile
)];
869 if (addr
< startaddr
|| (endaddr
&& addr
>= endaddr
))
872 if (int_lnno
.l_lnno
== 0)
874 *firstLine
= read_symbol_lineno (int_lnno
.l_addr
.l_symndx
);
875 record_line (subfile
, 0, gdbarch_addr_bits_remove (gdbarch
, addr
));
879 record_line (subfile
, *firstLine
+ int_lnno
.l_lnno
,
880 gdbarch_addr_bits_remove (gdbarch
, addr
));
886 /* Save the vital information for use when closing off the current file.
887 NAME is the file name the symbols came from, START_ADDR is the first
888 text address for the file, and SIZE is the number of bytes of text. */
890 #define complete_symtab(name, start_addr) { \
891 set_last_source_file (name); \
892 set_last_source_start_addr (start_addr); \
896 /* Refill the symbol table input buffer
897 and set the variables that control fetching entries from it.
898 Reports an error if no data available.
899 This function can read past the end of the symbol table
900 (into the string table) but this does no harm. */
902 /* Create a new minimal symbol (using record_with_info).
904 Creation of all new minimal symbols should go through this function
905 rather than calling the various record functions in order
906 to make sure that all symbol addresses get properly relocated.
910 NAME - the symbol's name (but if NAME starts with a period, that
911 leading period is discarded).
912 ADDRESS - the symbol's address, prior to relocation. This function
913 relocates the address before recording the minimal symbol.
914 MS_TYPE - the symbol's type.
915 N_SCNUM - the symbol's XCOFF section number.
916 OBJFILE - the objfile associated with the minimal symbol. */
919 record_minimal_symbol (minimal_symbol_reader
&reader
,
920 const char *name
, CORE_ADDR address
,
921 enum minimal_symbol_type ms_type
,
923 struct objfile
*objfile
)
928 reader
.record_with_info (name
, address
, ms_type
,
929 secnum_to_section (n_scnum
, objfile
));
932 /* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
933 nested. At any given time, a symbol can only be in one static block.
934 This is the base address of current static block, zero if non exists. */
936 static int static_block_base
= 0;
938 /* Section number for the current static block. */
940 static int static_block_section
= -1;
942 /* true if space for symbol name has been allocated. */
944 static int symname_alloced
= 0;
946 /* Next symbol to read. Pointer into raw seething symbol table. */
948 static char *raw_symbol
;
950 /* This is the function which stabsread.c calls to get symbol
954 xcoff_next_symbol_text (struct objfile
*objfile
)
956 struct internal_syment symbol
;
959 /* FIXME: is this the same as the passed arg? */
960 if (this_symtab_objfile
)
961 objfile
= this_symtab_objfile
;
963 bfd_coff_swap_sym_in (objfile
->obfd
, raw_symbol
, &symbol
);
966 complaint (_("Unexpected symbol continuation"));
968 /* Return something which points to '\0' and hope the symbol reading
969 code does something reasonable. */
972 else if (symbol
.n_sclass
& 0x80)
974 retval
= XCOFF_DATA (objfile
)->debugsec
+ symbol
.n_offset
;
975 raw_symbol
+= coff_data (objfile
->obfd
)->local_symesz
;
980 complaint (_("Unexpected symbol continuation"));
982 /* Return something which points to '\0' and hope the symbol reading
983 code does something reasonable. */
989 /* Read symbols for a given partial symbol table. */
992 read_xcoff_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
994 bfd
*abfd
= objfile
->obfd
;
995 char *raw_auxptr
; /* Pointer to first raw aux entry for sym. */
996 struct xcoff_symfile_info
*xcoff
= XCOFF_DATA (objfile
);
997 char *strtbl
= xcoff
->strtbl
;
998 char *debugsec
= xcoff
->debugsec
;
999 const char *debugfmt
= bfd_xcoff_is_xcoff64 (abfd
) ? "XCOFF64" : "XCOFF";
1001 struct internal_syment symbol
[1];
1002 union internal_auxent main_aux
;
1003 struct coff_symbol cs
[1];
1004 CORE_ADDR file_start_addr
= 0;
1005 CORE_ADDR file_end_addr
= 0;
1007 int next_file_symnum
= -1;
1008 unsigned int max_symnum
;
1009 int just_started
= 1;
1011 CORE_ADDR fcn_start_addr
= 0;
1012 enum language pst_symtab_language
;
1014 struct coff_symbol fcn_stab_saved
= { 0 };
1016 /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
1017 union internal_auxent fcn_aux_saved
= main_aux
;
1018 struct context_stack
*newobj
;
1020 const char *filestring
= pst
->filename
; /* Name of the current file. */
1022 const char *last_csect_name
; /* Last seen csect's name. */
1024 this_symtab_psymtab
= pst
;
1025 this_symtab_objfile
= objfile
;
1027 /* Get the appropriate COFF "constants" related to the file we're
1029 local_symesz
= coff_data (abfd
)->local_symesz
;
1031 set_last_source_file (NULL
);
1032 last_csect_name
= 0;
1033 pst_symtab_language
= deduce_language_from_filename (filestring
);
1036 start_symtab (objfile
, filestring
, NULL
, file_start_addr
,
1037 pst_symtab_language
);
1038 record_debugformat (debugfmt
);
1039 symnum
= ((struct symloc
*) pst
->read_symtab_private
)->first_symnum
;
1041 symnum
+ ((struct symloc
*) pst
->read_symtab_private
)->numsyms
;
1042 first_object_file_end
= 0;
1044 raw_symbol
= xcoff
->symtbl
+ symnum
* local_symesz
;
1046 while (symnum
< max_symnum
)
1048 QUIT
; /* make this command interruptable. */
1050 /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
1051 /* read one symbol into `cs' structure. After processing the
1052 whole symbol table, only string table will be kept in memory,
1053 symbol table and debug section of xcoff will be freed. Thus
1054 we can mark symbols with names in string table as
1059 /* Swap and align the symbol into a reasonable C structure. */
1060 bfd_coff_swap_sym_in (abfd
, raw_symbol
, symbol
);
1062 cs
->c_symnum
= symnum
;
1063 cs
->c_naux
= symbol
->n_numaux
;
1064 if (symbol
->n_zeroes
)
1066 symname_alloced
= 0;
1067 /* We must use the original, unswapped, name here so the name field
1068 pointed to by cs->c_name will persist throughout xcoffread. If
1069 we use the new field, it gets overwritten for each symbol. */
1070 cs
->c_name
= ((struct external_syment
*) raw_symbol
)->e
.e_name
;
1071 /* If it's exactly E_SYMNMLEN characters long it isn't
1073 if (cs
->c_name
[E_SYMNMLEN
- 1] != '\0')
1077 p
= (char *) obstack_alloc (&objfile
->objfile_obstack
,
1079 strncpy (p
, cs
->c_name
, E_SYMNMLEN
);
1080 p
[E_SYMNMLEN
] = '\0';
1082 symname_alloced
= 1;
1085 else if (symbol
->n_sclass
& 0x80)
1087 cs
->c_name
= debugsec
+ symbol
->n_offset
;
1088 symname_alloced
= 0;
1092 /* in string table */
1093 cs
->c_name
= strtbl
+ (int) symbol
->n_offset
;
1094 symname_alloced
= 1;
1096 cs
->c_value
= symbol
->n_value
;
1097 cs
->c_sclass
= symbol
->n_sclass
;
1098 cs
->c_secnum
= symbol
->n_scnum
;
1099 cs
->c_type
= (unsigned) symbol
->n_type
;
1101 raw_symbol
+= local_symesz
;
1104 /* Save addr of first aux entry. */
1105 raw_auxptr
= raw_symbol
;
1107 /* Skip all the auxents associated with this symbol. */
1108 for (ii
= symbol
->n_numaux
; ii
; --ii
)
1110 raw_symbol
+= coff_data (abfd
)->local_auxesz
;
1115 /* if symbol name starts with ".$" or "$", ignore it. */
1116 if (cs
->c_name
[0] == '$'
1117 || (cs
->c_name
[1] == '$' && cs
->c_name
[0] == '.'))
1120 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
1122 if (get_last_source_file ())
1124 pst
->compunit_symtab
= end_symtab (cur_src_end_addr
,
1125 SECT_OFF_TEXT (objfile
));
1130 start_symtab (objfile
, "_globals_", NULL
,
1131 0, pst_symtab_language
);
1132 record_debugformat (debugfmt
);
1133 cur_src_end_addr
= first_object_file_end
;
1134 /* Done with all files, everything from here on is globals. */
1137 if (cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_HIDEXT
||
1138 cs
->c_sclass
== C_WEAKEXT
)
1140 /* Dealing with a symbol with a csect entry. */
1142 #define CSECT(PP) ((PP)->x_csect)
1143 #define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
1144 #define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1145 #define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1146 #define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1148 /* Convert the auxent to something we can access.
1149 XCOFF can have more than one auxiliary entries.
1151 Actual functions will have two auxiliary entries, one to have the
1152 function size and other to have the smtype/smclass (LD/PR).
1154 c_type value of main symbol table will be set only in case of
1155 C_EXT/C_HIDEEXT/C_WEAKEXT storage class symbols.
1156 Bit 10 of type is set if symbol is a function, ie the value is set
1157 to 32(0x20). So we need to read the first function auxiliary entry
1158 which contains the size. */
1159 if (cs
->c_naux
> 1 && ISFCN (cs
->c_type
))
1161 /* a function entry point. */
1163 fcn_start_addr
= cs
->c_value
;
1165 /* save the function header info, which will be used
1166 when `.bf' is seen. */
1169 /* Convert the auxent to something we can access. */
1170 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1171 0, cs
->c_naux
, &fcn_aux_saved
);
1174 /* Read the csect auxiliary header, which is always the last by
1176 bfd_coff_swap_aux_in (abfd
,
1178 + ((coff_data (abfd
)->local_symesz
)
1179 * (cs
->c_naux
- 1)),
1180 cs
->c_type
, cs
->c_sclass
,
1181 cs
->c_naux
- 1, cs
->c_naux
,
1184 switch (CSECT_SMTYP (&main_aux
))
1188 /* Ignore all external references. */
1192 /* A section description. */
1194 switch (CSECT_SCLAS (&main_aux
))
1200 /* A program csect is seen. We have to allocate one
1201 symbol table for each program csect. Normally gdb
1202 prefers one symtab for each source file. In case
1203 of AIX, one source file might include more than one
1204 [PR] csect, and they don't have to be adjacent in
1205 terms of the space they occupy in memory. Thus, one
1206 single source file might get fragmented in the
1207 memory and gdb's file start and end address
1208 approach does not work! GCC (and I think xlc) seem
1209 to put all the code in the unnamed program csect. */
1211 if (last_csect_name
)
1213 complete_symtab (filestring
, file_start_addr
);
1214 cur_src_end_addr
= file_end_addr
;
1215 end_symtab (file_end_addr
, SECT_OFF_TEXT (objfile
));
1218 /* Give all csects for this source file the same
1220 start_symtab (objfile
, filestring
, NULL
,
1221 0, pst_symtab_language
);
1222 record_debugformat (debugfmt
);
1225 /* If this is the very first csect seen,
1226 basically `__start'. */
1229 first_object_file_end
1230 = cs
->c_value
+ CSECT_LEN (&main_aux
);
1235 cs
->c_value
+ objfile
->section_offsets
[SECT_OFF_TEXT (objfile
)];
1236 file_end_addr
= file_start_addr
+ CSECT_LEN (&main_aux
);
1238 if (cs
->c_name
&& (cs
->c_name
[0] == '.' || cs
->c_name
[0] == '@'))
1239 last_csect_name
= cs
->c_name
;
1243 /* All other symbols are put into the minimal symbol
1256 /* Ignore the symbol. */
1264 switch (CSECT_SCLAS (&main_aux
))
1266 /* We never really come to this part as this case has been
1267 handled in ISFCN check above.
1268 This and other cases of XTY_LD are kept just for
1274 /* shared library function trampoline code entry point. */
1278 /* The symbols often have the same names as debug symbols for
1279 functions, and confuse lookup_symbol. */
1283 /* xlc puts each variable in a separate csect, so we get
1284 an XTY_SD for each variable. But gcc puts several
1285 variables in a csect, so that each variable only gets
1286 an XTY_LD. This will typically be XMC_RW; I suspect
1287 XMC_RO and XMC_BS might be possible too.
1288 These variables are put in the minimal symbol table
1295 /* Common symbols are put into the minimal symbol table only. */
1303 switch (cs
->c_sclass
)
1307 /* c_value field contains symnum of next .file entry in table
1308 or symnum of first global after last .file. */
1310 next_file_symnum
= cs
->c_value
;
1312 /* Complete symbol table for last object file containing
1313 debugging information. */
1315 /* Whether or not there was a csect in the previous file, we
1316 have to call `end_stabs' and `start_stabs' to reset
1317 type_vector, line_vector, etc. structures. */
1319 complete_symtab (filestring
, file_start_addr
);
1320 cur_src_end_addr
= file_end_addr
;
1321 end_symtab (file_end_addr
, SECT_OFF_TEXT (objfile
));
1324 /* XCOFF, according to the AIX 3.2 documentation, puts the
1325 filename in cs->c_name. But xlc 1.3.0.2 has decided to
1326 do things the standard COFF way and put it in the auxent.
1327 We use the auxent if the symbol is ".file" and an auxent
1328 exists, otherwise use the symbol itself. Simple
1330 if (!strcmp (cs
->c_name
, ".file") && cs
->c_naux
> 0)
1332 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1333 0, cs
->c_naux
, &main_aux
);
1334 filestring
= coff_getfilename (&main_aux
, objfile
);
1337 filestring
= cs
->c_name
;
1340 start_symtab (objfile
, filestring
, NULL
, 0, pst_symtab_language
);
1341 record_debugformat (debugfmt
);
1342 last_csect_name
= 0;
1344 /* reset file start and end addresses. A compilation unit
1345 with no text (only data) should have zero file
1347 file_start_addr
= file_end_addr
= 0;
1351 fcn_stab_saved
= *cs
;
1355 if (strcmp (cs
->c_name
, ".bf") == 0)
1357 CORE_ADDR off
= objfile
->section_offsets
[SECT_OFF_TEXT (objfile
)];
1359 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1360 0, cs
->c_naux
, &main_aux
);
1362 within_function
= 1;
1364 newobj
= push_context (0, fcn_start_addr
+ off
);
1366 newobj
->name
= define_symbol
1367 (fcn_cs_saved
.c_value
+ off
,
1368 fcn_stab_saved
.c_name
, 0, 0, objfile
);
1369 if (newobj
->name
!= NULL
)
1370 SYMBOL_SECTION (newobj
->name
) = SECT_OFF_TEXT (objfile
);
1372 else if (strcmp (cs
->c_name
, ".ef") == 0)
1374 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1375 0, cs
->c_naux
, &main_aux
);
1377 /* The value of .ef is the address of epilogue code;
1378 not useful for gdb. */
1379 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1380 contains number of lines to '}' */
1382 if (outermost_context_p ())
1383 { /* We attempted to pop an empty context stack. */
1384 ef_complaint (cs
->c_symnum
);
1385 within_function
= 0;
1388 struct context_stack cstk
= pop_context ();
1389 /* Stack must be empty now. */
1390 if (!outermost_context_p ())
1392 ef_complaint (cs
->c_symnum
);
1393 within_function
= 0;
1397 finish_block (cstk
.name
, cstk
.old_blocks
,
1398 NULL
, cstk
.start_addr
,
1399 (fcn_cs_saved
.c_value
1400 + fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1401 + objfile
->section_offsets
[SECT_OFF_TEXT (objfile
)]));
1402 within_function
= 0;
1407 /* Begin static block. */
1409 struct internal_syment static_symbol
;
1411 read_symbol (&static_symbol
, cs
->c_value
);
1412 static_block_base
= static_symbol
.n_value
;
1413 static_block_section
=
1414 secnum_to_section (static_symbol
.n_scnum
, objfile
);
1419 /* End of static block. */
1420 static_block_base
= 0;
1421 static_block_section
= -1;
1432 complaint (_("Unrecognized storage class %d."),
1447 /* beginning of include file */
1448 /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1449 order. Thus, when wee see them, we might not know enough info
1450 to process them. Thus, we'll be saving them into a table
1451 (inclTable) and postpone their processing. */
1453 record_include_begin (cs
);
1457 /* End of include file. */
1458 /* See the comment after case C_BINCL. */
1459 record_include_end (cs
);
1463 if (strcmp (cs
->c_name
, ".bb") == 0)
1466 newobj
= push_context (depth
,
1468 + objfile
->section_offsets
[SECT_OFF_TEXT (objfile
)]));
1470 else if (strcmp (cs
->c_name
, ".eb") == 0)
1472 if (outermost_context_p ())
1473 { /* We attempted to pop an empty context stack. */
1474 eb_complaint (cs
->c_symnum
);
1477 struct context_stack cstk
= pop_context ();
1478 if (depth
-- != cstk
.depth
)
1480 eb_complaint (cs
->c_symnum
);
1483 if (*get_local_symbols () && !outermost_context_p ())
1485 /* Make a block for the local symbols within. */
1486 finish_block (cstk
.name
,
1487 cstk
.old_blocks
, NULL
,
1490 + objfile
->section_offsets
[SECT_OFF_TEXT (objfile
)]));
1492 *get_local_symbols () = cstk
.locals
;
1497 process_xcoff_symbol (cs
, objfile
);
1502 if (get_last_source_file ())
1504 struct compunit_symtab
*cust
;
1506 complete_symtab (filestring
, file_start_addr
);
1507 cur_src_end_addr
= file_end_addr
;
1508 cust
= end_symtab (file_end_addr
, SECT_OFF_TEXT (objfile
));
1509 /* When reading symbols for the last C_FILE of the objfile, try
1510 to make sure that we set pst->compunit_symtab to the symtab for the
1511 file, not to the _globals_ symtab. I'm not sure whether this
1512 actually works right or when/if it comes up. */
1513 if (pst
->compunit_symtab
== NULL
)
1514 pst
->compunit_symtab
= cust
;
1519 #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1520 (SYMBOL2) = new (&objfile->objfile_obstack) symbol (); \
1521 *(SYMBOL2) = *(SYMBOL1);
1524 #define SYMNAME_ALLOC(NAME, ALLOCED) \
1525 ((ALLOCED) ? (NAME) : obstack_strdup (&objfile->objfile_obstack, \
1529 /* process one xcoff symbol. */
1531 static struct symbol
*
1532 process_xcoff_symbol (struct coff_symbol
*cs
, struct objfile
*objfile
)
1534 struct symbol onesymbol
;
1535 struct symbol
*sym
= &onesymbol
;
1536 struct symbol
*sym2
= NULL
;
1542 if (cs
->c_secnum
< 0)
1544 /* The value is a register number, offset within a frame, etc.,
1545 and does not get relocated. */
1551 sec
= secnum_to_section (cs
->c_secnum
, objfile
);
1552 off
= objfile
->section_offsets
[sec
];
1559 initialize_objfile_symbol (sym
);
1561 /* default assumptions */
1562 SET_SYMBOL_VALUE_ADDRESS (sym
, cs
->c_value
+ off
);
1563 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
1564 SYMBOL_SECTION (sym
) = secnum_to_section (cs
->c_secnum
, objfile
);
1566 if (ISFCN (cs
->c_type
))
1568 /* At this point, we don't know the type of the function. This
1569 will be patched with the type from its stab entry later on in
1570 patch_block_stabs (), unless the file was compiled without -g. */
1572 sym
->set_linkage_name (SYMNAME_ALLOC (name
, symname_alloced
));
1573 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->nodebug_text_symbol
;
1575 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
1576 SYMBOL_DUP (sym
, sym2
);
1578 if (cs
->c_sclass
== C_EXT
|| C_WEAKEXT
)
1579 add_symbol_to_list (sym2
, get_global_symbols ());
1580 else if (cs
->c_sclass
== C_HIDEXT
|| cs
->c_sclass
== C_STAT
)
1581 add_symbol_to_list (sym2
, get_file_symbols ());
1585 /* In case we can't figure out the type, provide default. */
1586 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->nodebug_data_symbol
;
1588 switch (cs
->c_sclass
)
1591 /* The values of functions and global symbols are now resolved
1592 via the global_sym_chain in stabsread.c. */
1594 if (fcn_cs_saved
.c_sclass
== C_EXT
)
1595 add_stab_to_list (name
, &global_stabs
);
1597 add_stab_to_list (name
, &file_stabs
);
1601 add_stab_to_list (name
, &global_stabs
);
1606 common_block_start (cs
->c_name
, objfile
);
1610 common_block_end (objfile
);
1614 complaint (_("Unexpected storage class: %d"),
1627 sym
= define_symbol (cs
->c_value
+ off
, cs
->c_name
, 0, 0, objfile
);
1630 SYMBOL_SECTION (sym
) = sec
;
1637 /* For xlc (not GCC), the 'V' symbol descriptor is used for
1638 all statics and we need to distinguish file-scope versus
1639 function-scope using within_function. We do this by
1640 changing the string we pass to define_symbol to use 'S'
1641 where we need to, which is not necessarily super-clean,
1642 but seems workable enough. */
1647 pp
= strchr (name
, ':');
1652 if (*pp
== 'V' && !within_function
)
1654 sym
= define_symbol ((cs
->c_value
1655 + objfile
->section_offsets
[static_block_section
]),
1656 cs
->c_name
, 0, 0, objfile
);
1659 SET_SYMBOL_VALUE_ADDRESS (sym
,
1660 SYMBOL_VALUE_ADDRESS (sym
)
1661 + static_block_base
);
1662 SYMBOL_SECTION (sym
) = static_block_section
;
1671 /* Extract the file name from the aux entry of a C_FILE symbol.
1672 Result is in static storage and is only good for temporary use. */
1675 coff_getfilename (union internal_auxent
*aux_entry
, struct objfile
*objfile
)
1677 static char buffer
[BUFSIZ
];
1679 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1680 strcpy (buffer
, (XCOFF_DATA (objfile
)->strtbl
1681 + aux_entry
->x_file
.x_n
.x_offset
));
1684 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1685 buffer
[FILNMLEN
] = '\0';
1690 /* Set *SYMBOL to symbol number symno in symtbl. */
1692 read_symbol (struct internal_syment
*symbol
, int symno
)
1694 struct xcoff_symfile_info
*xcoff
= XCOFF_DATA (this_symtab_objfile
);
1695 int nsyms
= xcoff
->symtbl_num_syms
;
1696 char *stbl
= xcoff
->symtbl
;
1698 if (symno
< 0 || symno
>= nsyms
)
1700 complaint (_("Invalid symbol offset"));
1701 symbol
->n_value
= 0;
1702 symbol
->n_scnum
= -1;
1705 bfd_coff_swap_sym_in (this_symtab_objfile
->obfd
,
1706 stbl
+ (symno
* local_symesz
),
1710 /* Get value corresponding to symbol number symno in symtbl. */
1713 read_symbol_nvalue (int symno
)
1715 struct internal_syment symbol
[1];
1717 read_symbol (symbol
, symno
);
1718 return symbol
->n_value
;
1722 /* Find the address of the function corresponding to symno, where
1723 symno is the symbol pointed to by the linetable. */
1726 read_symbol_lineno (int symno
)
1728 struct objfile
*objfile
= this_symtab_objfile
;
1729 int xcoff64
= bfd_xcoff_is_xcoff64 (objfile
->obfd
);
1731 struct xcoff_symfile_info
*info
= XCOFF_DATA (objfile
);
1732 int nsyms
= info
->symtbl_num_syms
;
1733 char *stbl
= info
->symtbl
;
1734 char *strtbl
= info
->strtbl
;
1736 struct internal_syment symbol
[1];
1737 union internal_auxent main_aux
[1];
1741 bf_notfound_complaint ();
1745 /* Note that just searching for a short distance (e.g. 50 symbols)
1746 is not enough, at least in the following case.
1749 [many .stabx entries]
1750 [a few functions, referring to foo]
1754 What happens here is that the assembler moves the .stabx entries
1755 to right before the ".bf" for foo, but the symbol for "foo" is before
1756 all the stabx entries. See PR gdb/2222. */
1758 /* Maintaining a table of .bf entries might be preferable to this search.
1759 If I understand things correctly it would need to be done only for
1760 the duration of a single psymtab to symtab conversion. */
1761 while (symno
< nsyms
)
1763 bfd_coff_swap_sym_in (symfile_bfd
,
1764 stbl
+ (symno
* local_symesz
), symbol
);
1765 if (symbol
->n_sclass
== C_FCN
)
1767 char *name
= xcoff64
? strtbl
+ symbol
->n_offset
: symbol
->n_name
;
1769 if (strcmp (name
, ".bf") == 0)
1772 symno
+= symbol
->n_numaux
+ 1;
1775 bf_notfound_complaint ();
1779 /* Take aux entry and return its lineno. */
1781 bfd_coff_swap_aux_in (objfile
->obfd
, stbl
+ symno
* local_symesz
,
1782 symbol
->n_type
, symbol
->n_sclass
,
1783 0, symbol
->n_numaux
, main_aux
);
1785 return main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
1788 /* Support for line number handling. */
1790 /* This function is called for every section; it finds the outer limits
1791 * of the line table (minimum and maximum file offset) so that the
1792 * mainline code can read the whole thing for efficiency.
1795 find_linenos (struct bfd
*abfd
, struct bfd_section
*asect
, void *vpinfo
)
1797 struct xcoff_symfile_info
*info
;
1799 file_ptr offset
, maxoff
;
1801 count
= asect
->lineno_count
;
1803 if (strcmp (asect
->name
, ".text") != 0 || count
== 0)
1806 size
= count
* coff_data (abfd
)->local_linesz
;
1807 info
= (struct xcoff_symfile_info
*) vpinfo
;
1808 offset
= asect
->line_filepos
;
1809 maxoff
= offset
+ size
;
1811 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
1812 info
->min_lineno_offset
= offset
;
1814 if (maxoff
> info
->max_lineno_offset
)
1815 info
->max_lineno_offset
= maxoff
;
1819 xcoff_psymtab_to_symtab_1 (struct objfile
*objfile
, struct partial_symtab
*pst
)
1829 (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1834 /* Read in all partial symtabs on which this one is dependent. */
1835 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1836 if (!pst
->dependencies
[i
]->readin
)
1838 /* Inform about additional files that need to be read in. */
1841 fputs_filtered (" ", gdb_stdout
);
1843 fputs_filtered ("and ", gdb_stdout
);
1845 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1846 wrap_here (""); /* Flush output */
1847 gdb_flush (gdb_stdout
);
1849 xcoff_psymtab_to_symtab_1 (objfile
, pst
->dependencies
[i
]);
1852 if (((struct symloc
*) pst
->read_symtab_private
)->numsyms
!= 0)
1854 /* Init stuff necessary for reading in symbols. */
1857 scoped_free_pendings free_pending
;
1858 read_xcoff_symtab (objfile
, pst
);
1864 /* Read in all of the symbols for a given psymtab for real.
1865 Be verbose about it if the user wants that. SELF is not NULL. */
1868 xcoff_read_symtab (struct partial_symtab
*self
, struct objfile
*objfile
)
1873 (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1878 if (((struct symloc
*) self
->read_symtab_private
)->numsyms
!= 0
1879 || self
->number_of_dependencies
)
1881 /* Print the message now, before reading the string table,
1882 to avoid disconcerting pauses. */
1885 printf_filtered ("Reading in symbols for %s...", self
->filename
);
1886 gdb_flush (gdb_stdout
);
1889 next_symbol_text_func
= xcoff_next_symbol_text
;
1891 xcoff_psymtab_to_symtab_1 (objfile
, self
);
1893 /* Match with global symbols. This only needs to be done once,
1894 after all of the symtabs and dependencies have been read in. */
1895 scan_file_globals (objfile
);
1897 /* Finish up the debug error message. */
1899 printf_filtered ("done.\n");
1904 xcoff_new_init (struct objfile
*objfile
)
1906 stabsread_new_init ();
1909 /* Do initialization in preparation for reading symbols from OBJFILE.
1911 We will only be called if this is an XCOFF or XCOFF-like file.
1912 BFD handles figuring out the format of the file, and code in symfile.c
1913 uses BFD's determination to vector to us. */
1916 xcoff_symfile_init (struct objfile
*objfile
)
1918 /* Allocate struct to keep track of the symfile. */
1919 xcoff_objfile_data_key
.emplace (objfile
);
1921 /* XCOFF objects may be reordered, so set OBJF_REORDERED. If we
1922 find this causes a significant slowdown in gdb then we could
1923 set it in the debug symbol readers only when necessary. */
1924 objfile
->flags
|= OBJF_REORDERED
;
1927 /* Perform any local cleanups required when we are done with a particular
1928 objfile. I.E, we are in the process of discarding all symbol information
1929 for an objfile, freeing up all memory held for it, and unlinking the
1930 objfile struct from the global list of known objfiles. */
1933 xcoff_symfile_finish (struct objfile
*objfile
)
1935 /* Start with a fresh include table for the next objfile. */
1941 inclIndx
= inclLength
= inclDepth
= 0;
1946 init_stringtab (bfd
*abfd
, file_ptr offset
, struct objfile
*objfile
)
1950 unsigned char lengthbuf
[4];
1952 struct xcoff_symfile_info
*xcoff
= XCOFF_DATA (objfile
);
1954 xcoff
->strtbl
= NULL
;
1956 if (bfd_seek (abfd
, offset
, SEEK_SET
) < 0)
1957 error (_("cannot seek to string table in %s: %s"),
1958 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
1960 val
= bfd_bread ((char *) lengthbuf
, sizeof lengthbuf
, abfd
);
1961 length
= bfd_h_get_32 (abfd
, lengthbuf
);
1963 /* If no string table is needed, then the file may end immediately
1964 after the symbols. Just return with `strtbl' set to NULL. */
1966 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1969 /* Allocate string table from objfile_obstack. We will need this table
1970 as long as we have its symbol table around. */
1972 strtbl
= (char *) obstack_alloc (&objfile
->objfile_obstack
, length
);
1973 xcoff
->strtbl
= strtbl
;
1975 /* Copy length buffer, the first byte is usually zero and is
1976 used for stabs with a name length of zero. */
1977 memcpy (strtbl
, lengthbuf
, sizeof lengthbuf
);
1978 if (length
== sizeof lengthbuf
)
1981 val
= bfd_bread (strtbl
+ sizeof lengthbuf
, length
- sizeof lengthbuf
, abfd
);
1983 if (val
!= length
- sizeof lengthbuf
)
1984 error (_("cannot read string table from %s: %s"),
1985 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
1986 if (strtbl
[length
- 1] != '\0')
1987 error (_("bad symbol file: string table "
1988 "does not end with null character"));
1993 /* If we have not yet seen a function for this psymtab, this is 0. If we
1994 have seen one, it is the offset in the line numbers of the line numbers
1996 static unsigned int first_fun_line_offset
;
1998 /* Allocate and partially fill a partial symtab. It will be
1999 completely filled at the end of the symbol list.
2001 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2002 is the address relative to which its symbols are (incremental) or 0
2005 static struct partial_symtab
*
2006 xcoff_start_psymtab (struct objfile
*objfile
,
2007 const char *filename
, int first_symnum
)
2009 struct partial_symtab
*result
=
2010 start_psymtab_common (objfile
,
2012 /* We fill in textlow later. */
2015 result
->read_symtab_private
=
2016 XOBNEW (&objfile
->objfile_obstack
, struct symloc
);
2017 ((struct symloc
*) result
->read_symtab_private
)->first_symnum
= first_symnum
;
2018 result
->read_symtab
= xcoff_read_symtab
;
2020 /* Deduce the source language from the filename for this psymtab. */
2021 psymtab_language
= deduce_language_from_filename (filename
);
2026 /* Close off the current usage of PST.
2027 Returns PST, or NULL if the partial symtab was empty and thrown away.
2029 CAPPING_SYMBOL_NUMBER is the end of pst (exclusive).
2031 INCLUDE_LIST, NUM_INCLUDES, DEPENDENCY_LIST, and NUMBER_DEPENDENCIES
2032 are the information for includes and dependencies. */
2034 static struct partial_symtab
*
2035 xcoff_end_psymtab (struct objfile
*objfile
, struct partial_symtab
*pst
,
2036 const char **include_list
, int num_includes
,
2037 int capping_symbol_number
,
2038 struct partial_symtab
**dependency_list
,
2039 int number_dependencies
, int textlow_not_set
)
2043 if (capping_symbol_number
!= -1)
2044 ((struct symloc
*) pst
->read_symtab_private
)->numsyms
=
2045 capping_symbol_number
2046 - ((struct symloc
*) pst
->read_symtab_private
)->first_symnum
;
2047 ((struct symloc
*) pst
->read_symtab_private
)->lineno_off
=
2048 first_fun_line_offset
;
2049 first_fun_line_offset
= 0;
2051 end_psymtab_common (objfile
, pst
);
2053 pst
->number_of_dependencies
= number_dependencies
;
2054 if (number_dependencies
)
2057 = objfile
->partial_symtabs
->allocate_dependencies (number_dependencies
);
2058 memcpy (pst
->dependencies
, dependency_list
,
2059 number_dependencies
* sizeof (struct partial_symtab
*));
2062 pst
->dependencies
= 0;
2064 for (i
= 0; i
< num_includes
; i
++)
2066 struct partial_symtab
*subpst
=
2067 allocate_psymtab (include_list
[i
], objfile
);
2069 subpst
->read_symtab_private
= XOBNEW (&objfile
->objfile_obstack
, symloc
);
2070 ((struct symloc
*) subpst
->read_symtab_private
)->first_symnum
= 0;
2071 ((struct symloc
*) subpst
->read_symtab_private
)->numsyms
= 0;
2073 /* We could save slight bits of space by only making one of these,
2074 shared by the entire set of include files. FIXME-someday. */
2075 subpst
->dependencies
=
2076 objfile
->partial_symtabs
->allocate_dependencies (1);
2077 subpst
->dependencies
[0] = pst
;
2078 subpst
->number_of_dependencies
= 1;
2080 subpst
->read_symtab
= pst
->read_symtab
;
2083 if (num_includes
== 0
2084 && number_dependencies
== 0
2085 && pst
->n_global_syms
== 0
2086 && pst
->n_static_syms
== 0)
2088 /* Throw away this psymtab, it's empty. We can't deallocate it, since
2089 it is on the obstack, but we can forget to chain it on the list. */
2090 /* Empty psymtabs happen as a result of header files which don't have
2091 any symbols in them. There can be a lot of them. */
2093 discard_psymtab (objfile
, pst
);
2095 /* Indicate that psymtab was thrown away. */
2101 /* Swap raw symbol at *RAW and put the name in *NAME, the symbol in
2102 *SYMBOL, the first auxent in *AUX. Advance *RAW and *SYMNUMP over
2103 the symbol and its auxents. */
2106 swap_sym (struct internal_syment
*symbol
, union internal_auxent
*aux
,
2107 const char **name
, char **raw
, unsigned int *symnump
,
2108 struct objfile
*objfile
)
2110 bfd_coff_swap_sym_in (objfile
->obfd
, *raw
, symbol
);
2111 if (symbol
->n_zeroes
)
2113 /* If it's exactly E_SYMNMLEN characters long it isn't
2115 if (symbol
->n_name
[E_SYMNMLEN
- 1] != '\0')
2117 /* FIXME: wastes memory for symbols which we don't end up putting
2118 into the minimal symbols. */
2121 p
= (char *) obstack_alloc (&objfile
->objfile_obstack
,
2123 strncpy (p
, symbol
->n_name
, E_SYMNMLEN
);
2124 p
[E_SYMNMLEN
] = '\0';
2128 /* Point to the unswapped name as that persists as long as the
2130 *name
= ((struct external_syment
*) *raw
)->e
.e_name
;
2132 else if (symbol
->n_sclass
& 0x80)
2134 *name
= XCOFF_DATA (objfile
)->debugsec
+ symbol
->n_offset
;
2138 *name
= XCOFF_DATA (objfile
)->strtbl
+ symbol
->n_offset
;
2141 *raw
+= coff_data (objfile
->obfd
)->local_symesz
;
2142 if (symbol
->n_numaux
> 0)
2144 bfd_coff_swap_aux_in (objfile
->obfd
, *raw
, symbol
->n_type
,
2145 symbol
->n_sclass
, 0, symbol
->n_numaux
, aux
);
2147 *symnump
+= symbol
->n_numaux
;
2148 *raw
+= coff_data (objfile
->obfd
)->local_symesz
* symbol
->n_numaux
;
2153 function_outside_compilation_unit_complaint (const char *arg1
)
2155 complaint (_("function `%s' appears to be defined "
2156 "outside of all compilation units"),
2161 scan_xcoff_symtab (minimal_symbol_reader
&reader
,
2162 struct objfile
*objfile
)
2164 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2165 CORE_ADDR toc_offset
= 0; /* toc offset value in data section. */
2166 const char *filestring
= NULL
;
2168 const char *namestring
;
2173 /* Current partial symtab */
2174 struct partial_symtab
*pst
;
2176 /* List of current psymtab's include files. */
2177 const char **psymtab_include_list
;
2178 int includes_allocated
;
2181 /* Index within current psymtab dependency list. */
2182 struct partial_symtab
**dependency_list
;
2183 int dependencies_used
, dependencies_allocated
;
2186 struct internal_syment symbol
;
2187 union internal_auxent main_aux
[5];
2188 unsigned int ssymnum
;
2190 const char *last_csect_name
= NULL
; /* Last seen csect's name and value. */
2191 CORE_ADDR last_csect_val
= 0;
2192 int last_csect_sec
= 0;
2193 int misc_func_recorded
= 0; /* true if any misc. function. */
2194 int textlow_not_set
= 1;
2196 pst
= (struct partial_symtab
*) 0;
2198 includes_allocated
= 30;
2200 psymtab_include_list
= (const char **) alloca (includes_allocated
*
2201 sizeof (const char *));
2203 dependencies_allocated
= 30;
2204 dependencies_used
= 0;
2206 (struct partial_symtab
**) alloca (dependencies_allocated
*
2207 sizeof (struct partial_symtab
*));
2209 set_last_source_file (NULL
);
2211 abfd
= objfile
->obfd
;
2212 next_symbol_text_func
= xcoff_next_symbol_text
;
2214 sraw_symbol
= XCOFF_DATA (objfile
)->symtbl
;
2215 nsyms
= XCOFF_DATA (objfile
)->symtbl_num_syms
;
2217 while (ssymnum
< nsyms
)
2223 bfd_coff_swap_sym_in (abfd
, sraw_symbol
, &symbol
);
2224 sclass
= symbol
.n_sclass
;
2232 /* The CSECT auxent--always the last auxent. */
2233 union internal_auxent csect_aux
;
2234 unsigned int symnum_before
= ssymnum
;
2236 swap_sym (&symbol
, &main_aux
[0], &namestring
, &sraw_symbol
,
2238 if (symbol
.n_numaux
> 1)
2240 bfd_coff_swap_aux_in
2242 sraw_symbol
- coff_data (abfd
)->local_symesz
,
2245 symbol
.n_numaux
- 1,
2250 csect_aux
= main_aux
[0];
2252 /* If symbol name starts with ".$" or "$", ignore it. */
2253 if (namestring
[0] == '$'
2254 || (namestring
[0] == '.' && namestring
[1] == '$'))
2257 switch (csect_aux
.x_csect
.x_smtyp
& 0x7)
2260 switch (csect_aux
.x_csect
.x_smclas
)
2263 if (last_csect_name
)
2265 /* If no misc. function recorded in the last
2266 seen csect, enter it as a function. This
2267 will take care of functions like strcmp()
2270 if (!misc_func_recorded
)
2272 record_minimal_symbol
2273 (reader
, last_csect_name
, last_csect_val
,
2274 mst_text
, last_csect_sec
, objfile
);
2275 misc_func_recorded
= 1;
2280 /* We have to allocate one psymtab for
2281 each program csect, because their text
2282 sections need not be adjacent. */
2284 (objfile
, pst
, psymtab_include_list
,
2285 includes_used
, symnum_before
, dependency_list
,
2286 dependencies_used
, textlow_not_set
);
2288 dependencies_used
= 0;
2289 /* Give all psymtabs for this source file the same
2291 pst
= xcoff_start_psymtab
2297 /* Activate the misc_func_recorded mechanism for
2298 compiler- and linker-generated CSECTs like ".strcmp"
2300 if (namestring
&& (namestring
[0] == '.'
2301 || namestring
[0] == '@'))
2303 last_csect_name
= namestring
;
2304 last_csect_val
= symbol
.n_value
;
2305 last_csect_sec
= symbol
.n_scnum
;
2310 symbol
.n_value
+ csect_aux
.x_csect
.x_scnlen
.l
;
2312 if (highval
> pst
->raw_text_high ())
2313 pst
->set_text_high (highval
);
2314 if (!pst
->text_low_valid
2315 || symbol
.n_value
< pst
->raw_text_low ())
2316 pst
->set_text_low (symbol
.n_value
);
2318 misc_func_recorded
= 0;
2323 /* Data variables are recorded in the minimal symbol
2324 table, except for section symbols. */
2325 if (*namestring
!= '.')
2326 record_minimal_symbol
2327 (reader
, namestring
, symbol
.n_value
,
2328 sclass
== C_HIDEXT
? mst_file_data
: mst_data
,
2329 symbol
.n_scnum
, objfile
);
2334 warning (_("More than one XMC_TC0 symbol found."));
2335 toc_offset
= symbol
.n_value
;
2337 /* Make TOC offset relative to start address of
2339 bfd_sect
= secnum_to_bfd_section (symbol
.n_scnum
, objfile
);
2341 toc_offset
-= bfd_section_vma (bfd_sect
);
2345 /* These symbols tell us where the TOC entry for a
2346 variable is, not the variable itself. */
2355 switch (csect_aux
.x_csect
.x_smclas
)
2358 /* A function entry point. */
2360 if (first_fun_line_offset
== 0 && symbol
.n_numaux
> 1)
2361 first_fun_line_offset
=
2362 main_aux
[0].x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2364 record_minimal_symbol
2365 (reader
, namestring
, symbol
.n_value
,
2366 sclass
== C_HIDEXT
? mst_file_text
: mst_text
,
2367 symbol
.n_scnum
, objfile
);
2368 misc_func_recorded
= 1;
2372 /* shared library function trampoline code entry
2375 /* record trampoline code entries as
2376 mst_solib_trampoline symbol. When we lookup mst
2377 symbols, we will choose mst_text over
2378 mst_solib_trampoline. */
2379 record_minimal_symbol
2380 (reader
, namestring
, symbol
.n_value
,
2381 mst_solib_trampoline
, symbol
.n_scnum
, objfile
);
2382 misc_func_recorded
= 1;
2386 /* The symbols often have the same names as
2387 debug symbols for functions, and confuse
2393 /* xlc puts each variable in a separate csect,
2394 so we get an XTY_SD for each variable. But
2395 gcc puts several variables in a csect, so
2396 that each variable only gets an XTY_LD. We
2397 still need to record them. This will
2398 typically be XMC_RW; I suspect XMC_RO and
2399 XMC_BS might be possible too. */
2400 if (*namestring
!= '.')
2401 record_minimal_symbol
2402 (reader
, namestring
, symbol
.n_value
,
2403 sclass
== C_HIDEXT
? mst_file_data
: mst_data
,
2404 symbol
.n_scnum
, objfile
);
2410 switch (csect_aux
.x_csect
.x_smclas
)
2414 /* Common variables are recorded in the minimal symbol
2415 table, except for section symbols. */
2416 if (*namestring
!= '.')
2417 record_minimal_symbol
2418 (reader
, namestring
, symbol
.n_value
,
2419 sclass
== C_HIDEXT
? mst_file_bss
: mst_bss
,
2420 symbol
.n_scnum
, objfile
);
2432 unsigned int symnum_before
;
2434 symnum_before
= ssymnum
;
2435 swap_sym (&symbol
, &main_aux
[0], &namestring
, &sraw_symbol
,
2438 /* See if the last csect needs to be recorded. */
2440 if (last_csect_name
&& !misc_func_recorded
)
2442 /* If no misc. function recorded in the last seen csect, enter
2443 it as a function. This will take care of functions like
2444 strcmp() compiled by xlc. */
2446 record_minimal_symbol (reader
, last_csect_name
, last_csect_val
,
2447 mst_text
, last_csect_sec
, objfile
);
2448 misc_func_recorded
= 1;
2453 xcoff_end_psymtab (objfile
, pst
, psymtab_include_list
,
2454 includes_used
, symnum_before
,
2455 dependency_list
, dependencies_used
,
2458 dependencies_used
= 0;
2460 first_fun_line_offset
= 0;
2462 /* XCOFF, according to the AIX 3.2 documentation, puts the
2463 filename in cs->c_name. But xlc 1.3.0.2 has decided to
2464 do things the standard COFF way and put it in the auxent.
2465 We use the auxent if the symbol is ".file" and an auxent
2466 exists, otherwise use the symbol itself. */
2467 if (!strcmp (namestring
, ".file") && symbol
.n_numaux
> 0)
2469 filestring
= coff_getfilename (&main_aux
[0], objfile
);
2472 filestring
= namestring
;
2474 pst
= xcoff_start_psymtab (objfile
,
2477 last_csect_name
= NULL
;
2483 complaint (_("Storage class %d not recognized during scan"),
2489 /* C_FCN is .bf and .ef symbols. I think it is sufficient
2490 to handle only the C_FUN and C_EXT. */
2504 /* C_EINCL means we are switching back to the main file. But there
2505 is no reason to care; the only thing we want to know about
2506 includes is the names of all the included (.h) files. */
2511 /* I don't think C_STAT is used in xcoff; C_HIDEXT appears to be
2515 /* I don't think the name of the common block (as opposed to the
2516 variables within it) is something which is user visible
2524 /* I think we can ignore C_LSYM; types on xcoff seem to use C_DECL
2525 so C_LSYM would appear to be only for locals. */
2531 /* We probably could save a few instructions by assuming that
2532 C_LSYM, C_PSYM, etc., never have auxents. */
2533 int naux1
= symbol
.n_numaux
+ 1;
2536 sraw_symbol
+= bfd_coff_symesz (abfd
) * naux1
;
2542 /* Mark down an include file in the current psymtab. */
2543 enum language tmp_language
;
2545 swap_sym (&symbol
, &main_aux
[0], &namestring
, &sraw_symbol
,
2548 tmp_language
= deduce_language_from_filename (namestring
);
2550 /* Only change the psymtab's language if we've learned
2551 something useful (eg. tmp_language is not language_unknown).
2552 In addition, to match what start_subfile does, never change
2554 if (tmp_language
!= language_unknown
2555 && (tmp_language
!= language_c
2556 || psymtab_language
!= language_cplus
))
2557 psymtab_language
= tmp_language
;
2559 /* In C++, one may expect the same filename to come round many
2560 times, when code is coming alternately from the main file
2561 and from inline functions in other files. So I check to see
2562 if this is a file we've seen before -- either the main
2563 source file, or a previously included file.
2565 This seems to be a lot of time to be spending on N_SOL, but
2566 things like "break c-exp.y:435" need to work (I
2567 suppose the psymtab_include_list could be hashed or put
2568 in a binary tree, if profiling shows this is a major hog). */
2569 if (pst
&& strcmp (namestring
, pst
->filename
) == 0)
2575 for (i
= 0; i
< includes_used
; i
++)
2576 if (strcmp (namestring
, psymtab_include_list
[i
]) == 0)
2584 psymtab_include_list
[includes_used
++] = namestring
;
2585 if (includes_used
>= includes_allocated
)
2587 const char **orig
= psymtab_include_list
;
2589 psymtab_include_list
= (const char **)
2590 alloca ((includes_allocated
*= 2) *
2591 sizeof (const char *));
2592 memcpy (psymtab_include_list
, orig
,
2593 includes_used
* sizeof (const char *));
2598 /* The value of the C_FUN is not the address of the function (it
2599 appears to be the address before linking), but as long as it
2600 is smaller than the actual address, then find_pc_partial_function
2601 will use the minimal symbols instead. I hope. */
2610 swap_sym (&symbol
, &main_aux
[0], &namestring
, &sraw_symbol
,
2613 p
= strchr (namestring
, ':');
2615 continue; /* Not a debugging symbol. */
2617 /* Main processing section for debugging symbols which
2618 the initial read through the symbol tables needs to worry
2619 about. If we reach this point, the symbol which we are
2620 considering is definitely one we are interested in.
2621 p must also contain the (valid) index into the namestring
2622 which indicates the debugging type symbol. */
2627 if (gdbarch_static_transform_name_p (gdbarch
))
2628 namestring
= gdbarch_static_transform_name
2629 (gdbarch
, namestring
);
2631 add_psymbol_to_list (gdb::string_view (namestring
,
2633 true, VAR_DOMAIN
, LOC_STATIC
,
2634 SECT_OFF_DATA (objfile
),
2635 psymbol_placement::STATIC
,
2637 psymtab_language
, objfile
);
2641 /* The addresses in these entries are reported to be
2642 wrong. See the code that reads 'G's for symtabs. */
2643 add_psymbol_to_list (gdb::string_view (namestring
,
2645 true, VAR_DOMAIN
, LOC_STATIC
,
2646 SECT_OFF_DATA (objfile
),
2647 psymbol_placement::GLOBAL
,
2649 psymtab_language
, objfile
);
2653 /* When a 'T' entry is defining an anonymous enum, it
2654 may have a name which is the empty string, or a
2655 single space. Since they're not really defining a
2656 symbol, those shouldn't go in the partial symbol
2657 table. We do pick up the elements of such enums at
2658 'check_enum:', below. */
2659 if (p
>= namestring
+ 2
2660 || (p
== namestring
+ 1
2661 && namestring
[0] != ' '))
2663 add_psymbol_to_list (gdb::string_view (namestring
,
2665 true, STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
2666 psymbol_placement::STATIC
,
2667 0, psymtab_language
, objfile
);
2670 /* Also a typedef with the same name. */
2671 add_psymbol_to_list (gdb::string_view (namestring
,
2673 true, VAR_DOMAIN
, LOC_TYPEDEF
, -1,
2674 psymbol_placement::STATIC
,
2675 0, psymtab_language
, objfile
);
2682 if (p
!= namestring
) /* a name is there, not just :T... */
2684 add_psymbol_to_list (gdb::string_view (namestring
,
2686 true, VAR_DOMAIN
, LOC_TYPEDEF
, -1,
2687 psymbol_placement::STATIC
,
2688 0, psymtab_language
, objfile
);
2691 /* If this is an enumerated type, we need to
2692 add all the enum constants to the partial symbol
2693 table. This does not cover enums without names, e.g.
2694 "enum {a, b} c;" in C, but fortunately those are
2695 rare. There is no way for GDB to find those from the
2696 enum type without spending too much time on it. Thus
2697 to solve this problem, the compiler needs to put out the
2698 enum in a nameless type. GCC2 does this. */
2700 /* We are looking for something of the form
2701 <name> ":" ("t" | "T") [<number> "="] "e"
2702 {<constant> ":" <value> ","} ";". */
2704 /* Skip over the colon and the 't' or 'T'. */
2706 /* This type may be given a number. Also, numbers can come
2707 in pairs like (0,26). Skip over it. */
2708 while ((*p
>= '0' && *p
<= '9')
2709 || *p
== '(' || *p
== ',' || *p
== ')'
2715 /* The aix4 compiler emits extra crud before the
2719 /* Skip over the type (?). */
2723 /* Skip over the colon. */
2727 /* We have found an enumerated type. */
2728 /* According to comments in read_enum_type
2729 a comma could end it instead of a semicolon.
2730 I don't know where that happens.
2732 while (*p
&& *p
!= ';' && *p
!= ',')
2736 /* Check for and handle cretinous dbx symbol name
2738 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
2739 p
= next_symbol_text (objfile
);
2741 /* Point to the character after the name
2742 of the enum constant. */
2743 for (q
= p
; *q
&& *q
!= ':'; q
++)
2745 /* Note that the value doesn't matter for
2746 enum constants in psymtabs, just in symtabs. */
2747 add_psymbol_to_list (gdb::string_view (p
, q
- p
), true,
2748 VAR_DOMAIN
, LOC_CONST
, -1,
2749 psymbol_placement::STATIC
,
2750 0, psymtab_language
, objfile
);
2751 /* Point past the name. */
2753 /* Skip over the value. */
2754 while (*p
&& *p
!= ',')
2756 /* Advance past the comma. */
2764 /* Constant, e.g. from "const" in Pascal. */
2765 add_psymbol_to_list (gdb::string_view (namestring
,
2767 true, VAR_DOMAIN
, LOC_CONST
, -1,
2768 psymbol_placement::STATIC
,
2769 0, psymtab_language
, objfile
);
2775 int name_len
= p
- namestring
;
2776 char *name
= (char *) xmalloc (name_len
+ 1);
2778 memcpy (name
, namestring
, name_len
);
2779 name
[name_len
] = '\0';
2780 function_outside_compilation_unit_complaint (name
);
2783 add_psymbol_to_list (gdb::string_view (namestring
,
2785 true, VAR_DOMAIN
, LOC_BLOCK
,
2786 SECT_OFF_TEXT (objfile
),
2787 psymbol_placement::STATIC
,
2789 psymtab_language
, objfile
);
2792 /* Global functions were ignored here, but now they
2793 are put into the global psymtab like one would expect.
2794 They're also in the minimal symbol table. */
2798 int name_len
= p
- namestring
;
2799 char *name
= (char *) xmalloc (name_len
+ 1);
2801 memcpy (name
, namestring
, name_len
);
2802 name
[name_len
] = '\0';
2803 function_outside_compilation_unit_complaint (name
);
2807 /* We need only the minimal symbols for these
2808 loader-generated definitions. Keeping the global
2809 symbols leads to "in psymbols but not in symbols"
2811 if (startswith (namestring
, "@FIX"))
2814 add_psymbol_to_list (gdb::string_view (namestring
,
2816 true, VAR_DOMAIN
, LOC_BLOCK
,
2817 SECT_OFF_TEXT (objfile
),
2818 psymbol_placement::GLOBAL
,
2820 psymtab_language
, objfile
);
2823 /* Two things show up here (hopefully); static symbols of
2824 local scope (static used inside braces) or extensions
2825 of structure symbols. We can ignore both. */
2839 case '#': /* For symbol identification (used in
2844 /* It is a C++ nested symbol. We don't need to record it
2845 (I don't think); if we try to look up foo::bar::baz,
2846 then symbols for the symtab containing foo should get
2847 read in, I think. */
2848 /* Someone says sun cc puts out symbols like
2849 /foo/baz/maclib::/usr/local/bin/maclib,
2850 which would get here with a symbol type of ':'. */
2854 /* Unexpected symbol descriptor. The second and
2855 subsequent stabs of a continued stab can show up
2856 here. The question is whether they ever can mimic
2857 a normal stab--it would be nice if not, since we
2858 certainly don't want to spend the time searching to
2859 the end of every string looking for a
2862 complaint (_("unknown symbol descriptor `%c'"), p
[1]);
2864 /* Ignore it; perhaps it is an extension that we don't
2874 xcoff_end_psymtab (objfile
, pst
, psymtab_include_list
, includes_used
,
2875 ssymnum
, dependency_list
,
2876 dependencies_used
, textlow_not_set
);
2879 /* Record the toc offset value of this symbol table into objfile
2880 structure. If no XMC_TC0 is found, toc_offset should be zero.
2881 Another place to obtain this information would be file auxiliary
2884 XCOFF_DATA (objfile
)->toc_offset
= toc_offset
;
2887 /* Return the toc offset value for a given objfile. */
2890 xcoff_get_toc_offset (struct objfile
*objfile
)
2893 return XCOFF_DATA (objfile
)->toc_offset
;
2897 /* Scan and build partial symbols for a symbol file.
2898 We have been initialized by a call to dbx_symfile_init, which
2899 put all the relevant info into a "struct dbx_symfile_info",
2900 hung off the objfile structure.
2902 SECTION_OFFSETS contains offsets relative to which the symbols in the
2903 various sections are (depending where the sections were actually
2907 xcoff_initial_scan (struct objfile
*objfile
, symfile_add_flags symfile_flags
)
2911 int num_symbols
; /* # of symbols */
2912 file_ptr symtab_offset
; /* symbol table and */
2913 file_ptr stringtab_offset
; /* string table file offsets */
2914 struct xcoff_symfile_info
*info
;
2918 info
= XCOFF_DATA (objfile
);
2919 symfile_bfd
= abfd
= objfile
->obfd
;
2920 name
= objfile_name (objfile
);
2922 num_symbols
= bfd_get_symcount (abfd
); /* # of symbols */
2923 symtab_offset
= obj_sym_filepos (abfd
); /* symbol table file offset */
2924 stringtab_offset
= symtab_offset
+
2925 num_symbols
* coff_data (abfd
)->local_symesz
;
2927 info
->min_lineno_offset
= 0;
2928 info
->max_lineno_offset
= 0;
2929 bfd_map_over_sections (abfd
, find_linenos
, info
);
2931 if (num_symbols
> 0)
2933 /* Read the string table. */
2934 init_stringtab (abfd
, stringtab_offset
, objfile
);
2936 /* Read the .debug section, if present and if we're not ignoring
2938 if (!(objfile
->flags
& OBJF_READNEVER
))
2940 struct bfd_section
*secp
;
2941 bfd_size_type length
;
2942 bfd_byte
*debugsec
= NULL
;
2944 secp
= bfd_get_section_by_name (abfd
, ".debug");
2947 length
= bfd_section_size (secp
);
2951 = (bfd_byte
*) obstack_alloc (&objfile
->objfile_obstack
,
2954 if (!bfd_get_full_section_contents (abfd
, secp
, &debugsec
))
2956 error (_("Error reading .debug section of `%s': %s"),
2957 name
, bfd_errmsg (bfd_get_error ()));
2961 info
->debugsec
= (char *) debugsec
;
2965 /* Read the symbols. We keep them in core because we will want to
2966 access them randomly in read_symbol*. */
2967 val
= bfd_seek (abfd
, symtab_offset
, SEEK_SET
);
2969 error (_("Error reading symbols from %s: %s"),
2970 name
, bfd_errmsg (bfd_get_error ()));
2971 size
= coff_data (abfd
)->local_symesz
* num_symbols
;
2972 info
->symtbl
= (char *) obstack_alloc (&objfile
->objfile_obstack
, size
);
2973 info
->symtbl_num_syms
= num_symbols
;
2975 val
= bfd_bread (info
->symtbl
, size
, abfd
);
2977 perror_with_name (_("reading symbol table"));
2979 /* I'm not sure how how good num_symbols is; the rule of thumb in
2980 init_psymbol_list was developed for a.out. On the one hand,
2981 num_symbols includes auxents. On the other hand, it doesn't
2983 init_psymbol_list (objfile
, num_symbols
);
2985 scoped_free_pendings free_pending
;
2986 minimal_symbol_reader
reader (objfile
);
2988 /* Now that the symbol table data of the executable file are all in core,
2989 process them and define symbols accordingly. */
2991 scan_xcoff_symtab (reader
, objfile
);
2993 /* Install any minimal symbols that have been collected as the current
2994 minimal symbols for this objfile. */
2998 /* DWARF2 sections. */
3000 if (dwarf2_has_info (objfile
, &dwarf2_xcoff_names
))
3001 dwarf2_build_psymtabs (objfile
);
3003 dwarf2_build_frame_info (objfile
);
3007 xcoff_symfile_offsets (struct objfile
*objfile
,
3008 const section_addr_info
&addrs
)
3010 const char *first_section_name
;
3012 default_symfile_offsets (objfile
, addrs
);
3014 /* Oneof the weird side-effects of default_symfile_offsets is that
3015 it sometimes sets some section indices to zero for sections that,
3016 in fact do not exist. See the body of default_symfile_offsets
3017 for more info on when that happens. Undo that, as this then allows
3018 us to test whether the associated section exists or not, and then
3019 access it quickly (without searching it again). */
3021 if (objfile
->section_offsets
.empty ())
3022 return; /* Is that even possible? Better safe than sorry. */
3024 first_section_name
= bfd_section_name (objfile
->sections
[0].the_bfd_section
);
3026 if (objfile
->sect_index_text
== 0
3027 && strcmp (first_section_name
, ".text") != 0)
3028 objfile
->sect_index_text
= -1;
3030 if (objfile
->sect_index_data
== 0
3031 && strcmp (first_section_name
, ".data") != 0)
3032 objfile
->sect_index_data
= -1;
3034 if (objfile
->sect_index_bss
== 0
3035 && strcmp (first_section_name
, ".bss") != 0)
3036 objfile
->sect_index_bss
= -1;
3038 if (objfile
->sect_index_rodata
== 0
3039 && strcmp (first_section_name
, ".rodata") != 0)
3040 objfile
->sect_index_rodata
= -1;
3043 /* Register our ability to parse symbols for xcoff BFD files. */
3045 static const struct sym_fns xcoff_sym_fns
=
3048 /* It is possible that coff and xcoff should be merged as
3049 they do have fundamental similarities (for example, the extra storage
3050 classes used for stabs could presumably be recognized in any COFF file).
3051 However, in addition to obvious things like all the csect hair, there are
3052 some subtler differences between xcoffread.c and coffread.c, notably
3053 the fact that coffread.c has no need to read in all the symbols, but
3054 xcoffread.c reads all the symbols and does in fact randomly access them
3055 (in C_BSTAT and line number processing). */
3057 xcoff_new_init
, /* init anything gbl to entire symtab */
3058 xcoff_symfile_init
, /* read initial info, setup for sym_read() */
3059 xcoff_initial_scan
, /* read a symbol file into symtab */
3060 NULL
, /* sym_read_psymbols */
3061 xcoff_symfile_finish
, /* finished with file, cleanup */
3062 xcoff_symfile_offsets
, /* xlate offsets ext->int form */
3063 default_symfile_segments
, /* Get segment information from a file. */
3064 aix_process_linenos
,
3065 default_symfile_relocate
, /* Relocate a debug section. */
3066 NULL
, /* sym_probe_fns */
3070 /* Same as xcoff_get_n_import_files, but for core files. */
3073 xcoff_get_core_n_import_files (bfd
*abfd
)
3075 asection
*sect
= bfd_get_section_by_name (abfd
, ".ldinfo");
3077 file_ptr offset
= 0;
3081 return -1; /* Not a core file. */
3083 for (offset
= 0; offset
< bfd_section_size (sect
);)
3089 if (!bfd_get_section_contents (abfd
, sect
, buf
, offset
, 4))
3091 next
= bfd_get_32 (abfd
, buf
);
3093 break; /* This is the last entry. */
3097 /* Return the number of entries, excluding the first one, which is
3098 the path to the executable that produced this core file. */
3099 return n_entries
- 1;
3102 /* Return the number of import files (shared libraries) that the given
3103 BFD depends on. Return -1 if this number could not be computed. */
3106 xcoff_get_n_import_files (bfd
*abfd
)
3108 asection
*sect
= bfd_get_section_by_name (abfd
, ".loader");
3112 /* If the ".loader" section does not exist, the objfile is probably
3113 not an executable. Might be a core file... */
3115 return xcoff_get_core_n_import_files (abfd
);
3117 /* The number of entries in the Import Files Table is stored in
3118 field l_nimpid. This field is always at offset 16, and is
3119 always 4 bytes long. Read those 4 bytes. */
3121 if (!bfd_get_section_contents (abfd
, sect
, buf
, 16, 4))
3123 l_nimpid
= bfd_get_32 (abfd
, buf
);
3125 /* By convention, the first entry is the default LIBPATH value
3126 to be used by the system loader, so it does not count towards
3127 the number of import files. */
3128 return l_nimpid
- 1;
3131 void _initialize_xcoffread ();
3133 _initialize_xcoffread ()
3135 add_symtab_fns (bfd_target_xcoff_flavour
, &xcoff_sym_fns
);