1 /* Read AIX xcoff symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
5 Derived from coffread.c, dbxread.c, and a lot of hacking.
6 Contributed by IBM Corporation.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
28 #include <sys/types.h>
31 #include "gdb_string.h"
33 #include <sys/param.h>
39 #include "coff/internal.h"
40 #include "libcoff.h" /* FIXME, internal data from BFD */
41 #include "coff/xcoff.h"
43 #include "coff/rs6000.h"
50 #include "stabsread.h"
51 #include "expression.h"
52 #include "complaints.h"
54 #include "gdb-stabs.h"
56 /* For interface with stabsread.c. */
57 #include "aout/stab_gnu.h"
60 /* We put a pointer to this structure in the read_symtab_private field
66 /* First symbol number for this file. */
70 /* Number of symbols in the section of the symbol table devoted to
71 this file's symbols (actually, the section bracketed may contain
72 more than just this file's symbols). If numsyms is 0, the only
73 reason for this thing's existence is the dependency list. Nothing
74 else will happen when it is read in. */
78 /* Position of the start of the line number information for this psymtab. */
79 unsigned int lineno_off
;
82 /* Remember what we deduced to be the source language of this psymtab. */
84 static enum language psymtab_language
= language_unknown
;
87 /* Simplified internal version of coff symbol table information */
92 int c_symnum
; /* symbol number of this entry */
93 int c_naux
; /* 0 if syment only, 1 if syment + auxent */
95 unsigned char c_sclass
;
100 /* last function's saved coff symbol `cs' */
102 static struct coff_symbol fcn_cs_saved
;
104 static bfd
*symfile_bfd
;
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
111 static CORE_ADDR cur_src_end_addr
;
113 /* Core address of the end of the first object file. */
115 static CORE_ADDR first_object_file_end
;
117 /* initial symbol-table-debug-string vector length */
119 #define INITIAL_STABVECTOR_LENGTH 40
121 /* Nonzero if within a function (so symbols should be local,
122 if nothing says specifically). */
126 /* Size of a COFF symbol. I think it is always 18, so I'm not sure
127 there is any reason not to just use a #define, but might as well
128 ask BFD for the size and store it here, I guess. */
130 static unsigned local_symesz
;
132 struct coff_symfile_info
134 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
135 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
137 /* Pointer to the string table. */
140 /* Pointer to debug section. */
143 /* Pointer to the a.out symbol table. */
146 /* Number of symbols in symtbl. */
149 /* Offset in data section to TOC anchor. */
150 CORE_ADDR toc_offset
;
153 static struct deprecated_complaint storclass_complaint
=
154 {"Unexpected storage class: %d", 0, 0};
156 static struct deprecated_complaint bf_notfound_complaint
=
157 {"line numbers off, `.bf' symbol not found", 0, 0};
159 static struct deprecated_complaint ef_complaint
=
160 {"Mismatched .ef symbol ignored starting at symnum %d", 0, 0};
162 static struct deprecated_complaint eb_complaint
=
163 {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
165 static void xcoff_initial_scan (struct objfile
*, int);
167 static void scan_xcoff_symtab (struct objfile
*);
169 static char *xcoff_next_symbol_text (struct objfile
*);
171 static void record_include_begin (struct coff_symbol
*);
174 enter_line_range (struct subfile
*, unsigned, unsigned,
175 CORE_ADDR
, CORE_ADDR
, unsigned *);
177 static void init_stringtab (bfd
*, file_ptr
, struct objfile
*);
179 static void xcoff_symfile_init (struct objfile
*);
181 static void xcoff_new_init (struct objfile
*);
183 static void xcoff_symfile_finish (struct objfile
*);
186 xcoff_symfile_offsets (struct objfile
*, struct section_addr_info
*addrs
);
188 static void find_linenos (bfd
*, sec_ptr
, PTR
);
190 static char *coff_getfilename (union internal_auxent
*, struct objfile
*);
192 static void read_symbol (struct internal_syment
*, int);
194 static int read_symbol_lineno (int);
196 static CORE_ADDR
read_symbol_nvalue (int);
198 static struct symbol
*process_xcoff_symbol (struct coff_symbol
*,
201 static void read_xcoff_symtab (struct partial_symtab
*);
204 static void add_stab_to_list (char *, struct pending_stabs
**);
207 static int compare_lte (const void *, const void *);
209 static struct linetable
*arrange_linetable (struct linetable
*);
211 static void record_include_end (struct coff_symbol
*);
213 static void process_linenos (CORE_ADDR
, CORE_ADDR
);
216 /* Translate from a COFF section number (target_index) to a SECT_OFF_*
218 static int secnum_to_section (int, struct objfile
*);
219 static asection
*secnum_to_bfd_section (int, struct objfile
*);
221 struct find_targ_sec_arg
226 struct objfile
*objfile
;
229 static void find_targ_sec (bfd
*, asection
*, void *);
232 find_targ_sec (bfd
*abfd
, asection
*sect
, PTR obj
)
234 struct find_targ_sec_arg
*args
= (struct find_targ_sec_arg
*) obj
;
235 struct objfile
*objfile
= args
->objfile
;
236 if (sect
->target_index
== args
->targ_index
)
238 /* This is the section. Figure out what SECT_OFF_* code it is. */
239 if (bfd_get_section_flags (abfd
, sect
) & SEC_CODE
)
240 *args
->resultp
= SECT_OFF_TEXT (objfile
);
241 else if (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
)
242 *args
->resultp
= SECT_OFF_DATA (objfile
);
244 *args
->resultp
= sect
->index
;
245 *args
->bfd_sect
= sect
;
249 /* Return the section number (SECT_OFF_*) that CS points to. */
251 secnum_to_section (int secnum
, struct objfile
*objfile
)
253 int off
= SECT_OFF_TEXT (objfile
);
254 asection
*sect
= NULL
;
255 struct find_targ_sec_arg args
;
256 args
.targ_index
= secnum
;
258 args
.bfd_sect
= §
;
259 args
.objfile
= objfile
;
260 bfd_map_over_sections (objfile
->obfd
, find_targ_sec
, &args
);
264 /* Return the BFD section that CS points to. */
266 secnum_to_bfd_section (int secnum
, struct objfile
*objfile
)
268 int off
= SECT_OFF_TEXT (objfile
);
269 asection
*sect
= NULL
;
270 struct find_targ_sec_arg args
;
271 args
.targ_index
= secnum
;
273 args
.bfd_sect
= §
;
274 args
.objfile
= objfile
;
275 bfd_map_over_sections (objfile
->obfd
, find_targ_sec
, &args
);
279 /* add a given stab string into given stab vector. */
284 add_stab_to_list (char *stabname
, struct pending_stabs
**stabvector
)
286 if (*stabvector
== NULL
)
288 *stabvector
= (struct pending_stabs
*)
289 xmalloc (sizeof (struct pending_stabs
) +
290 INITIAL_STABVECTOR_LENGTH
* sizeof (char *));
291 (*stabvector
)->count
= 0;
292 (*stabvector
)->length
= INITIAL_STABVECTOR_LENGTH
;
294 else if ((*stabvector
)->count
>= (*stabvector
)->length
)
296 (*stabvector
)->length
+= INITIAL_STABVECTOR_LENGTH
;
297 *stabvector
= (struct pending_stabs
*)
298 xrealloc ((char *) *stabvector
, sizeof (struct pending_stabs
) +
299 (*stabvector
)->length
* sizeof (char *));
301 (*stabvector
)->stab
[(*stabvector
)->count
++] = stabname
;
306 /* Linenos are processed on a file-by-file basis.
310 1) xlc (IBM's native c compiler) postpones static function code
311 emission to the end of a compilation unit. This way it can
312 determine if those functions (statics) are needed or not, and
313 can do some garbage collection (I think). This makes line
314 numbers and corresponding addresses unordered, and we end up
315 with a line table like:
332 and that breaks gdb's binary search on line numbers, if the
333 above table is not sorted on line numbers. And that sort
334 should be on function based, since gcc can emit line numbers
337 10 0x100 - for the init/test part of a for stmt.
340 10 0x400 - for the increment part of a for stmt.
342 arrange_linetable() will do this sorting.
344 2) aix symbol table might look like:
346 c_file // beginning of a new file
347 .bi // beginning of include file
348 .ei // end of include file
352 basically, .bi/.ei pairs do not necessarily encapsulate
353 their scope. They need to be recorded, and processed later
354 on when we come the end of the compilation unit.
355 Include table (inclTable) and process_linenos() handle
361 /* compare line table entry addresses. */
364 compare_lte (const void *lte1p
, const void *lte2p
)
366 struct linetable_entry
*lte1
= (struct linetable_entry
*) lte1p
;
367 struct linetable_entry
*lte2
= (struct linetable_entry
*) lte2p
;
368 return lte1
->pc
- lte2
->pc
;
371 /* Given a line table with function entries are marked, arrange its functions
372 in ascending order and strip off function entry markers and return it in
373 a newly created table. If the old one is good enough, return the old one. */
374 /* FIXME: I think all this stuff can be replaced by just passing
375 sort_linevec = 1 to end_symtab. */
377 static struct linetable
*
378 arrange_linetable (struct linetable
*oldLineTb
)
380 int ii
, jj
, newline
, /* new line count */
381 function_count
; /* # of functions */
383 struct linetable_entry
*fentry
; /* function entry vector */
384 int fentry_size
; /* # of function entries */
385 struct linetable
*newLineTb
; /* new line table */
387 #define NUM_OF_FUNCTIONS 20
389 fentry_size
= NUM_OF_FUNCTIONS
;
390 fentry
= (struct linetable_entry
*)
391 xmalloc (fentry_size
* sizeof (struct linetable_entry
));
393 for (function_count
= 0, ii
= 0; ii
< oldLineTb
->nitems
; ++ii
)
396 if (oldLineTb
->item
[ii
].line
== 0)
397 { /* function entry found. */
399 if (function_count
>= fentry_size
)
400 { /* make sure you have room. */
402 fentry
= (struct linetable_entry
*)
403 xrealloc (fentry
, fentry_size
* sizeof (struct linetable_entry
));
405 fentry
[function_count
].line
= ii
;
406 fentry
[function_count
].pc
= oldLineTb
->item
[ii
].pc
;
411 if (function_count
== 0)
416 else if (function_count
> 1)
417 qsort (fentry
, function_count
, sizeof (struct linetable_entry
), compare_lte
);
419 /* allocate a new line table. */
420 newLineTb
= (struct linetable
*)
422 (sizeof (struct linetable
) +
423 (oldLineTb
->nitems
- function_count
) * sizeof (struct linetable_entry
));
425 /* if line table does not start with a function beginning, copy up until
429 if (oldLineTb
->item
[0].line
!= 0)
431 newline
< oldLineTb
->nitems
&& oldLineTb
->item
[newline
].line
; ++newline
)
432 newLineTb
->item
[newline
] = oldLineTb
->item
[newline
];
434 /* Now copy function lines one by one. */
436 for (ii
= 0; ii
< function_count
; ++ii
)
438 for (jj
= fentry
[ii
].line
+ 1;
439 jj
< oldLineTb
->nitems
&& oldLineTb
->item
[jj
].line
!= 0;
441 newLineTb
->item
[newline
] = oldLineTb
->item
[jj
];
444 newLineTb
->nitems
= oldLineTb
->nitems
- function_count
;
448 /* include file support: C_BINCL/C_EINCL pairs will be kept in the
449 following `IncludeChain'. At the end of each symtab (end_symtab),
450 we will determine if we should create additional symtab's to
451 represent if (the include files. */
454 typedef struct _inclTable
456 char *name
; /* include filename */
458 /* Offsets to the line table. end points to the last entry which is
459 part of this include file. */
462 struct subfile
*subfile
;
463 unsigned funStartLine
; /* start line # of its function */
467 #define INITIAL_INCLUDE_TABLE_LENGTH 20
468 static InclTable
*inclTable
; /* global include table */
469 static int inclIndx
; /* last entry to table */
470 static int inclLength
; /* table length */
471 static int inclDepth
; /* nested include depth */
473 static void allocate_include_entry (void);
476 record_include_begin (struct coff_symbol
*cs
)
480 /* In xcoff, we assume include files cannot be nested (not in .c files
481 of course, but in corresponding .s files.). */
483 /* This can happen with old versions of GCC.
484 GCC 2.3.3-930426 does not exhibit this on a test case which
485 a user said produced the message for him. */
486 static struct deprecated_complaint msg
=
487 {"Nested C_BINCL symbols", 0, 0};
492 allocate_include_entry ();
494 inclTable
[inclIndx
].name
= cs
->c_name
;
495 inclTable
[inclIndx
].begin
= cs
->c_value
;
499 record_include_end (struct coff_symbol
*cs
)
505 static struct deprecated_complaint msg
=
506 {"Mismatched C_BINCL/C_EINCL pair", 0, 0};
510 allocate_include_entry ();
512 pTbl
= &inclTable
[inclIndx
];
513 pTbl
->end
= cs
->c_value
;
520 allocate_include_entry (void)
522 if (inclTable
== NULL
)
524 inclTable
= (InclTable
*)
525 xmalloc (sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
527 '\0', sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
528 inclLength
= INITIAL_INCLUDE_TABLE_LENGTH
;
531 else if (inclIndx
>= inclLength
)
533 inclLength
+= INITIAL_INCLUDE_TABLE_LENGTH
;
534 inclTable
= (InclTable
*)
535 xrealloc (inclTable
, sizeof (InclTable
) * inclLength
);
536 memset (inclTable
+ inclLength
- INITIAL_INCLUDE_TABLE_LENGTH
,
537 '\0', sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
541 /* Global variable to pass the psymtab down to all the routines involved
542 in psymtab to symtab processing. */
543 static struct partial_symtab
*this_symtab_psymtab
;
545 /* given the start and end addresses of a compilation unit (or a csect,
546 at times) process its lines and create appropriate line vectors. */
549 process_linenos (CORE_ADDR start
, CORE_ADDR end
)
552 file_ptr max_offset
=
553 ((struct coff_symfile_info
*) this_symtab_psymtab
->objfile
->sym_private
)
556 /* subfile structure for the main compilation unit. */
557 struct subfile main_subfile
;
559 /* In the main source file, any time we see a function entry, we
560 reset this variable to function's absolute starting line number.
561 All the following line numbers in the function are relative to
562 this, and we record absolute line numbers in record_line(). */
564 unsigned int main_source_baseline
= 0;
569 ((struct symloc
*) this_symtab_psymtab
->read_symtab_private
)->lineno_off
;
571 goto return_after_cleanup
;
573 memset (&main_subfile
, '\0', sizeof (main_subfile
));
576 /* All source lines were in the main source file. None in include files. */
578 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
579 &main_source_baseline
);
583 /* There was source with line numbers in include files. */
586 coff_data (this_symtab_psymtab
->objfile
->obfd
)->local_linesz
;
587 main_source_baseline
= 0;
589 for (ii
= 0; ii
< inclIndx
; ++ii
)
591 struct subfile
*tmpSubfile
;
593 /* If there is main file source before include file, enter it. */
594 if (offset
< inclTable
[ii
].begin
)
597 (&main_subfile
, offset
, inclTable
[ii
].begin
- linesz
,
598 start
, 0, &main_source_baseline
);
601 /* Have a new subfile for the include file. */
603 tmpSubfile
= inclTable
[ii
].subfile
=
604 (struct subfile
*) xmalloc (sizeof (struct subfile
));
606 memset (tmpSubfile
, '\0', sizeof (struct subfile
));
607 firstLine
= &(inclTable
[ii
].funStartLine
);
609 /* Enter include file's lines now. */
610 enter_line_range (tmpSubfile
, inclTable
[ii
].begin
,
611 inclTable
[ii
].end
, start
, 0, firstLine
);
613 if (offset
<= inclTable
[ii
].end
)
614 offset
= inclTable
[ii
].end
+ linesz
;
617 /* All the include files' line have been processed at this point. Now,
618 enter remaining lines of the main file, if any left. */
619 if (offset
< max_offset
+ 1 - linesz
)
621 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
622 &main_source_baseline
);
626 /* Process main file's line numbers. */
627 if (main_subfile
.line_vector
)
629 struct linetable
*lineTb
, *lv
;
631 lv
= main_subfile
.line_vector
;
633 /* Line numbers are not necessarily ordered. xlc compilation will
634 put static function to the end. */
636 lineTb
= arrange_linetable (lv
);
639 current_subfile
->line_vector
= (struct linetable
*)
640 xrealloc (lv
, (sizeof (struct linetable
)
641 + lv
->nitems
* sizeof (struct linetable_entry
)));
646 current_subfile
->line_vector
= lineTb
;
649 current_subfile
->line_vector_length
=
650 current_subfile
->line_vector
->nitems
;
653 /* Now, process included files' line numbers. */
655 for (ii
= 0; ii
< inclIndx
; ++ii
)
657 if ((inclTable
[ii
].subfile
)->line_vector
) /* Useless if!!! FIXMEmgo */
659 struct linetable
*lineTb
, *lv
;
661 lv
= (inclTable
[ii
].subfile
)->line_vector
;
663 /* Line numbers are not necessarily ordered. xlc compilation will
664 put static function to the end. */
666 lineTb
= arrange_linetable (lv
);
670 /* For the same include file, we might want to have more than one
671 subfile. This happens if we have something like:
679 while foo.h including code in it. (stupid but possible)
680 Since start_subfile() looks at the name and uses an
681 existing one if finds, we need to provide a fake name and
685 start_subfile (inclTable
[ii
].name
, (char *) 0);
688 /* Pick a fake name that will produce the same results as this
689 one when passed to deduce_language_from_filename. Kludge on
691 char *fakename
= strrchr (inclTable
[ii
].name
, '.');
692 if (fakename
== NULL
)
694 start_subfile (fakename
, (char *) 0);
695 xfree (current_subfile
->name
);
697 current_subfile
->name
= xstrdup (inclTable
[ii
].name
);
702 current_subfile
->line_vector
=
703 (struct linetable
*) xrealloc
704 (lv
, (sizeof (struct linetable
)
705 + lv
->nitems
* sizeof (struct linetable_entry
)));
711 current_subfile
->line_vector
= lineTb
;
714 current_subfile
->line_vector_length
=
715 current_subfile
->line_vector
->nitems
;
716 start_subfile (pop_subfile (), (char *) 0);
720 return_after_cleanup
:
722 /* We don't want to keep alloc/free'ing the global include file table. */
725 /* Start with a fresh subfile structure for the next file. */
726 memset (&main_subfile
, '\0', sizeof (struct subfile
));
730 aix_process_linenos (void)
732 /* process line numbers and enter them into line vector */
733 process_linenos (last_source_start_addr
, cur_src_end_addr
);
737 /* Enter a given range of lines into the line vector.
738 can be called in the following two ways:
739 enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or
740 enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine)
742 endoffset points to the last line table entry that we should pay
746 enter_line_range (struct subfile
*subfile
, unsigned beginoffset
, unsigned endoffset
, /* offsets to line table */
747 CORE_ADDR startaddr
, /* offsets to line table */
748 CORE_ADDR endaddr
, unsigned *firstLine
)
750 unsigned int curoffset
;
753 struct internal_lineno int_lnno
;
754 unsigned int limit_offset
;
758 if (endoffset
== 0 && startaddr
== 0 && endaddr
== 0)
760 curoffset
= beginoffset
;
762 ((struct coff_symfile_info
*) this_symtab_psymtab
->objfile
->sym_private
)
767 if (endoffset
>= limit_offset
)
769 static struct deprecated_complaint msg
=
770 {"Bad line table offset in C_EINCL directive", 0, 0};
774 limit_offset
= endoffset
;
779 abfd
= this_symtab_psymtab
->objfile
->obfd
;
780 linesz
= coff_data (abfd
)->local_linesz
;
781 ext_lnno
= alloca (linesz
);
783 while (curoffset
<= limit_offset
)
785 bfd_seek (abfd
, curoffset
, SEEK_SET
);
786 bfd_bread (ext_lnno
, linesz
, abfd
);
787 bfd_coff_swap_lineno_in (abfd
, ext_lnno
, &int_lnno
);
789 /* Find the address this line represents. */
790 addr
= (int_lnno
.l_lnno
791 ? int_lnno
.l_addr
.l_paddr
792 : read_symbol_nvalue (int_lnno
.l_addr
.l_symndx
));
793 addr
+= ANOFFSET (this_symtab_psymtab
->objfile
->section_offsets
,
794 SECT_OFF_TEXT (this_symtab_psymtab
->objfile
));
796 if (addr
< startaddr
|| (endaddr
&& addr
>= endaddr
))
799 if (int_lnno
.l_lnno
== 0)
801 *firstLine
= read_symbol_lineno (int_lnno
.l_addr
.l_symndx
);
802 record_line (subfile
, 0, addr
);
806 record_line (subfile
, *firstLine
+ int_lnno
.l_lnno
, addr
);
812 /* Save the vital information for use when closing off the current file.
813 NAME is the file name the symbols came from, START_ADDR is the first
814 text address for the file, and SIZE is the number of bytes of text. */
816 #define complete_symtab(name, start_addr) { \
817 last_source_file = savestring (name, strlen (name)); \
818 last_source_start_addr = start_addr; \
822 /* Refill the symbol table input buffer
823 and set the variables that control fetching entries from it.
824 Reports an error if no data available.
825 This function can read past the end of the symbol table
826 (into the string table) but this does no harm. */
828 /* Reading symbol table has to be fast! Keep the followings as macros, rather
831 #define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, SECTION, OBJFILE) \
835 if (namestr[0] == '.') ++namestr; \
836 prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \
837 (char *)NULL, (SECTION), (asection *)NULL, (OBJFILE)); \
838 misc_func_recorded = 1; \
842 /* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
843 nested. At any given time, a symbol can only be in one static block.
844 This is the base address of current static block, zero if non exists. */
846 static int static_block_base
= 0;
848 /* Section number for the current static block. */
850 static int static_block_section
= -1;
852 /* true if space for symbol name has been allocated. */
854 static int symname_alloced
= 0;
856 /* Next symbol to read. Pointer into raw seething symbol table. */
858 static char *raw_symbol
;
860 /* This is the function which stabsread.c calls to get symbol
864 xcoff_next_symbol_text (struct objfile
*objfile
)
866 struct internal_syment symbol
;
867 static struct deprecated_complaint msg
=
868 {"Unexpected symbol continuation", 0, 0};
870 /* FIXME: is this the same as the passed arg? */
871 objfile
= this_symtab_psymtab
->objfile
;
873 bfd_coff_swap_sym_in (objfile
->obfd
, raw_symbol
, &symbol
);
878 /* Return something which points to '\0' and hope the symbol reading
879 code does something reasonable. */
882 else if (symbol
.n_sclass
& 0x80)
885 ((struct coff_symfile_info
*) objfile
->sym_private
)->debugsec
888 coff_data (objfile
->obfd
)->local_symesz
;
895 /* Return something which points to '\0' and hope the symbol reading
896 code does something reasonable. */
902 /* Read symbols for a given partial symbol table. */
905 read_xcoff_symtab (struct partial_symtab
*pst
)
907 struct objfile
*objfile
= pst
->objfile
;
908 bfd
*abfd
= objfile
->obfd
;
909 char *raw_auxptr
; /* Pointer to first raw aux entry for sym */
910 char *strtbl
= ((struct coff_symfile_info
*) objfile
->sym_private
)->strtbl
;
912 ((struct coff_symfile_info
*) objfile
->sym_private
)->debugsec
;
913 char *debugfmt
= bfd_xcoff_is_xcoff64 (abfd
) ? "XCOFF64" : "XCOFF";
915 struct internal_syment symbol
[1];
916 union internal_auxent main_aux
;
917 struct coff_symbol cs
[1];
918 CORE_ADDR file_start_addr
= 0;
919 CORE_ADDR file_end_addr
= 0;
921 int next_file_symnum
= -1;
922 unsigned int max_symnum
;
923 int just_started
= 1;
925 int fcn_start_addr
= 0;
927 struct coff_symbol fcn_stab_saved
;
929 /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
930 union internal_auxent fcn_aux_saved
;
931 struct context_stack
*new;
933 char *filestring
= " _start_ "; /* Name of the current file. */
935 char *last_csect_name
; /* last seen csect's name and value */
936 CORE_ADDR last_csect_val
;
939 this_symtab_psymtab
= pst
;
941 /* Get the appropriate COFF "constants" related to the file we're
943 local_symesz
= coff_data (abfd
)->local_symesz
;
945 last_source_file
= NULL
;
950 start_symtab (filestring
, (char *) NULL
, file_start_addr
);
951 record_debugformat (debugfmt
);
952 symnum
= ((struct symloc
*) pst
->read_symtab_private
)->first_symnum
;
954 symnum
+ ((struct symloc
*) pst
->read_symtab_private
)->numsyms
;
955 first_object_file_end
= 0;
958 ((struct coff_symfile_info
*) objfile
->sym_private
)->symtbl
959 + symnum
* local_symesz
;
961 while (symnum
< max_symnum
)
964 QUIT
; /* make this command interruptable. */
966 /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
967 /* read one symbol into `cs' structure. After processing the
968 whole symbol table, only string table will be kept in memory,
969 symbol table and debug section of xcoff will be freed. Thus
970 we can mark symbols with names in string table as
975 /* Swap and align the symbol into a reasonable C structure. */
976 bfd_coff_swap_sym_in (abfd
, raw_symbol
, symbol
);
978 cs
->c_symnum
= symnum
;
979 cs
->c_naux
= symbol
->n_numaux
;
980 if (symbol
->n_zeroes
)
983 /* We must use the original, unswapped, name here so the name field
984 pointed to by cs->c_name will persist throughout xcoffread. If
985 we use the new field, it gets overwritten for each symbol. */
986 cs
->c_name
= ((struct external_syment
*) raw_symbol
)->e
.e_name
;
987 /* If it's exactly E_SYMNMLEN characters long it isn't
989 if (cs
->c_name
[E_SYMNMLEN
- 1] != '\0')
992 p
= obstack_alloc (&objfile
->symbol_obstack
, E_SYMNMLEN
+ 1);
993 strncpy (p
, cs
->c_name
, E_SYMNMLEN
);
994 p
[E_SYMNMLEN
] = '\0';
999 else if (symbol
->n_sclass
& 0x80)
1001 cs
->c_name
= debugsec
+ symbol
->n_offset
;
1002 symname_alloced
= 0;
1006 /* in string table */
1007 cs
->c_name
= strtbl
+ (int) symbol
->n_offset
;
1008 symname_alloced
= 1;
1010 cs
->c_value
= symbol
->n_value
;
1011 cs
->c_sclass
= symbol
->n_sclass
;
1012 cs
->c_secnum
= symbol
->n_scnum
;
1013 cs
->c_type
= (unsigned) symbol
->n_type
;
1015 raw_symbol
+= local_symesz
;
1018 /* Save addr of first aux entry. */
1019 raw_auxptr
= raw_symbol
;
1021 /* Skip all the auxents associated with this symbol. */
1022 for (ii
= symbol
->n_numaux
; ii
; --ii
)
1024 raw_symbol
+= coff_data (abfd
)->local_auxesz
;
1029 /* if symbol name starts with ".$" or "$", ignore it. */
1030 if (cs
->c_name
[0] == '$'
1031 || (cs
->c_name
[1] == '$' && cs
->c_name
[0] == '.'))
1034 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
1036 if (last_source_file
)
1039 end_symtab (cur_src_end_addr
, objfile
, SECT_OFF_TEXT (objfile
));
1044 start_symtab ("_globals_", (char *) NULL
, (CORE_ADDR
) 0);
1045 record_debugformat (debugfmt
);
1046 cur_src_end_addr
= first_object_file_end
;
1047 /* done with all files, everything from here on is globals */
1050 if ((cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_HIDEXT
)
1053 /* Dealing with a symbol with a csect entry. */
1055 #define CSECT(PP) ((PP)->x_csect)
1056 #define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
1057 #define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1058 #define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1059 #define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1061 /* Convert the auxent to something we can access. */
1062 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1063 0, cs
->c_naux
, &main_aux
);
1065 switch (CSECT_SMTYP (&main_aux
))
1069 /* Ignore all external references. */
1073 /* A section description. */
1075 switch (CSECT_SCLAS (&main_aux
))
1081 /* A program csect is seen. We have to allocate one
1082 symbol table for each program csect. Normally gdb
1083 prefers one symtab for each source file. In case
1084 of AIX, one source file might include more than one
1085 [PR] csect, and they don't have to be adjacent in
1086 terms of the space they occupy in memory. Thus, one
1087 single source file might get fragmented in the
1088 memory and gdb's file start and end address
1089 approach does not work! GCC (and I think xlc) seem
1090 to put all the code in the unnamed program csect. */
1092 if (last_csect_name
)
1094 complete_symtab (filestring
, file_start_addr
);
1095 cur_src_end_addr
= file_end_addr
;
1096 end_symtab (file_end_addr
, objfile
, SECT_OFF_TEXT (objfile
));
1099 /* Give all csects for this source file the same
1101 start_symtab (filestring
, NULL
, (CORE_ADDR
) 0);
1102 record_debugformat (debugfmt
);
1105 /* If this is the very first csect seen,
1106 basically `__start'. */
1109 first_object_file_end
1110 = cs
->c_value
+ CSECT_LEN (&main_aux
);
1115 cs
->c_value
+ ANOFFSET (objfile
->section_offsets
,
1116 SECT_OFF_TEXT (objfile
));
1117 file_end_addr
= file_start_addr
+ CSECT_LEN (&main_aux
);
1119 if (cs
->c_name
&& (cs
->c_name
[0] == '.'
1120 || cs
->c_name
[0] == '@'))
1122 last_csect_name
= cs
->c_name
;
1123 last_csect_val
= cs
->c_value
;
1124 last_csect_sec
= secnum_to_section (cs
->c_secnum
, objfile
);
1129 /* All other symbols are put into the minimal symbol
1142 /* Ignore the symbol. */
1150 switch (CSECT_SCLAS (&main_aux
))
1153 /* a function entry point. */
1154 function_entry_point
:
1156 fcn_start_addr
= cs
->c_value
;
1158 /* save the function header info, which will be used
1159 when `.bf' is seen. */
1161 fcn_aux_saved
= main_aux
;
1165 /* shared library function trampoline code entry point. */
1169 /* The symbols often have the same names as debug symbols for
1170 functions, and confuse lookup_symbol. */
1174 /* xlc puts each variable in a separate csect, so we get
1175 an XTY_SD for each variable. But gcc puts several
1176 variables in a csect, so that each variable only gets
1177 an XTY_LD. This will typically be XMC_RW; I suspect
1178 XMC_RO and XMC_BS might be possible too.
1179 These variables are put in the minimal symbol table
1186 /* Common symbols are put into the minimal symbol table only. */
1194 /* If explicitly specified as a function, treat is as one. This check
1195 evaluates to true for @FIX* bigtoc CSECT symbols, so it must occur
1196 after the above CSECT check. */
1197 if (ISFCN (cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
1199 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1200 0, cs
->c_naux
, &main_aux
);
1201 goto function_entry_point
;
1204 switch (cs
->c_sclass
)
1209 /* c_value field contains symnum of next .file entry in table
1210 or symnum of first global after last .file. */
1212 next_file_symnum
= cs
->c_value
;
1214 /* Complete symbol table for last object file containing
1215 debugging information. */
1217 /* Whether or not there was a csect in the previous file, we
1218 have to call `end_stabs' and `start_stabs' to reset
1219 type_vector, line_vector, etc. structures. */
1221 complete_symtab (filestring
, file_start_addr
);
1222 cur_src_end_addr
= file_end_addr
;
1223 end_symtab (file_end_addr
, objfile
, SECT_OFF_TEXT (objfile
));
1226 /* XCOFF, according to the AIX 3.2 documentation, puts the filename
1227 in cs->c_name. But xlc 1.3.0.2 has decided to do things the
1228 standard COFF way and put it in the auxent. We use the auxent if
1229 the symbol is ".file" and an auxent exists, otherwise use the symbol
1230 itself. Simple enough. */
1231 if (!strcmp (cs
->c_name
, ".file") && cs
->c_naux
> 0)
1233 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1234 0, cs
->c_naux
, &main_aux
);
1235 filestring
= coff_getfilename (&main_aux
, objfile
);
1238 filestring
= cs
->c_name
;
1241 start_symtab (filestring
, (char *) NULL
, (CORE_ADDR
) 0);
1242 record_debugformat (debugfmt
);
1243 last_csect_name
= 0;
1245 /* reset file start and end addresses. A compilation unit with no text
1246 (only data) should have zero file boundaries. */
1247 file_start_addr
= file_end_addr
= 0;
1251 fcn_stab_saved
= *cs
;
1255 if (STREQ (cs
->c_name
, ".bf"))
1257 CORE_ADDR off
= ANOFFSET (objfile
->section_offsets
,
1258 SECT_OFF_TEXT (objfile
));
1259 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1260 0, cs
->c_naux
, &main_aux
);
1262 within_function
= 1;
1264 new = push_context (0, fcn_start_addr
+ off
);
1266 new->name
= define_symbol
1267 (fcn_cs_saved
.c_value
+ off
,
1268 fcn_stab_saved
.c_name
, 0, 0, objfile
);
1269 if (new->name
!= NULL
)
1270 SYMBOL_SECTION (new->name
) = SECT_OFF_TEXT (objfile
);
1272 else if (STREQ (cs
->c_name
, ".ef"))
1275 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1276 0, cs
->c_naux
, &main_aux
);
1278 /* The value of .ef is the address of epilogue code;
1279 not useful for gdb. */
1280 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1281 contains number of lines to '}' */
1283 if (context_stack_depth
<= 0)
1284 { /* We attempted to pop an empty context stack */
1285 complain (&ef_complaint
, cs
->c_symnum
);
1286 within_function
= 0;
1289 new = pop_context ();
1290 /* Stack must be empty now. */
1291 if (context_stack_depth
> 0 || new == NULL
)
1293 complain (&ef_complaint
, cs
->c_symnum
);
1294 within_function
= 0;
1298 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1300 (fcn_cs_saved
.c_value
1301 + fcn_aux_saved
.x_sym
.x_misc
.x_fsize
1302 + ANOFFSET (objfile
->section_offsets
,
1303 SECT_OFF_TEXT (objfile
))),
1305 within_function
= 0;
1310 /* Begin static block. */
1312 struct internal_syment symbol
;
1314 read_symbol (&symbol
, cs
->c_value
);
1315 static_block_base
= symbol
.n_value
;
1316 static_block_section
=
1317 secnum_to_section (symbol
.n_scnum
, objfile
);
1322 /* End of static block. */
1323 static_block_base
= 0;
1324 static_block_section
= -1;
1335 static struct deprecated_complaint msg
=
1336 {"Unrecognized storage class %d.", 0, 0};
1337 complain (&msg
, cs
->c_sclass
);
1351 /* beginning of include file */
1352 /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1353 order. Thus, when wee see them, we might not know enough info
1354 to process them. Thus, we'll be saving them into a table
1355 (inclTable) and postpone their processing. */
1357 record_include_begin (cs
);
1361 /* End of include file. */
1362 /* See the comment after case C_BINCL. */
1363 record_include_end (cs
);
1367 if (STREQ (cs
->c_name
, ".bb"))
1370 new = push_context (depth
,
1372 + ANOFFSET (objfile
->section_offsets
,
1373 SECT_OFF_TEXT (objfile
))));
1375 else if (STREQ (cs
->c_name
, ".eb"))
1377 if (context_stack_depth
<= 0)
1378 { /* We attempted to pop an empty context stack */
1379 complain (&eb_complaint
, cs
->c_symnum
);
1382 new = pop_context ();
1383 if (depth
-- != new->depth
)
1385 complain (&eb_complaint
, cs
->c_symnum
);
1388 if (local_symbols
&& context_stack_depth
> 0)
1390 /* Make a block for the local symbols within. */
1391 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1394 + ANOFFSET (objfile
->section_offsets
,
1395 SECT_OFF_TEXT (objfile
))),
1398 local_symbols
= new->locals
;
1403 process_xcoff_symbol (cs
, objfile
);
1408 if (last_source_file
)
1412 complete_symtab (filestring
, file_start_addr
);
1413 cur_src_end_addr
= file_end_addr
;
1414 s
= end_symtab (file_end_addr
, objfile
, SECT_OFF_TEXT (objfile
));
1415 /* When reading symbols for the last C_FILE of the objfile, try
1416 to make sure that we set pst->symtab to the symtab for the
1417 file, not to the _globals_ symtab. I'm not sure whether this
1418 actually works right or when/if it comes up. */
1419 if (pst
->symtab
== NULL
)
1425 #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1426 (SYMBOL2) = (struct symbol *) \
1427 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1428 *(SYMBOL2) = *(SYMBOL1);
1431 #define SYMNAME_ALLOC(NAME, ALLOCED) \
1432 (ALLOCED) ? (NAME) : obsavestring ((NAME), strlen (NAME), &objfile->symbol_obstack);
1435 static struct type
*func_symbol_type
;
1436 static struct type
*var_symbol_type
;
1438 /* process one xcoff symbol. */
1440 static struct symbol
*
1441 process_xcoff_symbol (register struct coff_symbol
*cs
, struct objfile
*objfile
)
1443 struct symbol onesymbol
;
1444 register struct symbol
*sym
= &onesymbol
;
1445 struct symbol
*sym2
= NULL
;
1451 if (cs
->c_secnum
< 0)
1453 /* The value is a register number, offset within a frame, etc.,
1454 and does not get relocated. */
1460 sec
= secnum_to_section (cs
->c_secnum
, objfile
);
1461 off
= ANOFFSET (objfile
->section_offsets
, sec
);
1468 memset (sym
, '\0', sizeof (struct symbol
));
1470 /* default assumptions */
1471 SYMBOL_VALUE_ADDRESS (sym
) = cs
->c_value
+ off
;
1472 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1473 SYMBOL_SECTION (sym
) = secnum_to_section (cs
->c_secnum
, objfile
);
1475 if (ISFCN (cs
->c_type
))
1477 /* At this point, we don't know the type of the function. This
1478 will be patched with the type from its stab entry later on in
1479 patch_block_stabs (), unless the file was compiled without -g. */
1481 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1482 SYMBOL_TYPE (sym
) = func_symbol_type
;
1484 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1485 SYMBOL_DUP (sym
, sym2
);
1487 if (cs
->c_sclass
== C_EXT
)
1488 add_symbol_to_list (sym2
, &global_symbols
);
1489 else if (cs
->c_sclass
== C_HIDEXT
|| cs
->c_sclass
== C_STAT
)
1490 add_symbol_to_list (sym2
, &file_symbols
);
1494 /* In case we can't figure out the type, provide default. */
1495 SYMBOL_TYPE (sym
) = var_symbol_type
;
1497 switch (cs
->c_sclass
)
1500 /* The values of functions and global symbols are now resolved
1501 via the global_sym_chain in stabsread.c. */
1503 if (fcn_cs_saved
.c_sclass
== C_EXT
)
1504 add_stab_to_list (name
, &global_stabs
);
1506 add_stab_to_list (name
, &file_stabs
);
1510 add_stab_to_list (name
, &global_stabs
);
1515 common_block_start (cs
->c_name
, objfile
);
1519 common_block_end (objfile
);
1523 complain (&storclass_complaint
, cs
->c_sclass
);
1535 sym
= define_symbol (cs
->c_value
+ off
, cs
->c_name
, 0, 0, objfile
);
1538 SYMBOL_SECTION (sym
) = sec
;
1545 /* For xlc (not GCC), the 'V' symbol descriptor is used for
1546 all statics and we need to distinguish file-scope versus
1547 function-scope using within_function. We do this by
1548 changing the string we pass to define_symbol to use 'S'
1549 where we need to, which is not necessarily super-clean,
1550 but seems workable enough. */
1552 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1556 if (*pp
== 'V' && !within_function
)
1558 sym
= define_symbol ((cs
->c_value
1559 + ANOFFSET (objfile
->section_offsets
,
1560 static_block_section
)),
1561 cs
->c_name
, 0, 0, objfile
);
1564 SYMBOL_VALUE_ADDRESS (sym
) += static_block_base
;
1565 SYMBOL_SECTION (sym
) = static_block_section
;
1574 /* Extract the file name from the aux entry of a C_FILE symbol.
1575 Result is in static storage and is only good for temporary use. */
1578 coff_getfilename (union internal_auxent
*aux_entry
, struct objfile
*objfile
)
1580 static char buffer
[BUFSIZ
];
1582 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1584 ((struct coff_symfile_info
*) objfile
->sym_private
)->strtbl
1585 + aux_entry
->x_file
.x_n
.x_offset
);
1588 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1589 buffer
[FILNMLEN
] = '\0';
1594 /* Set *SYMBOL to symbol number symno in symtbl. */
1596 read_symbol (struct internal_syment
*symbol
, int symno
)
1599 ((struct coff_symfile_info
*) this_symtab_psymtab
->objfile
->sym_private
)
1602 ((struct coff_symfile_info
*) this_symtab_psymtab
->objfile
->sym_private
)
1604 if (symno
< 0 || symno
>= nsyms
)
1606 static struct deprecated_complaint msg
=
1607 {"Invalid symbol offset", 0, 0};
1609 symbol
->n_value
= 0;
1610 symbol
->n_scnum
= -1;
1613 bfd_coff_swap_sym_in (this_symtab_psymtab
->objfile
->obfd
,
1614 stbl
+ (symno
* local_symesz
),
1618 /* Get value corresponding to symbol number symno in symtbl. */
1621 read_symbol_nvalue (int symno
)
1623 struct internal_syment symbol
[1];
1625 read_symbol (symbol
, symno
);
1626 return symbol
->n_value
;
1630 /* Find the address of the function corresponding to symno, where
1631 symno is the symbol pointed to by the linetable. */
1634 read_symbol_lineno (int symno
)
1636 struct objfile
*objfile
= this_symtab_psymtab
->objfile
;
1637 int xcoff64
= bfd_xcoff_is_xcoff64 (objfile
->obfd
);
1639 struct coff_symfile_info
*info
=
1640 (struct coff_symfile_info
*)objfile
->sym_private
;
1641 int nsyms
= info
->symtbl_num_syms
;
1642 char *stbl
= info
->symtbl
;
1643 char *strtbl
= info
->strtbl
;
1645 struct internal_syment symbol
[1];
1646 union internal_auxent main_aux
[1];
1650 complain (&bf_notfound_complaint
);
1654 /* Note that just searching for a short distance (e.g. 50 symbols)
1655 is not enough, at least in the following case.
1658 [many .stabx entries]
1659 [a few functions, referring to foo]
1663 What happens here is that the assembler moves the .stabx entries
1664 to right before the ".bf" for foo, but the symbol for "foo" is before
1665 all the stabx entries. See PR gdb/2222. */
1667 /* Maintaining a table of .bf entries might be preferable to this search.
1668 If I understand things correctly it would need to be done only for
1669 the duration of a single psymtab to symtab conversion. */
1670 while (symno
< nsyms
)
1672 bfd_coff_swap_sym_in (symfile_bfd
,
1673 stbl
+ (symno
* local_symesz
), symbol
);
1674 if (symbol
->n_sclass
== C_FCN
)
1676 char *name
= xcoff64
? strtbl
+ symbol
->n_offset
: symbol
->n_name
;
1677 if (STREQ (name
, ".bf"))
1680 symno
+= symbol
->n_numaux
+ 1;
1683 complain (&bf_notfound_complaint
);
1687 /* take aux entry and return its lineno */
1689 bfd_coff_swap_aux_in (objfile
->obfd
, stbl
+ symno
* local_symesz
,
1690 symbol
->n_type
, symbol
->n_sclass
,
1691 0, symbol
->n_numaux
, main_aux
);
1693 return main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
1696 /* Support for line number handling */
1698 /* This function is called for every section; it finds the outer limits
1699 * of the line table (minimum and maximum file offset) so that the
1700 * mainline code can read the whole thing for efficiency.
1703 find_linenos (bfd
*abfd
, sec_ptr asect
, PTR vpinfo
)
1705 struct coff_symfile_info
*info
;
1707 file_ptr offset
, maxoff
;
1709 count
= asect
->lineno_count
;
1711 if (!STREQ (asect
->name
, ".text") || count
== 0)
1714 size
= count
* coff_data (abfd
)->local_linesz
;
1715 info
= (struct coff_symfile_info
*) vpinfo
;
1716 offset
= asect
->line_filepos
;
1717 maxoff
= offset
+ size
;
1719 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
1720 info
->min_lineno_offset
= offset
;
1722 if (maxoff
> info
->max_lineno_offset
)
1723 info
->max_lineno_offset
= maxoff
;
1726 static void xcoff_psymtab_to_symtab_1 (struct partial_symtab
*);
1729 xcoff_psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1731 struct cleanup
*old_chain
;
1740 (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1745 /* Read in all partial symtabs on which this one is dependent */
1746 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1747 if (!pst
->dependencies
[i
]->readin
)
1749 /* Inform about additional files that need to be read in. */
1752 fputs_filtered (" ", gdb_stdout
);
1754 fputs_filtered ("and ", gdb_stdout
);
1756 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1757 wrap_here (""); /* Flush output */
1758 gdb_flush (gdb_stdout
);
1760 xcoff_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1763 if (((struct symloc
*) pst
->read_symtab_private
)->numsyms
!= 0)
1765 /* Init stuff necessary for reading in symbols. */
1768 old_chain
= make_cleanup (really_free_pendings
, 0);
1770 read_xcoff_symtab (pst
);
1771 sort_symtab_syms (pst
->symtab
);
1773 do_cleanups (old_chain
);
1779 static void xcoff_psymtab_to_symtab (struct partial_symtab
*);
1781 /* Read in all of the symbols for a given psymtab for real.
1782 Be verbose about it if the user wants that. */
1785 xcoff_psymtab_to_symtab (struct partial_symtab
*pst
)
1795 (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1800 if (((struct symloc
*) pst
->read_symtab_private
)->numsyms
!= 0
1801 || pst
->number_of_dependencies
)
1803 /* Print the message now, before reading the string table,
1804 to avoid disconcerting pauses. */
1807 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1808 gdb_flush (gdb_stdout
);
1811 sym_bfd
= pst
->objfile
->obfd
;
1813 next_symbol_text_func
= xcoff_next_symbol_text
;
1815 xcoff_psymtab_to_symtab_1 (pst
);
1817 /* Match with global symbols. This only needs to be done once,
1818 after all of the symtabs and dependencies have been read in. */
1819 scan_file_globals (pst
->objfile
);
1821 /* Finish up the debug error message. */
1823 printf_filtered ("done.\n");
1828 xcoff_new_init (struct objfile
*objfile
)
1830 stabsread_new_init ();
1831 buildsym_new_init ();
1834 /* Do initialization in preparation for reading symbols from OBJFILE.
1836 We will only be called if this is an XCOFF or XCOFF-like file.
1837 BFD handles figuring out the format of the file, and code in symfile.c
1838 uses BFD's determination to vector to us. */
1841 xcoff_symfile_init (struct objfile
*objfile
)
1843 /* Allocate struct to keep track of the symfile */
1844 objfile
->sym_private
= xmmalloc (objfile
->md
,
1845 sizeof (struct coff_symfile_info
));
1847 /* XCOFF objects may be reordered, so set OBJF_REORDERED. If we
1848 find this causes a significant slowdown in gdb then we could
1849 set it in the debug symbol readers only when necessary. */
1850 objfile
->flags
|= OBJF_REORDERED
;
1852 init_entry_point_info (objfile
);
1855 /* Perform any local cleanups required when we are done with a particular
1856 objfile. I.E, we are in the process of discarding all symbol information
1857 for an objfile, freeing up all memory held for it, and unlinking the
1858 objfile struct from the global list of known objfiles. */
1861 xcoff_symfile_finish (struct objfile
*objfile
)
1863 if (objfile
->sym_private
!= NULL
)
1865 xmfree (objfile
->md
, objfile
->sym_private
);
1868 /* Start with a fresh include table for the next objfile. */
1874 inclIndx
= inclLength
= inclDepth
= 0;
1879 init_stringtab (bfd
*abfd
, file_ptr offset
, struct objfile
*objfile
)
1883 unsigned char lengthbuf
[4];
1886 ((struct coff_symfile_info
*) objfile
->sym_private
)->strtbl
= NULL
;
1888 if (bfd_seek (abfd
, offset
, SEEK_SET
) < 0)
1889 error ("cannot seek to string table in %s: %s",
1890 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
1892 val
= bfd_bread ((char *) lengthbuf
, sizeof lengthbuf
, abfd
);
1893 length
= bfd_h_get_32 (abfd
, lengthbuf
);
1895 /* If no string table is needed, then the file may end immediately
1896 after the symbols. Just return with `strtbl' set to NULL. */
1898 if (val
!= sizeof lengthbuf
|| length
< sizeof lengthbuf
)
1901 /* Allocate string table from symbol_obstack. We will need this table
1902 as long as we have its symbol table around. */
1904 strtbl
= (char *) obstack_alloc (&objfile
->symbol_obstack
, length
);
1905 ((struct coff_symfile_info
*) objfile
->sym_private
)->strtbl
= strtbl
;
1907 /* Copy length buffer, the first byte is usually zero and is
1908 used for stabs with a name length of zero. */
1909 memcpy (strtbl
, lengthbuf
, sizeof lengthbuf
);
1910 if (length
== sizeof lengthbuf
)
1913 val
= bfd_bread (strtbl
+ sizeof lengthbuf
, length
- sizeof lengthbuf
, abfd
);
1915 if (val
!= length
- sizeof lengthbuf
)
1916 error ("cannot read string table from %s: %s",
1917 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
1918 if (strtbl
[length
- 1] != '\0')
1919 error ("bad symbol file: string table does not end with null character");
1924 /* If we have not yet seen a function for this psymtab, this is 0. If we
1925 have seen one, it is the offset in the line numbers of the line numbers
1927 static unsigned int first_fun_line_offset
;
1929 static struct partial_symtab
*xcoff_start_psymtab
1930 (struct objfile
*, char *, int,
1931 struct partial_symbol
**, struct partial_symbol
**);
1933 /* Allocate and partially fill a partial symtab. It will be
1934 completely filled at the end of the symbol list.
1936 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1937 is the address relative to which its symbols are (incremental) or 0
1940 static struct partial_symtab
*
1941 xcoff_start_psymtab (struct objfile
*objfile
, char *filename
, int first_symnum
,
1942 struct partial_symbol
**global_syms
,
1943 struct partial_symbol
**static_syms
)
1945 struct partial_symtab
*result
=
1946 start_psymtab_common (objfile
, objfile
->section_offsets
,
1948 /* We fill in textlow later. */
1950 global_syms
, static_syms
);
1952 result
->read_symtab_private
= (char *)
1953 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1954 ((struct symloc
*) result
->read_symtab_private
)->first_symnum
= first_symnum
;
1955 result
->read_symtab
= xcoff_psymtab_to_symtab
;
1957 /* Deduce the source language from the filename for this psymtab. */
1958 psymtab_language
= deduce_language_from_filename (filename
);
1963 static struct partial_symtab
*xcoff_end_psymtab
1964 (struct partial_symtab
*, char **, int, int,
1965 struct partial_symtab
**, int, int);
1967 /* Close off the current usage of PST.
1968 Returns PST, or NULL if the partial symtab was empty and thrown away.
1970 CAPPING_SYMBOL_NUMBER is the end of pst (exclusive).
1972 INCLUDE_LIST, NUM_INCLUDES, DEPENDENCY_LIST, and NUMBER_DEPENDENCIES
1973 are the information for includes and dependencies. */
1975 static struct partial_symtab
*
1976 xcoff_end_psymtab (struct partial_symtab
*pst
, char **include_list
,
1977 int num_includes
, int capping_symbol_number
,
1978 struct partial_symtab
**dependency_list
,
1979 int number_dependencies
, int textlow_not_set
)
1982 struct objfile
*objfile
= pst
->objfile
;
1984 if (capping_symbol_number
!= -1)
1985 ((struct symloc
*) pst
->read_symtab_private
)->numsyms
=
1986 capping_symbol_number
1987 - ((struct symloc
*) pst
->read_symtab_private
)->first_symnum
;
1988 ((struct symloc
*) pst
->read_symtab_private
)->lineno_off
=
1989 first_fun_line_offset
;
1990 first_fun_line_offset
= 0;
1991 pst
->n_global_syms
=
1992 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1993 pst
->n_static_syms
=
1994 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1996 pst
->number_of_dependencies
= number_dependencies
;
1997 if (number_dependencies
)
1999 pst
->dependencies
= (struct partial_symtab
**)
2000 obstack_alloc (&objfile
->psymbol_obstack
,
2001 number_dependencies
* sizeof (struct partial_symtab
*));
2002 memcpy (pst
->dependencies
, dependency_list
,
2003 number_dependencies
* sizeof (struct partial_symtab
*));
2006 pst
->dependencies
= 0;
2008 for (i
= 0; i
< num_includes
; i
++)
2010 struct partial_symtab
*subpst
=
2011 allocate_psymtab (include_list
[i
], objfile
);
2013 subpst
->section_offsets
= pst
->section_offsets
;
2014 subpst
->read_symtab_private
=
2015 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
2016 sizeof (struct symloc
));
2017 ((struct symloc
*) subpst
->read_symtab_private
)->first_symnum
= 0;
2018 ((struct symloc
*) subpst
->read_symtab_private
)->numsyms
= 0;
2019 subpst
->textlow
= 0;
2020 subpst
->texthigh
= 0;
2022 /* We could save slight bits of space by only making one of these,
2023 shared by the entire set of include files. FIXME-someday. */
2024 subpst
->dependencies
= (struct partial_symtab
**)
2025 obstack_alloc (&objfile
->psymbol_obstack
,
2026 sizeof (struct partial_symtab
*));
2027 subpst
->dependencies
[0] = pst
;
2028 subpst
->number_of_dependencies
= 1;
2030 subpst
->globals_offset
=
2031 subpst
->n_global_syms
=
2032 subpst
->statics_offset
=
2033 subpst
->n_static_syms
= 0;
2037 subpst
->read_symtab
= pst
->read_symtab
;
2040 sort_pst_symbols (pst
);
2042 /* If there is already a psymtab or symtab for a file of this name,
2043 remove it. (If there is a symtab, more drastic things also
2044 happen.) This happens in VxWorks. */
2045 free_named_symtabs (pst
->filename
);
2047 if (num_includes
== 0
2048 && number_dependencies
== 0
2049 && pst
->n_global_syms
== 0
2050 && pst
->n_static_syms
== 0)
2052 /* Throw away this psymtab, it's empty. We can't deallocate it, since
2053 it is on the obstack, but we can forget to chain it on the list. */
2054 /* Empty psymtabs happen as a result of header files which don't have
2055 any symbols in them. There can be a lot of them. */
2057 discard_psymtab (pst
);
2059 /* Indicate that psymtab was thrown away. */
2060 pst
= (struct partial_symtab
*) NULL
;
2065 static void swap_sym (struct internal_syment
*,
2066 union internal_auxent
*, char **, char **,
2067 unsigned int *, struct objfile
*);
2069 /* Swap raw symbol at *RAW and put the name in *NAME, the symbol in
2070 *SYMBOL, the first auxent in *AUX. Advance *RAW and *SYMNUMP over
2071 the symbol and its auxents. */
2074 swap_sym (struct internal_syment
*symbol
, union internal_auxent
*aux
,
2075 char **name
, char **raw
, unsigned int *symnump
,
2076 struct objfile
*objfile
)
2078 bfd_coff_swap_sym_in (objfile
->obfd
, *raw
, symbol
);
2079 if (symbol
->n_zeroes
)
2081 /* If it's exactly E_SYMNMLEN characters long it isn't
2083 if (symbol
->n_name
[E_SYMNMLEN
- 1] != '\0')
2085 /* FIXME: wastes memory for symbols which we don't end up putting
2086 into the minimal symbols. */
2088 p
= obstack_alloc (&objfile
->psymbol_obstack
, E_SYMNMLEN
+ 1);
2089 strncpy (p
, symbol
->n_name
, E_SYMNMLEN
);
2090 p
[E_SYMNMLEN
] = '\0';
2094 /* Point to the unswapped name as that persists as long as the
2096 *name
= ((struct external_syment
*) *raw
)->e
.e_name
;
2098 else if (symbol
->n_sclass
& 0x80)
2100 *name
= ((struct coff_symfile_info
*) objfile
->sym_private
)->debugsec
2105 *name
= ((struct coff_symfile_info
*) objfile
->sym_private
)->strtbl
2109 *raw
+= coff_data (objfile
->obfd
)->local_symesz
;
2110 if (symbol
->n_numaux
> 0)
2112 bfd_coff_swap_aux_in (objfile
->obfd
, *raw
, symbol
->n_type
,
2113 symbol
->n_sclass
, 0, symbol
->n_numaux
, aux
);
2115 *symnump
+= symbol
->n_numaux
;
2116 *raw
+= coff_data (objfile
->obfd
)->local_symesz
* symbol
->n_numaux
;
2121 scan_xcoff_symtab (struct objfile
*objfile
)
2123 CORE_ADDR toc_offset
= 0; /* toc offset value in data section. */
2124 char *filestring
= NULL
;
2127 int past_first_source_file
= 0;
2132 /* Current partial symtab */
2133 struct partial_symtab
*pst
;
2135 /* List of current psymtab's include files */
2136 char **psymtab_include_list
;
2137 int includes_allocated
;
2140 /* Index within current psymtab dependency list */
2141 struct partial_symtab
**dependency_list
;
2142 int dependencies_used
, dependencies_allocated
;
2145 struct internal_syment symbol
;
2146 union internal_auxent main_aux
[5];
2147 unsigned int ssymnum
;
2149 char *last_csect_name
= NULL
; /* last seen csect's name and value */
2150 CORE_ADDR last_csect_val
= 0;
2151 int last_csect_sec
= 0;
2152 int misc_func_recorded
= 0; /* true if any misc. function */
2153 int textlow_not_set
= 1;
2155 pst
= (struct partial_symtab
*) 0;
2157 includes_allocated
= 30;
2159 psymtab_include_list
= (char **) alloca (includes_allocated
*
2162 dependencies_allocated
= 30;
2163 dependencies_used
= 0;
2165 (struct partial_symtab
**) alloca (dependencies_allocated
*
2166 sizeof (struct partial_symtab
*));
2168 last_source_file
= NULL
;
2170 abfd
= objfile
->obfd
;
2172 sraw_symbol
= ((struct coff_symfile_info
*) objfile
->sym_private
)->symtbl
;
2173 nsyms
= ((struct coff_symfile_info
*) objfile
->sym_private
)->symtbl_num_syms
;
2175 while (ssymnum
< nsyms
)
2181 bfd_coff_swap_sym_in (abfd
, sraw_symbol
, &symbol
);
2182 sclass
= symbol
.n_sclass
;
2189 /* The CSECT auxent--always the last auxent. */
2190 union internal_auxent csect_aux
;
2191 unsigned int symnum_before
= ssymnum
;
2193 swap_sym (&symbol
, &main_aux
[0], &namestring
, &sraw_symbol
,
2195 if (symbol
.n_numaux
> 1)
2197 bfd_coff_swap_aux_in
2199 sraw_symbol
- coff_data (abfd
)->local_symesz
,
2202 symbol
.n_numaux
- 1,
2207 csect_aux
= main_aux
[0];
2209 /* If symbol name starts with ".$" or "$", ignore it. */
2210 if (namestring
[0] == '$'
2211 || (namestring
[0] == '.' && namestring
[1] == '$'))
2214 switch (csect_aux
.x_csect
.x_smtyp
& 0x7)
2217 switch (csect_aux
.x_csect
.x_smclas
)
2220 if (last_csect_name
)
2222 /* If no misc. function recorded in the last
2223 seen csect, enter it as a function. This
2224 will take care of functions like strcmp()
2227 if (!misc_func_recorded
)
2229 RECORD_MINIMAL_SYMBOL
2230 (last_csect_name
, last_csect_val
,
2231 mst_text
, last_csect_sec
,
2237 /* We have to allocate one psymtab for
2238 each program csect, because their text
2239 sections need not be adjacent. */
2241 (pst
, psymtab_include_list
, includes_used
,
2242 symnum_before
, dependency_list
,
2243 dependencies_used
, textlow_not_set
);
2245 dependencies_used
= 0;
2246 /* Give all psymtabs for this source file the same
2248 pst
= xcoff_start_psymtab
2252 objfile
->global_psymbols
.next
,
2253 objfile
->static_psymbols
.next
);
2256 /* Activate the misc_func_recorded mechanism for
2257 compiler- and linker-generated CSECTs like ".strcmp"
2259 if (namestring
&& (namestring
[0] == '.'
2260 || namestring
[0] == '@'))
2262 last_csect_name
= namestring
;
2263 last_csect_val
= symbol
.n_value
;
2265 secnum_to_section (symbol
.n_scnum
, objfile
);
2270 symbol
.n_value
+ csect_aux
.x_csect
.x_scnlen
.l
;
2271 if (highval
> pst
->texthigh
)
2272 pst
->texthigh
= highval
;
2273 if (pst
->textlow
== 0 || symbol
.n_value
< pst
->textlow
)
2274 pst
->textlow
= symbol
.n_value
;
2276 misc_func_recorded
= 0;
2281 /* Data variables are recorded in the minimal symbol
2282 table, except for section symbols. */
2283 if (*namestring
!= '.')
2284 prim_record_minimal_symbol_and_info
2285 (namestring
, symbol
.n_value
,
2286 sclass
== C_HIDEXT
? mst_file_data
: mst_data
,
2287 NULL
, secnum_to_section (symbol
.n_scnum
, objfile
),
2293 warning ("More than one XMC_TC0 symbol found.");
2294 toc_offset
= symbol
.n_value
;
2296 /* Make TOC offset relative to start address of section. */
2297 bfd_sect
= secnum_to_bfd_section (symbol
.n_scnum
, objfile
);
2299 toc_offset
-= bfd_section_vma (objfile
->obfd
, bfd_sect
);
2303 /* These symbols tell us where the TOC entry for a
2304 variable is, not the variable itself. */
2313 switch (csect_aux
.x_csect
.x_smclas
)
2316 /* A function entry point. */
2318 if (first_fun_line_offset
== 0 && symbol
.n_numaux
> 1)
2319 first_fun_line_offset
=
2320 main_aux
[0].x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2321 RECORD_MINIMAL_SYMBOL
2322 (namestring
, symbol
.n_value
,
2323 sclass
== C_HIDEXT
? mst_file_text
: mst_text
,
2324 secnum_to_section (symbol
.n_scnum
, objfile
),
2329 /* shared library function trampoline code entry
2332 /* record trampoline code entries as
2333 mst_solib_trampoline symbol. When we lookup mst
2334 symbols, we will choose mst_text over
2335 mst_solib_trampoline. */
2336 RECORD_MINIMAL_SYMBOL
2337 (namestring
, symbol
.n_value
,
2338 mst_solib_trampoline
,
2339 secnum_to_section (symbol
.n_scnum
, objfile
),
2344 /* The symbols often have the same names as
2345 debug symbols for functions, and confuse
2351 /* xlc puts each variable in a separate csect,
2352 so we get an XTY_SD for each variable. But
2353 gcc puts several variables in a csect, so
2354 that each variable only gets an XTY_LD. We
2355 still need to record them. This will
2356 typically be XMC_RW; I suspect XMC_RO and
2357 XMC_BS might be possible too. */
2358 if (*namestring
!= '.')
2359 prim_record_minimal_symbol_and_info
2360 (namestring
, symbol
.n_value
,
2361 sclass
== C_HIDEXT
? mst_file_data
: mst_data
,
2362 NULL
, secnum_to_section (symbol
.n_scnum
, objfile
),
2369 switch (csect_aux
.x_csect
.x_smclas
)
2373 /* Common variables are recorded in the minimal symbol
2374 table, except for section symbols. */
2375 if (*namestring
!= '.')
2376 prim_record_minimal_symbol_and_info
2377 (namestring
, symbol
.n_value
,
2378 sclass
== C_HIDEXT
? mst_file_bss
: mst_bss
,
2379 NULL
, secnum_to_section (symbol
.n_scnum
, objfile
),
2392 unsigned int symnum_before
;
2394 symnum_before
= ssymnum
;
2395 swap_sym (&symbol
, &main_aux
[0], &namestring
, &sraw_symbol
,
2398 /* See if the last csect needs to be recorded. */
2400 if (last_csect_name
&& !misc_func_recorded
)
2403 /* If no misc. function recorded in the last seen csect, enter
2404 it as a function. This will take care of functions like
2405 strcmp() compiled by xlc. */
2407 RECORD_MINIMAL_SYMBOL
2408 (last_csect_name
, last_csect_val
,
2409 mst_text
, last_csect_sec
, objfile
);
2414 xcoff_end_psymtab (pst
, psymtab_include_list
, includes_used
,
2415 symnum_before
, dependency_list
,
2416 dependencies_used
, textlow_not_set
);
2418 dependencies_used
= 0;
2420 first_fun_line_offset
= 0;
2422 /* XCOFF, according to the AIX 3.2 documentation, puts the
2423 filename in cs->c_name. But xlc 1.3.0.2 has decided to
2424 do things the standard COFF way and put it in the auxent.
2425 We use the auxent if the symbol is ".file" and an auxent
2426 exists, otherwise use the symbol itself. */
2427 if (!strcmp (namestring
, ".file") && symbol
.n_numaux
> 0)
2429 filestring
= coff_getfilename (&main_aux
[0], objfile
);
2432 filestring
= namestring
;
2434 pst
= xcoff_start_psymtab (objfile
,
2437 objfile
->global_psymbols
.next
,
2438 objfile
->static_psymbols
.next
);
2439 last_csect_name
= NULL
;
2445 static struct deprecated_complaint msg
=
2446 {"Storage class %d not recognized during scan", 0, 0};
2447 complain (&msg
, sclass
);
2451 /* C_FCN is .bf and .ef symbols. I think it is sufficient
2452 to handle only the C_FUN and C_EXT. */
2467 /* C_EINCL means we are switching back to the main file. But there
2468 is no reason to care; the only thing we want to know about
2469 includes is the names of all the included (.h) files. */
2474 /* I don't think C_STAT is used in xcoff; C_HIDEXT appears to be
2478 /* I don't think the name of the common block (as opposed to the
2479 variables within it) is something which is user visible
2487 /* I think we can ignore C_LSYM; types on xcoff seem to use C_DECL
2488 so C_LSYM would appear to be only for locals. */
2494 /* We probably could save a few instructions by assuming that
2495 C_LSYM, C_PSYM, etc., never have auxents. */
2496 int naux1
= symbol
.n_numaux
+ 1;
2498 sraw_symbol
+= bfd_coff_symesz (abfd
) * naux1
;
2504 /* Mark down an include file in the current psymtab */
2505 enum language tmp_language
;
2506 swap_sym (&symbol
, &main_aux
[0], &namestring
, &sraw_symbol
,
2509 tmp_language
= deduce_language_from_filename (namestring
);
2511 /* Only change the psymtab's language if we've learned
2512 something useful (eg. tmp_language is not language_unknown).
2513 In addition, to match what start_subfile does, never change
2515 if (tmp_language
!= language_unknown
2516 && (tmp_language
!= language_c
2517 || psymtab_language
!= language_cplus
))
2518 psymtab_language
= tmp_language
;
2520 /* In C++, one may expect the same filename to come round many
2521 times, when code is coming alternately from the main file
2522 and from inline functions in other files. So I check to see
2523 if this is a file we've seen before -- either the main
2524 source file, or a previously included file.
2526 This seems to be a lot of time to be spending on N_SOL, but
2527 things like "break c-exp.y:435" need to work (I
2528 suppose the psymtab_include_list could be hashed or put
2529 in a binary tree, if profiling shows this is a major hog). */
2530 if (pst
&& STREQ (namestring
, pst
->filename
))
2534 for (i
= 0; i
< includes_used
; i
++)
2535 if (STREQ (namestring
, psymtab_include_list
[i
]))
2543 psymtab_include_list
[includes_used
++] = namestring
;
2544 if (includes_used
>= includes_allocated
)
2546 char **orig
= psymtab_include_list
;
2548 psymtab_include_list
= (char **)
2549 alloca ((includes_allocated
*= 2) *
2551 memcpy ((PTR
) psymtab_include_list
, (PTR
) orig
,
2552 includes_used
* sizeof (char *));
2557 /* The value of the C_FUN is not the address of the function (it
2558 appears to be the address before linking), but as long as it
2559 is smaller than the actual address, then find_pc_partial_function
2560 will use the minimal symbols instead. I hope. */
2568 static struct deprecated_complaint function_outside_compilation_unit
= {
2569 "function `%s' appears to be defined outside of all compilation units", 0, 0
2573 swap_sym (&symbol
, &main_aux
[0], &namestring
, &sraw_symbol
,
2576 p
= (char *) strchr (namestring
, ':');
2578 continue; /* Not a debugging symbol. */
2580 /* Main processing section for debugging symbols which
2581 the initial read through the symbol tables needs to worry
2582 about. If we reach this point, the symbol which we are
2583 considering is definitely one we are interested in.
2584 p must also contain the (valid) index into the namestring
2585 which indicates the debugging type symbol. */
2590 symbol
.n_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2591 #ifdef STATIC_TRANSFORM_NAME
2592 namestring
= STATIC_TRANSFORM_NAME (namestring
);
2594 add_psymbol_to_list (namestring
, p
- namestring
,
2595 VAR_NAMESPACE
, LOC_STATIC
,
2596 &objfile
->static_psymbols
,
2598 psymtab_language
, objfile
);
2602 symbol
.n_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2603 /* The addresses in these entries are reported to be
2604 wrong. See the code that reads 'G's for symtabs. */
2605 add_psymbol_to_list (namestring
, p
- namestring
,
2606 VAR_NAMESPACE
, LOC_STATIC
,
2607 &objfile
->global_psymbols
,
2609 psymtab_language
, objfile
);
2613 /* When a 'T' entry is defining an anonymous enum, it
2614 may have a name which is the empty string, or a
2615 single space. Since they're not really defining a
2616 symbol, those shouldn't go in the partial symbol
2617 table. We do pick up the elements of such enums at
2618 'check_enum:', below. */
2619 if (p
>= namestring
+ 2
2620 || (p
== namestring
+ 1
2621 && namestring
[0] != ' '))
2623 add_psymbol_to_list (namestring
, p
- namestring
,
2624 STRUCT_NAMESPACE
, LOC_TYPEDEF
,
2625 &objfile
->static_psymbols
,
2627 psymtab_language
, objfile
);
2630 /* Also a typedef with the same name. */
2631 add_psymbol_to_list (namestring
, p
- namestring
,
2632 VAR_NAMESPACE
, LOC_TYPEDEF
,
2633 &objfile
->static_psymbols
,
2635 psymtab_language
, objfile
);
2638 /* The semantics of C++ state that "struct foo { ... }"
2639 also defines a typedef for "foo". Unfortuantely, cfront
2640 never makes the typedef when translating from C++ to C.
2641 We make the typedef here so that "ptype foo" works as
2642 expected for cfront translated code. */
2643 else if (psymtab_language
== language_cplus
)
2645 /* Also a typedef with the same name. */
2646 add_psymbol_to_list (namestring
, p
- namestring
,
2647 VAR_NAMESPACE
, LOC_TYPEDEF
,
2648 &objfile
->static_psymbols
,
2650 psymtab_language
, objfile
);
2656 if (p
!= namestring
) /* a name is there, not just :T... */
2658 add_psymbol_to_list (namestring
, p
- namestring
,
2659 VAR_NAMESPACE
, LOC_TYPEDEF
,
2660 &objfile
->static_psymbols
,
2662 psymtab_language
, objfile
);
2665 /* If this is an enumerated type, we need to
2666 add all the enum constants to the partial symbol
2667 table. This does not cover enums without names, e.g.
2668 "enum {a, b} c;" in C, but fortunately those are
2669 rare. There is no way for GDB to find those from the
2670 enum type without spending too much time on it. Thus
2671 to solve this problem, the compiler needs to put out the
2672 enum in a nameless type. GCC2 does this. */
2674 /* We are looking for something of the form
2675 <name> ":" ("t" | "T") [<number> "="] "e"
2676 {<constant> ":" <value> ","} ";". */
2678 /* Skip over the colon and the 't' or 'T'. */
2680 /* This type may be given a number. Also, numbers can come
2681 in pairs like (0,26). Skip over it. */
2682 while ((*p
>= '0' && *p
<= '9')
2683 || *p
== '(' || *p
== ',' || *p
== ')'
2689 /* The aix4 compiler emits extra crud before the members. */
2692 /* Skip over the type (?). */
2696 /* Skip over the colon. */
2700 /* We have found an enumerated type. */
2701 /* According to comments in read_enum_type
2702 a comma could end it instead of a semicolon.
2703 I don't know where that happens.
2705 while (*p
&& *p
!= ';' && *p
!= ',')
2709 /* Check for and handle cretinous dbx symbol name
2711 if (*p
== '\\' || (*p
== '?' && p
[1] == '\0'))
2712 p
= next_symbol_text (objfile
);
2714 /* Point to the character after the name
2715 of the enum constant. */
2716 for (q
= p
; *q
&& *q
!= ':'; q
++)
2718 /* Note that the value doesn't matter for
2719 enum constants in psymtabs, just in symtabs. */
2720 add_psymbol_to_list (p
, q
- p
,
2721 VAR_NAMESPACE
, LOC_CONST
,
2722 &objfile
->static_psymbols
, 0,
2723 0, psymtab_language
, objfile
);
2724 /* Point past the name. */
2726 /* Skip over the value. */
2727 while (*p
&& *p
!= ',')
2729 /* Advance past the comma. */
2737 /* Constant, e.g. from "const" in Pascal. */
2738 add_psymbol_to_list (namestring
, p
- namestring
,
2739 VAR_NAMESPACE
, LOC_CONST
,
2740 &objfile
->static_psymbols
, symbol
.n_value
,
2741 0, psymtab_language
, objfile
);
2747 int name_len
= p
- namestring
;
2748 char *name
= xmalloc (name_len
+ 1);
2749 memcpy (name
, namestring
, name_len
);
2750 name
[name_len
] = '\0';
2751 complain (&function_outside_compilation_unit
, name
);
2754 symbol
.n_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2755 add_psymbol_to_list (namestring
, p
- namestring
,
2756 VAR_NAMESPACE
, LOC_BLOCK
,
2757 &objfile
->static_psymbols
,
2759 psymtab_language
, objfile
);
2762 /* Global functions were ignored here, but now they
2763 are put into the global psymtab like one would expect.
2764 They're also in the minimal symbol table. */
2768 int name_len
= p
- namestring
;
2769 char *name
= xmalloc (name_len
+ 1);
2770 memcpy (name
, namestring
, name_len
);
2771 name
[name_len
] = '\0';
2772 complain (&function_outside_compilation_unit
, name
);
2775 symbol
.n_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2776 add_psymbol_to_list (namestring
, p
- namestring
,
2777 VAR_NAMESPACE
, LOC_BLOCK
,
2778 &objfile
->global_psymbols
,
2780 psymtab_language
, objfile
);
2783 /* Two things show up here (hopefully); static symbols of
2784 local scope (static used inside braces) or extensions
2785 of structure symbols. We can ignore both. */
2799 case '#': /* for symbol identification (used in live ranges) */
2800 /* added to support cfront stabs strings */
2801 case 'Z': /* for definition continuations */
2802 case 'P': /* for prototypes */
2806 /* It is a C++ nested symbol. We don't need to record it
2807 (I don't think); if we try to look up foo::bar::baz,
2808 then symbols for the symtab containing foo should get
2809 read in, I think. */
2810 /* Someone says sun cc puts out symbols like
2811 /foo/baz/maclib::/usr/local/bin/maclib,
2812 which would get here with a symbol type of ':'. */
2816 /* Unexpected symbol descriptor. The second and subsequent stabs
2817 of a continued stab can show up here. The question is
2818 whether they ever can mimic a normal stab--it would be
2819 nice if not, since we certainly don't want to spend the
2820 time searching to the end of every string looking for
2823 complain (&unknown_symchar_complaint
, p
[1]);
2825 /* Ignore it; perhaps it is an extension that we don't
2835 xcoff_end_psymtab (pst
, psymtab_include_list
, includes_used
,
2836 ssymnum
, dependency_list
,
2837 dependencies_used
, textlow_not_set
);
2840 /* Record the toc offset value of this symbol table into objfile structure.
2841 If no XMC_TC0 is found, toc_offset should be zero. Another place to obtain
2842 this information would be file auxiliary header. */
2844 ((struct coff_symfile_info
*) objfile
->sym_private
)->toc_offset
= toc_offset
;
2847 /* Return the toc offset value for a given objfile. */
2850 get_toc_offset (struct objfile
*objfile
)
2853 return ((struct coff_symfile_info
*) objfile
->sym_private
)->toc_offset
;
2857 /* Scan and build partial symbols for a symbol file.
2858 We have been initialized by a call to dbx_symfile_init, which
2859 put all the relevant info into a "struct dbx_symfile_info",
2860 hung off the objfile structure.
2862 SECTION_OFFSETS contains offsets relative to which the symbols in the
2863 various sections are (depending where the sections were actually loaded).
2864 MAINLINE is true if we are reading the main symbol
2865 table (as opposed to a shared lib or dynamically loaded file). */
2868 xcoff_initial_scan (struct objfile
*objfile
, int mainline
)
2872 struct cleanup
*back_to
;
2873 int num_symbols
; /* # of symbols */
2874 file_ptr symtab_offset
; /* symbol table and */
2875 file_ptr stringtab_offset
; /* string table file offsets */
2876 struct coff_symfile_info
*info
;
2880 info
= (struct coff_symfile_info
*) objfile
->sym_private
;
2881 symfile_bfd
= abfd
= objfile
->obfd
;
2882 name
= objfile
->name
;
2884 num_symbols
= bfd_get_symcount (abfd
); /* # of symbols */
2885 symtab_offset
= obj_sym_filepos (abfd
); /* symbol table file offset */
2886 stringtab_offset
= symtab_offset
+
2887 num_symbols
* coff_data (abfd
)->local_symesz
;
2889 info
->min_lineno_offset
= 0;
2890 info
->max_lineno_offset
= 0;
2891 bfd_map_over_sections (abfd
, find_linenos
, info
);
2893 if (num_symbols
> 0)
2895 /* Read the string table. */
2896 init_stringtab (abfd
, stringtab_offset
, objfile
);
2898 /* Read the .debug section, if present. */
2901 bfd_size_type length
;
2902 char *debugsec
= NULL
;
2904 secp
= bfd_get_section_by_name (abfd
, ".debug");
2907 length
= bfd_section_size (abfd
, secp
);
2911 (char *) obstack_alloc (&objfile
->symbol_obstack
, length
);
2913 if (!bfd_get_section_contents (abfd
, secp
, debugsec
,
2914 (file_ptr
) 0, length
))
2916 error ("Error reading .debug section of `%s': %s",
2917 name
, bfd_errmsg (bfd_get_error ()));
2921 ((struct coff_symfile_info
*) objfile
->sym_private
)->debugsec
=
2926 /* Read the symbols. We keep them in core because we will want to
2927 access them randomly in read_symbol*. */
2928 val
= bfd_seek (abfd
, symtab_offset
, SEEK_SET
);
2930 error ("Error reading symbols from %s: %s",
2931 name
, bfd_errmsg (bfd_get_error ()));
2932 size
= coff_data (abfd
)->local_symesz
* num_symbols
;
2933 ((struct coff_symfile_info
*) objfile
->sym_private
)->symtbl
=
2934 obstack_alloc (&objfile
->symbol_obstack
, size
);
2935 ((struct coff_symfile_info
*) objfile
->sym_private
)->symtbl_num_syms
=
2938 val
= bfd_bread (((struct coff_symfile_info
*) objfile
->sym_private
)->symtbl
,
2941 perror_with_name ("reading symbol table");
2943 /* If we are reinitializing, or if we have never loaded syms yet, init */
2945 || (objfile
->global_psymbols
.size
== 0
2946 && objfile
->static_psymbols
.size
== 0))
2947 /* I'm not sure how how good num_symbols is; the rule of thumb in
2948 init_psymbol_list was developed for a.out. On the one hand,
2949 num_symbols includes auxents. On the other hand, it doesn't
2951 init_psymbol_list (objfile
, num_symbols
);
2953 free_pending_blocks ();
2954 back_to
= make_cleanup (really_free_pendings
, 0);
2956 init_minimal_symbol_collection ();
2957 make_cleanup_discard_minimal_symbols ();
2959 /* Now that the symbol table data of the executable file are all in core,
2960 process them and define symbols accordingly. */
2962 scan_xcoff_symtab (objfile
);
2964 /* Install any minimal symbols that have been collected as the current
2965 minimal symbols for this objfile. */
2967 install_minimal_symbols (objfile
);
2969 do_cleanups (back_to
);
2973 xcoff_symfile_offsets (struct objfile
*objfile
, struct section_addr_info
*addrs
)
2975 asection
*sect
= NULL
;
2978 objfile
->num_sections
= SECT_OFF_MAX
;
2979 objfile
->section_offsets
= (struct section_offsets
*)
2980 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
2982 /* Initialize the section indexes for future use. */
2983 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
2985 objfile
->sect_index_text
= sect
->index
;
2987 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
2989 objfile
->sect_index_data
= sect
->index
;
2991 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
2993 objfile
->sect_index_bss
= sect
->index
;
2995 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
2997 objfile
->sect_index_rodata
= sect
->index
;
2999 for (i
= 0; i
< objfile
->num_sections
; ++i
)
3001 /* syms_from_objfile kindly subtracts from addr the
3002 bfd_section_vma of the .text section. This strikes me as
3003 wrong--whether the offset to be applied to symbol reading is
3004 relative to the start address of the section depends on the
3005 symbol format. In any event, this whole "addr" concept is
3006 pretty broken (it doesn't handle any section but .text
3007 sensibly), so just ignore the addr parameter and use 0.
3008 rs6000-nat.c will set the correct section offsets via
3009 objfile_relocate. */
3010 (objfile
->section_offsets
)->offsets
[i
] = 0;
3014 /* Register our ability to parse symbols for xcoff BFD files. */
3016 static struct sym_fns xcoff_sym_fns
=
3019 /* It is possible that coff and xcoff should be merged as
3020 they do have fundamental similarities (for example, the extra storage
3021 classes used for stabs could presumably be recognized in any COFF file).
3022 However, in addition to obvious things like all the csect hair, there are
3023 some subtler differences between xcoffread.c and coffread.c, notably
3024 the fact that coffread.c has no need to read in all the symbols, but
3025 xcoffread.c reads all the symbols and does in fact randomly access them
3026 (in C_BSTAT and line number processing). */
3028 bfd_target_xcoff_flavour
,
3030 xcoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
3031 xcoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
3032 xcoff_initial_scan
, /* sym_read: read a symbol file into symtab */
3033 xcoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
3034 xcoff_symfile_offsets
, /* sym_offsets: xlate offsets ext->int form */
3035 NULL
/* next: pointer to next struct sym_fns */
3039 _initialize_xcoffread (void)
3041 add_symtab_fns (&xcoff_sym_fns
);
3043 func_symbol_type
= init_type (TYPE_CODE_FUNC
, 1, 0,
3044 "<function, no debug info>", NULL
);
3045 TYPE_TARGET_TYPE (func_symbol_type
) = builtin_type_int
;
3047 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
3048 "<variable, no debug info>", NULL
);