1 /* Read AIX xcoff symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993
3 Free Software Foundation, Inc.
4 Derived from coffread.c, dbxread.c, and a lot of hacking.
5 Contributed by IBM Corporation.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
23 /* Native only: Need struct tbtable in <sys/debug.h> from host, and
24 need xcoff_add_toc_to_loadinfo in rs6000-tdep.c from target.
25 need xcoff_init_loadinfo ditto.
26 However, if you grab <sys/debug.h> and make it available on your
27 host, and define FAKING_RS6000, then this code will compile. */
32 #include <sys/types.h>
37 #include <sys/param.h>
42 #include <sys/debug.h>
44 #include "coff/internal.h" /* FIXME, internal data from BFD */
45 #include "libcoff.h" /* FIXME, internal data from BFD */
46 #include "coff/rs6000.h" /* FIXME, raw file-format guts of xcoff */
53 #include "stabsread.h"
54 #include "complaints.h"
56 /* For interface with stabsread.c. */
57 #include "aout/stab_gnu.h"
59 /* Simplified internal version of coff symbol table information */
63 int c_symnum
; /* symbol number of this entry */
64 int c_naux
; /* 0 if syment only, 1 if syment + auxent */
66 unsigned char c_sclass
;
71 /* The COFF line table, in raw form. */
72 static char *linetab
= NULL
; /* Its actual contents */
73 static long linetab_offset
; /* Its offset in the file */
74 static unsigned long linetab_size
; /* Its size */
76 /* last function's saved coff symbol `cs' */
78 static struct coff_symbol fcn_cs_saved
;
80 static bfd
*symfile_bfd
;
82 /* Core address of start and end of text of current source file.
83 This is calculated from the first function seen after a C_FILE
87 static CORE_ADDR cur_src_end_addr
;
89 /* Core address of the end of the first object file. */
91 static CORE_ADDR first_object_file_end
;
93 /* pointer to the string table */
96 /* length of the string table */
97 static int strtbl_len
;
99 /* pointer to debug section */
100 static char *debugsec
;
102 /* pointer to the a.out symbol table */
105 /* Number of symbols in symtbl. */
106 static int symtbl_num_syms
;
108 /* initial symbol-table-debug-string vector length */
110 #define INITIAL_STABVECTOR_LENGTH 40
112 /* Nonzero if within a function (so symbols should be local,
113 if nothing says specifically). */
117 /* Local variables that hold the shift and mask values for the
118 COFF file that we are currently reading. These come back to us
119 from BFD, and are referenced by their macro names, as well as
120 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
121 macros from ../internalcoff.h . */
123 static unsigned local_n_btshft
;
124 static unsigned local_n_tmask
;
127 #define N_BTSHFT local_n_btshft
129 #define N_TMASK local_n_tmask
131 /* Local variables that hold the sizes in the file of various COFF structures.
132 (We only need to know this to read them from the file -- BFD will then
133 translate the data in them, into `internal_xxx' structs in the right
134 byte order, alignment, etc.) */
136 static unsigned local_symesz
;
138 struct coff_symfile_info
{
139 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
140 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
143 static struct complaint rsym_complaint
=
144 {"Non-stab C_RSYM `%s' needs special handling", 0, 0};
146 static struct complaint storclass_complaint
=
147 {"Unexpected storage class: %d", 0, 0};
149 static struct complaint bf_notfound_complaint
=
150 {"line numbers off, `.bf' symbol not found", 0, 0};
153 enter_line_range
PARAMS ((struct subfile
*, unsigned, unsigned,
154 CORE_ADDR
, CORE_ADDR
, unsigned *));
157 free_debugsection
PARAMS ((void));
160 init_debugsection
PARAMS ((bfd
*));
163 init_stringtab
PARAMS ((bfd
*, file_ptr
, struct objfile
*));
166 xcoff_symfile_init
PARAMS ((struct objfile
*));
169 xcoff_new_init
PARAMS ((struct objfile
*));
172 xcoff_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
175 xcoff_symfile_finish
PARAMS ((struct objfile
*));
177 static struct section_offsets
*
178 xcoff_symfile_offsets
PARAMS ((struct objfile
*, CORE_ADDR
));
181 init_lineno
PARAMS ((bfd
*, file_ptr
, int));
184 free_linetab
PARAMS ((void));
187 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
190 read_symbol
PARAMS ((struct internal_syment
*, int));
193 read_symbol_lineno
PARAMS ((int));
196 read_symbol_nvalue
PARAMS ((int));
198 static struct symbol
*
199 process_xcoff_symbol
PARAMS ((struct coff_symbol
*, struct objfile
*));
202 read_xcoff_symtab
PARAMS ((struct objfile
*, int));
205 add_stab_to_list
PARAMS ((char *, struct pending_stabs
**));
207 /* add a given stab string into given stab vector. */
210 add_stab_to_list (stabname
, stabvector
)
212 struct pending_stabs
**stabvector
;
214 if ( *stabvector
== NULL
) {
215 *stabvector
= (struct pending_stabs
*)
216 xmalloc (sizeof (struct pending_stabs
) +
217 INITIAL_STABVECTOR_LENGTH
* sizeof (char*));
218 (*stabvector
)->count
= 0;
219 (*stabvector
)->length
= INITIAL_STABVECTOR_LENGTH
;
221 else if ((*stabvector
)->count
>= (*stabvector
)->length
) {
222 (*stabvector
)->length
+= INITIAL_STABVECTOR_LENGTH
;
223 *stabvector
= (struct pending_stabs
*)
224 xrealloc ((char *) *stabvector
, sizeof (struct pending_stabs
) +
225 (*stabvector
)->length
* sizeof (char*));
227 (*stabvector
)->stab
[(*stabvector
)->count
++] = stabname
;
230 /* Linenos are processed on a file-by-file basis.
234 1) xlc (IBM's native c compiler) postpones static function code
235 emission to the end of a compilation unit. This way it can
236 determine if those functions (statics) are needed or not, and
237 can do some garbage collection (I think). This makes line
238 numbers and corresponding addresses unordered, and we end up
239 with a line table like:
256 and that breaks gdb's binary search on line numbers, if the
257 above table is not sorted on line numbers. And that sort
258 should be on function based, since gcc can emit line numbers
261 10 0x100 - for the init/test part of a for stmt.
264 10 0x400 - for the increment part of a for stmt.
266 arrange_linetable() will do this sorting.
268 2) aix symbol table might look like:
270 c_file // beginning of a new file
271 .bi // beginning of include file
272 .ei // end of include file
276 basically, .bi/.ei pairs do not necessarily encapsulate
277 their scope. They need to be recorded, and processed later
278 on when we come the end of the compilation unit.
279 Include table (inclTable) and process_linenos() handle
282 /* compare line table entry addresses. */
285 compare_lte (lte1
, lte2
)
286 struct linetable_entry
*lte1
, *lte2
;
288 return lte1
->pc
- lte2
->pc
;
291 /* Give a line table with function entries are marked, arrange its functions
292 in assending order and strip off function entry markers and return it in
293 a newly created table. If the old one is good enough, return the old one. */
294 /* FIXME: I think all this stuff can be replaced by just passing
295 sort_linevec = 1 to end_symtab. */
297 static struct linetable
*
298 arrange_linetable (oldLineTb
)
299 struct linetable
*oldLineTb
; /* old linetable */
302 newline
, /* new line count */
303 function_count
; /* # of functions */
305 struct linetable_entry
*fentry
; /* function entry vector */
306 int fentry_size
; /* # of function entries */
307 struct linetable
*newLineTb
; /* new line table */
309 #define NUM_OF_FUNCTIONS 20
311 fentry_size
= NUM_OF_FUNCTIONS
;
312 fentry
= (struct linetable_entry
*)
313 xmalloc (fentry_size
* sizeof (struct linetable_entry
));
315 for (function_count
=0, ii
=0; ii
<oldLineTb
->nitems
; ++ii
) {
317 if (oldLineTb
->item
[ii
].line
== 0) { /* function entry found. */
319 if (function_count
>= fentry_size
) { /* make sure you have room. */
321 fentry
= (struct linetable_entry
*)
322 xrealloc (fentry
, fentry_size
* sizeof (struct linetable_entry
));
324 fentry
[function_count
].line
= ii
;
325 fentry
[function_count
].pc
= oldLineTb
->item
[ii
].pc
;
330 if (function_count
== 0) {
334 else if (function_count
> 1)
335 qsort (fentry
, function_count
, sizeof(struct linetable_entry
), compare_lte
);
337 /* allocate a new line table. */
338 newLineTb
= (struct linetable
*)
340 (sizeof (struct linetable
) +
341 (oldLineTb
->nitems
- function_count
) * sizeof (struct linetable_entry
));
343 /* if line table does not start with a function beginning, copy up until
347 if (oldLineTb
->item
[0].line
!= 0)
349 newline
< oldLineTb
->nitems
&& oldLineTb
->item
[newline
].line
; ++newline
)
350 newLineTb
->item
[newline
] = oldLineTb
->item
[newline
];
352 /* Now copy function lines one by one. */
354 for (ii
=0; ii
< function_count
; ++ii
) {
355 for (jj
= fentry
[ii
].line
+ 1;
356 jj
< oldLineTb
->nitems
&& oldLineTb
->item
[jj
].line
!= 0;
358 newLineTb
->item
[newline
] = oldLineTb
->item
[jj
];
361 newLineTb
->nitems
= oldLineTb
->nitems
- function_count
;
367 /* We try to detect the beginning of a compilation unit. That info will
368 be used as an entry in line number recording routines (enter_line_range) */
370 static unsigned first_fun_line_offset
;
371 static unsigned first_fun_bf
;
373 #define mark_first_line(OFFSET, SYMNUM) \
374 if (!first_fun_line_offset) { \
375 first_fun_line_offset = OFFSET; \
376 first_fun_bf = SYMNUM; \
380 /* include file support: C_BINCL/C_EINCL pairs will be kept in the
381 following `IncludeChain'. At the end of each symtab (end_symtab),
382 we will determine if we should create additional symtab's to
383 represent if (the include files. */
386 typedef struct _inclTable
{
387 char *name
; /* include filename */
389 /* Offsets to the line table. end points to the last entry which is
390 part of this include file. */
393 struct subfile
*subfile
;
394 unsigned funStartLine
; /* start line # of its function */
397 #define INITIAL_INCLUDE_TABLE_LENGTH 20
398 static InclTable
*inclTable
; /* global include table */
399 static int inclIndx
; /* last entry to table */
400 static int inclLength
; /* table length */
401 static int inclDepth
; /* nested include depth */
405 record_include_begin (cs
)
406 struct coff_symbol
*cs
;
410 /* In xcoff, we assume include files cannot be nested (not in .c files
411 of course, but in corresponding .s files.). */
413 /* This can happen with old versions of GCC.
414 GCC 2.3.3-930426 does not exhibit this on a test case which
415 a user said produced the message for him. */
416 static struct complaint msg
= {"Nested C_BINCL symbols", 0, 0};
421 /* allocate an include file, or make room for the new entry */
422 if (inclLength
== 0) {
423 inclTable
= (InclTable
*)
424 xmalloc (sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
425 memset (inclTable
, '\0', sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
426 inclLength
= INITIAL_INCLUDE_TABLE_LENGTH
;
429 else if (inclIndx
>= inclLength
) {
430 inclLength
+= INITIAL_INCLUDE_TABLE_LENGTH
;
431 inclTable
= (InclTable
*)
432 xrealloc (inclTable
, sizeof (InclTable
) * inclLength
);
433 memset (inclTable
+inclLength
-INITIAL_INCLUDE_TABLE_LENGTH
,
434 '\0', sizeof (InclTable
)*INITIAL_INCLUDE_TABLE_LENGTH
);
437 inclTable
[inclIndx
].name
= cs
->c_name
;
438 inclTable
[inclIndx
].begin
= cs
->c_value
;
443 record_include_end (cs
)
444 struct coff_symbol
*cs
;
450 static struct complaint msg
= {"Mismatched C_BINCL/C_EINCL pair", 0, 0};
454 pTbl
= &inclTable
[inclIndx
];
455 pTbl
->end
= cs
->c_value
;
462 /* given the start and end addresses of a compilation unit (or a csect, at times)
463 process its lines and create appropriate line vectors. */
466 process_linenos (start
, end
)
467 CORE_ADDR start
, end
;
472 struct subfile main_subfile
; /* subfile structure for the main
475 /* in the main source file, any time we see a function entry, we reset
476 this variable to function's absolute starting line number. All the
477 following line numbers in the function are relative to this, and
478 we record absolute line numbers in record_line(). */
480 int main_source_baseline
= 0;
486 if (!(offset
= first_fun_line_offset
))
487 goto return_after_cleanup
;
489 memset (&main_subfile
, '\0', sizeof (main_subfile
));
490 first_fun_line_offset
= 0;
493 /* All source lines were in the main source file. None in include files. */
495 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
496 &main_source_baseline
);
498 /* else, there was source with line numbers in include files */
501 main_source_baseline
= 0;
502 for (ii
=0; ii
< inclIndx
; ++ii
) {
504 struct subfile
*tmpSubfile
;
506 /* if there is main file source before include file, enter it. */
507 if (offset
< inclTable
[ii
].begin
) {
509 (&main_subfile
, offset
, inclTable
[ii
].begin
- LINESZ
, start
, 0,
510 &main_source_baseline
);
513 /* Have a new subfile for the include file */
515 tmpSubfile
= inclTable
[ii
].subfile
= (struct subfile
*)
516 xmalloc (sizeof (struct subfile
));
518 memset (tmpSubfile
, '\0', sizeof (struct subfile
));
519 firstLine
= &(inclTable
[ii
].funStartLine
);
521 /* enter include file's lines now. */
522 enter_line_range (tmpSubfile
, inclTable
[ii
].begin
,
523 inclTable
[ii
].end
, start
, 0, firstLine
);
525 offset
= inclTable
[ii
].end
+ LINESZ
;
528 /* all the include files' line have been processed at this point. Now,
529 enter remaining lines of the main file, if any left. */
530 if (offset
< (linetab_offset
+ linetab_size
+ 1 - LINESZ
)) {
531 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
532 &main_source_baseline
);
536 /* Process main file's line numbers. */
537 if (main_subfile
.line_vector
) {
538 struct linetable
*lineTb
, *lv
;
540 lv
= main_subfile
.line_vector
;
542 /* Line numbers are not necessarily ordered. xlc compilation will
543 put static function to the end. */
545 lineTb
= arrange_linetable (lv
);
547 current_subfile
->line_vector
= (struct linetable
*)
548 xrealloc (lv
, (sizeof (struct linetable
)
549 + lv
->nitems
* sizeof (struct linetable_entry
)));
554 current_subfile
->line_vector
= lineTb
;
557 current_subfile
->line_vector_length
=
558 current_subfile
->line_vector
->nitems
;
561 /* Now, process included files' line numbers. */
563 for (ii
=0; ii
< inclIndx
; ++ii
) {
565 if ( (inclTable
[ii
].subfile
)->line_vector
) { /* Useless if!!! FIXMEmgo */
566 struct linetable
*lineTb
, *lv
;
568 lv
= (inclTable
[ii
].subfile
)->line_vector
;
570 /* Line numbers are not necessarily ordered. xlc compilation will
571 put static function to the end. */
573 lineTb
= arrange_linetable (lv
);
577 /* For the same include file, we might want to have more than one subfile.
578 This happens if we have something like:
586 while foo.h including code in it. (stupid but possible)
587 Since start_subfile() looks at the name and uses an existing one if finds,
588 we need to provide a fake name and fool it. */
590 /* start_subfile (inclTable[ii].name, (char*)0); */
591 start_subfile (" ?", (char*)0);
592 free (current_subfile
->name
);
593 current_subfile
->name
= strdup (inclTable
[ii
].name
);
596 current_subfile
->line_vector
= (struct linetable
*)
597 xrealloc (lv
, (sizeof (struct linetable
)
598 + lv
->nitems
* sizeof (struct linetable_entry
)));
603 current_subfile
->line_vector
= lineTb
;
606 current_subfile
->line_vector_length
=
607 current_subfile
->line_vector
->nitems
;
608 start_subfile (pop_subfile (), (char*)0);
612 return_after_cleanup
:
614 /* We don't want to keep alloc/free'ing the global include file table. */
617 /* start with a fresh subfile structure for the next file. */
618 memset (&main_subfile
, '\0', sizeof (struct subfile
));
622 aix_process_linenos ()
624 /* process line numbers and enter them into line vector */
625 process_linenos (last_source_start_addr
, cur_src_end_addr
);
629 /* Enter a given range of lines into the line vector.
630 can be called in the following two ways:
631 enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or
632 enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine)
634 endoffset points to the last line table entry that we should pay
638 enter_line_range (subfile
, beginoffset
, endoffset
, startaddr
, endaddr
, firstLine
)
639 struct subfile
*subfile
;
640 unsigned beginoffset
, endoffset
; /* offsets to line table */
641 CORE_ADDR startaddr
, endaddr
;
647 /* Do Byte swapping, if needed. FIXME! */
648 #define P_LINENO(PP) (*(unsigned short*)((struct external_lineno*)(PP))->l_lnno)
649 #define P_LINEADDR(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_paddr)
650 #define P_LINESYM(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_symndx)
652 pp
= &linetab
[beginoffset
- linetab_offset
];
653 if (endoffset
!= 0 && endoffset
- linetab_offset
>= linetab_size
)
655 static struct complaint msg
=
656 {"Bad line table offset in C_EINCL directive", 0, 0};
660 limit
= endoffset
? &linetab
[endoffset
- linetab_offset
]
661 : &linetab
[linetab_size
-1];
663 while (pp
<= limit
) {
665 /* find the address this line represents */
666 addr
= P_LINENO(pp
) ?
667 P_LINEADDR(pp
) : read_symbol_nvalue (P_LINESYM(pp
));
669 if (addr
< startaddr
|| (endaddr
&& addr
>= endaddr
))
672 if (P_LINENO(pp
) == 0) {
673 *firstLine
= read_symbol_lineno (P_LINESYM(pp
));
674 record_line (subfile
, 0, addr
);
678 record_line (subfile
, *firstLine
+ P_LINENO(pp
), addr
);
685 int fsize
; /* file size */
686 int fixedparms
; /* number of fixed parms */
687 int floatparms
; /* number of float parms */
688 unsigned int parminfo
; /* parameter info.
689 See /usr/include/sys/debug.h
690 tbtable_ext.parminfo */
691 int framesize
; /* function frame size */
695 /* Given a function symbol, return its traceback information. */
698 retrieve_tracebackinfo (abfd
, textsec
, cs
)
701 struct coff_symbol
*cs
;
703 #define TBTABLE_BUFSIZ 2000
705 static TracebackInfo tbInfo
;
708 static char buffer
[TBTABLE_BUFSIZ
];
711 int bytesread
=0; /* total # of bytes read so far */
712 int bufferbytes
; /* number of bytes in the buffer */
714 int functionstart
= cs
->c_value
- textsec
->vma
;
716 memset (&tbInfo
, '\0', sizeof (tbInfo
));
718 /* keep reading blocks of data from the text section, until finding a zero
719 word and a traceback table. */
721 /* Note: The logical thing way to write this code would be to assign
722 to bufferbytes within the while condition. But that triggers a
723 compiler (xlc in AIX 3.2) bug, so simplify it... */
725 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
726 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
728 && (bfd_get_section_contents
729 (abfd
, textsec
, buffer
,
730 (file_ptr
)(functionstart
+ bytesread
), bufferbytes
)))
732 bytesread
+= bufferbytes
;
733 pinsn
= (int*) buffer
;
735 /* if this is the first time we filled the buffer, retrieve function
738 if (bytesread
== bufferbytes
) {
740 /* skip over unrelated instructions */
742 if (*pinsn
== 0x7c0802a6) /* mflr r0 */
744 if ((*pinsn
& 0xfc00003e) == 0x7c000026) /* mfcr Rx */
746 if ((*pinsn
& 0xfc000000) == 0x48000000) /* bl foo, save fprs */
748 if ((*pinsn
& 0xfc1f0000) == 0xbc010000) /* stm Rx, NUM(r1) */
752 int tmp
= (*pinsn
>> 16) & 0xffff;
754 if (tmp
== 0x9421) { /* stu r1, NUM(r1) */
755 tbInfo
.framesize
= 0x10000 - (*pinsn
& 0xffff);
758 else if ((*pinsn
== 0x93e1fffc) || /* st r31,-4(r1) */
759 (tmp
== 0x9001)) /* st r0, NUM(r1) */
761 /* else, could not find a frame size. */
765 } while (++pinsn
&& *pinsn
);
767 if (!tbInfo
.framesize
)
772 /* look for a zero word. */
774 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
777 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
782 /* function size is the amount of bytes we have skipped so far. */
783 tbInfo
.fsize
= bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
);
787 /* if we don't have the whole traceback table in the buffer, re-read
790 /* This is how much to read to get the traceback table.
791 8 bytes of the traceback table are always present, plus we
793 #define MIN_TBTABSIZ 12
795 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
797 /* In case if we are *very* close to the end of the text section
798 and cannot read properly from that point on, abort by returning
801 This could happen if the traceback table is only 8 bytes,
802 but we try to read 12 bytes of it.
803 Handle this case more graciously -- FIXME */
805 if (!bfd_get_section_contents (
806 abfd
, textsec
, buffer
,
807 (file_ptr
)(functionstart
+
808 bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
)),MIN_TBTABSIZ
))
809 { printf_unfiltered ("Abnormal return!..\n"); return NULL
; }
811 ptb
= (struct tbtable
*)buffer
;
814 ptb
= (struct tbtable
*)pinsn
;
816 tbInfo
.fixedparms
= ptb
->tb
.fixedparms
;
817 tbInfo
.floatparms
= ptb
->tb
.floatparms
;
818 tbInfo
.parminfo
= ptb
->tb_ext
.parminfo
;
822 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
823 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
829 /* Given a function symbol, return a pointer to its traceback table. */
832 retrieve_traceback (abfd
, textsec
, cs
, size
)
835 struct coff_symbol
*cs
;
836 int *size
; /* return function size */
838 #define TBTABLE_BUFSIZ 2000
839 #define MIN_TBTABSIZ 50 /* minimum buffer size to hold a
842 static char buffer
[TBTABLE_BUFSIZ
];
845 int bytesread
=0; /* total # of bytes read so far */
846 int bufferbytes
; /* number of bytes in the buffer */
848 int functionstart
= cs
->c_value
- textsec
->filepos
+ textsec
->vma
;
851 /* keep reading blocks of data from the text section, until finding a zero
852 word and a traceback table. */
854 while (bfd_get_section_contents (abfd
, textsec
, buffer
,
855 (file_ptr
)(functionstart
+ bytesread
),
857 (TBTABLE_BUFSIZ
< (textsec
->size
- functionstart
- bytesread
)) ?
858 TBTABLE_BUFSIZ
: (textsec
->size
- functionstart
- bytesread
))))
860 bytesread
+= bufferbytes
;
861 pinsn
= (int*) buffer
;
863 /* look for a zero word. */
865 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
868 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
873 /* function size is the amount of bytes we have skipped so far. */
874 *size
= bytesread
- (buffer
+ bufferbytes
- pinsn
);
878 /* if we don't have the whole traceback table in the buffer, re-read
881 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
883 /* In case if we are *very* close to the end of the text section
884 and cannot read properly from that point on, abort for now.
885 Handle this case more graciously -- FIXME */
887 if (!bfd_get_section_contents (
888 abfd
, textsec
, buffer
,
889 (file_ptr
)(functionstart
+
890 bytesread
- (buffer
+ bufferbytes
- pinsn
)),MIN_TBTABSIZ
))
891 /* abort (); */ { printf_unfiltered ("abort!!!\n"); return NULL
; }
893 return (struct tbtable
*)buffer
;
896 return (struct tbtable
*)pinsn
;
906 /* Save the vital information for use when closing off the current file.
907 NAME is the file name the symbols came from, START_ADDR is the first
908 text address for the file, and SIZE is the number of bytes of text. */
910 #define complete_symtab(name, start_addr) { \
911 last_source_file = savestring (name, strlen (name)); \
912 last_source_start_addr = start_addr; \
916 /* Refill the symbol table input buffer
917 and set the variables that control fetching entries from it.
918 Reports an error if no data available.
919 This function can read past the end of the symbol table
920 (into the string table) but this does no harm. */
922 /* Reading symbol table has to be fast! Keep the followings as macros, rather
925 #define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, ALLOCED, SECTION, OBJFILE) \
929 namestr = (NAME) + 1; \
932 obstack_copy0 (&objfile->symbol_obstack, (NAME) + 1, strlen ((NAME)+1)); \
935 prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \
936 (char *)NULL, (SECTION), (OBJFILE)); \
937 misc_func_recorded = 1; \
941 /* A parameter template, used by ADD_PARM_TO_PENDING. It is initialized
942 in our initializer function at the bottom of the file, to avoid
943 dependencies on the exact "struct symbol" format. */
945 static struct symbol parmsym
;
947 /* Add a parameter to a given pending symbol list. */
949 #define ADD_PARM_TO_PENDING(PARM, VALUE, PTYPE, PENDING_SYMBOLS) \
951 PARM = (struct symbol *) \
952 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
954 SYMBOL_TYPE (PARM) = PTYPE; \
955 SYMBOL_VALUE (PARM) = VALUE; \
956 add_symbol_to_list (PARM, &PENDING_SYMBOLS); \
960 /* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
961 nested. At any given time, a symbol can only be in one static block.
962 This is the base address of current static block, zero if non exists. */
964 static int static_block_base
= 0;
966 /* Section number for the current static block. */
968 static int static_block_section
= -1;
970 /* true if space for symbol name has been allocated. */
972 static int symname_alloced
= 0;
974 /* Next symbol to read. Pointer into raw seething symbol table. */
976 static char *raw_symbol
;
978 /* This is the function which stabsread.c calls to get symbol
981 xcoff_next_symbol_text ()
983 struct internal_syment symbol
;
984 static struct complaint msg
=
985 {"Unexpected symbol continuation", 0, 0};
987 bfd_coff_swap_sym_in (current_objfile
->obfd
, raw_symbol
, &symbol
);
990 else if (symbol
.n_sclass
& 0x80)
991 return debugsec
+ symbol
.n_offset
;
994 raw_symbol
+= coff_data (current_objfile
->obfd
)->local_symesz
;
998 /* read the whole symbol table of a given bfd. */
1001 read_xcoff_symtab (objfile
, nsyms
)
1002 struct objfile
*objfile
; /* Object file we're reading from */
1003 int nsyms
; /* # of symbols */
1005 bfd
*abfd
= objfile
->obfd
;
1006 char *raw_auxptr
; /* Pointer to first raw aux entry for sym */
1007 sec_ptr textsec
; /* Pointer to text section */
1008 TracebackInfo
*ptb
; /* Pointer to traceback table */
1010 struct internal_syment symbol
[1];
1011 union internal_auxent main_aux
;
1012 struct coff_symbol cs
[1];
1013 CORE_ADDR file_start_addr
= 0;
1014 CORE_ADDR file_end_addr
= 0;
1016 int next_file_symnum
= -1;
1017 int just_started
= 1;
1019 int toc_offset
= 0; /* toc offset value in data section. */
1023 long fcn_line_offset
;
1026 struct coff_symbol fcn_stab_saved
;
1028 /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
1029 union internal_auxent fcn_aux_saved
;
1030 struct type
*fcn_type_saved
= NULL
;
1031 struct context_stack
*new;
1033 char *filestring
= " _start_ "; /* Name of the current file. */
1035 char *last_csect_name
; /* last seen csect's name and value */
1036 CORE_ADDR last_csect_val
;
1038 int misc_func_recorded
; /* true if any misc. function */
1040 current_objfile
= objfile
;
1042 /* Get the appropriate COFF "constants" related to the file we're handling. */
1043 N_TMASK
= coff_data (abfd
)->local_n_tmask
;
1044 N_BTSHFT
= coff_data (abfd
)->local_n_btshft
;
1045 local_symesz
= coff_data (abfd
)->local_symesz
;
1047 last_source_file
= NULL
;
1048 last_csect_name
= 0;
1050 misc_func_recorded
= 0;
1053 start_symtab (filestring
, (char *)NULL
, file_start_addr
);
1055 first_object_file_end
= 0;
1057 /* Allocate space for the entire symbol table at once, and read it
1058 all in. The bfd is already positioned at the beginning of
1059 the symbol table. */
1061 size
= coff_data (abfd
)->local_symesz
* nsyms
;
1062 symtbl
= xmalloc (size
);
1063 symtbl_num_syms
= nsyms
;
1065 val
= bfd_read (symtbl
, size
, 1, abfd
);
1067 perror_with_name ("reading symbol table");
1069 raw_symbol
= symtbl
;
1071 textsec
= bfd_get_section_by_name (abfd
, ".text");
1073 printf_unfiltered ("Unable to locate text section!\n");
1076 next_symbol_text_func
= xcoff_next_symbol_text
;
1078 while (symnum
< nsyms
) {
1080 QUIT
; /* make this command interruptable. */
1082 /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
1083 /* read one symbol into `cs' structure. After processing the whole symbol
1084 table, only string table will be kept in memory, symbol table and debug
1085 section of xcoff will be freed. Thus we can mark symbols with names
1086 in string table as `alloced'. */
1090 /* Swap and align the symbol into a reasonable C structure. */
1091 bfd_coff_swap_sym_in (abfd
, raw_symbol
, symbol
);
1093 cs
->c_symnum
= symnum
;
1094 cs
->c_naux
= symbol
->n_numaux
;
1095 if (symbol
->n_zeroes
) {
1096 symname_alloced
= 0;
1097 /* We must use the original, unswapped, name here so the name field
1098 pointed to by cs->c_name will persist throughout xcoffread. If
1099 we use the new field, it gets overwritten for each symbol. */
1100 cs
->c_name
= ((struct external_syment
*)raw_symbol
)->e
.e_name
;
1101 /* If it's exactly E_SYMNMLEN characters long it isn't
1103 if (cs
->c_name
[E_SYMNMLEN
- 1] != '\0')
1106 p
= obstack_alloc (&objfile
->symbol_obstack
, E_SYMNMLEN
+ 1);
1107 strncpy (p
, cs
->c_name
, E_SYMNMLEN
);
1108 p
[E_SYMNMLEN
] = '\0';
1110 symname_alloced
= 1;
1112 } else if (symbol
->n_sclass
& 0x80) {
1113 cs
->c_name
= debugsec
+ symbol
->n_offset
;
1114 symname_alloced
= 0;
1115 } else { /* in string table */
1116 cs
->c_name
= strtbl
+ (int)symbol
->n_offset
;
1117 symname_alloced
= 1;
1119 cs
->c_value
= symbol
->n_value
;
1120 cs
->c_sclass
= symbol
->n_sclass
;
1121 cs
->c_secnum
= symbol
->n_scnum
;
1122 cs
->c_type
= (unsigned)symbol
->n_type
;
1124 raw_symbol
+= coff_data (abfd
)->local_symesz
;
1127 raw_auxptr
= raw_symbol
; /* Save addr of first aux entry */
1129 /* Skip all the auxents associated with this symbol. */
1130 for (ii
= symbol
->n_numaux
; ii
; --ii
) {
1131 raw_symbol
+= coff_data (abfd
)->local_auxesz
;
1136 /* if symbol name starts with ".$" or "$", ignore it. */
1137 if (cs
->c_name
[0] == '$' || (cs
->c_name
[1] == '$' && cs
->c_name
[0] == '.'))
1140 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
) {
1141 if (last_source_file
)
1143 end_symtab (cur_src_end_addr
, 1, 0, objfile
, textsec
->target_index
);
1148 start_symtab ("_globals_", (char *)NULL
, (CORE_ADDR
)0);
1149 cur_src_end_addr
= first_object_file_end
;
1150 /* done with all files, everything from here on is globals */
1153 /* if explicitly specified as a function, treat is as one. */
1154 if (ISFCN(cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
) {
1155 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1156 0, cs
->c_naux
, &main_aux
);
1157 goto function_entry_point
;
1160 if ((cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_HIDEXT
) && cs
->c_naux
== 1)
1162 /* dealing with a symbol with a csect entry. */
1164 # define CSECT(PP) ((PP)->x_csect)
1165 # define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
1166 # define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1167 # define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1168 # define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1170 /* Convert the auxent to something we can access. */
1171 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1172 0, cs
->c_naux
, &main_aux
);
1174 switch (CSECT_SMTYP (&main_aux
)) {
1177 continue; /* ignore all external references. */
1179 case XTY_SD
: /* a section description. */
1181 switch (CSECT_SCLAS (&main_aux
)) {
1183 case XMC_PR
: /* a `.text' csect. */
1186 /* A program csect is seen. We have to allocate one
1187 symbol table for each program csect. Normally gdb
1188 prefers one symtab for each source file. In case
1189 of AIX, one source file might include more than one
1190 [PR] csect, and they don't have to be adjacent in
1191 terms of the space they occupy in memory. Thus, one
1192 single source file might get fragmented in the
1193 memory and gdb's file start and end address
1194 approach does not work! GCC (and I think xlc) seem
1195 to put all the code in the unnamed program csect. */
1197 if (last_csect_name
) {
1199 /* if no misc. function recorded in the last seen csect, enter
1200 it as a function. This will take care of functions like
1201 strcmp() compiled by xlc. */
1203 if (!misc_func_recorded
) {
1205 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1206 mst_text
, alloced
, last_csect_sec
,
1211 complete_symtab (filestring
, file_start_addr
);
1212 cur_src_end_addr
= file_end_addr
;
1213 end_symtab (file_end_addr
, 1, 0, objfile
,
1214 textsec
->target_index
);
1217 /* Give all csects for this source file the same
1219 start_symtab (filestring
, (char *)NULL
, (CORE_ADDR
)0);
1222 /* If this is the very first csect seen, basically `__start'. */
1224 first_object_file_end
= cs
->c_value
+ CSECT_LEN (&main_aux
);
1228 file_start_addr
= cs
->c_value
;
1229 file_end_addr
= cs
->c_value
+ CSECT_LEN (&main_aux
);
1231 if (cs
->c_name
&& cs
->c_name
[0] == '.') {
1232 last_csect_name
= cs
->c_name
;
1233 last_csect_val
= cs
->c_value
;
1234 last_csect_sec
= cs
->c_secnum
;
1237 misc_func_recorded
= 0;
1243 /* If the section is not a data description, ignore it. Note that
1244 uninitialized data will show up as XTY_CM/XMC_RW pair. */
1248 warning ("More than one xmc_tc0 symbol found.");
1249 toc_offset
= cs
->c_value
;
1252 case XMC_TC
: /* ignore toc entries */
1253 default : /* any other XMC_XXX */
1257 break; /* switch CSECT_SCLAS() */
1261 /* a function entry point. */
1262 if (CSECT_SCLAS (&main_aux
) == XMC_PR
) {
1264 function_entry_point
:
1265 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
, mst_text
,
1266 symname_alloced
, cs
->c_secnum
, objfile
);
1268 fcn_line_offset
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1269 fcn_start_addr
= cs
->c_value
;
1271 /* save the function header info, which will be used
1272 when `.bf' is seen. */
1274 fcn_aux_saved
= main_aux
;
1279 /* If function has two auxent, then debugging information is
1280 already available for it. Process traceback table for
1281 functions with only one auxent. */
1283 if (cs
->c_naux
== 1)
1284 ptb
= retrieve_tracebackinfo (abfd
, textsec
, cs
);
1286 else if (cs
->c_naux
!= 2)
1288 static struct complaint msg
=
1289 {"Expected one or two auxents for function", 0, 0};
1293 /* If there is traceback info, create and add parameters for it. */
1295 if (ptb
&& (ptb
->fixedparms
|| ptb
->floatparms
)) {
1297 int parmcnt
= ptb
->fixedparms
+ ptb
->floatparms
;
1298 char *parmcode
= (char*) &ptb
->parminfo
;
1299 int parmvalue
= ptb
->framesize
+ 0x18; /* sizeof(LINK AREA) == 0x18 */
1300 unsigned int ii
, mask
;
1302 for (ii
=0, mask
= 0x80000000; ii
<parmcnt
; ++ii
) {
1303 struct symbol
*parm
;
1305 if (ptb
->parminfo
& mask
) { /* float or double */
1307 if (ptb
->parminfo
& mask
) { /* double parm */
1309 (parm
, parmvalue
, builtin_type_double
, local_symbols
);
1310 parmvalue
+= sizeof (double);
1312 else { /* float parm */
1314 (parm
, parmvalue
, builtin_type_float
, local_symbols
);
1315 parmvalue
+= sizeof (float);
1318 else { /* fixed parm, use (int*) for hex rep. */
1319 ADD_PARM_TO_PENDING (parm
, parmvalue
,
1320 lookup_pointer_type (builtin_type_int
),
1322 parmvalue
+= sizeof (int);
1327 /* Fake this as a function. Needed in process_xcoff_symbol() */
1330 finish_block(process_xcoff_symbol (cs
, objfile
), &local_symbols
,
1331 pending_blocks
, cs
->c_value
,
1332 cs
->c_value
+ ptb
->fsize
, objfile
);
1336 /* shared library function trampoline code entry point. */
1337 else if (CSECT_SCLAS (&main_aux
) == XMC_GL
) {
1339 /* record trampoline code entries as mst_solib_trampoline symbol.
1340 When we lookup mst symbols, we will choose mst_text over
1341 mst_solib_trampoline. */
1344 /* After the implementation of incremental loading of shared
1345 libraries, we don't want to access trampoline entries. This
1346 approach has a consequence of the necessity to bring the whole
1347 shared library at first, in order do anything with it (putting
1348 breakpoints, using malloc, etc). On the other side, this is
1349 consistient with gdb's behaviour on a SUN platform. */
1351 /* Trying to prefer *real* function entry over its trampoline,
1352 by assigning `mst_solib_trampoline' type to trampoline entries
1353 fails. Gdb treats those entries as chars. FIXME. */
1355 /* Recording this entry is necessary. Single stepping relies on
1356 this vector to get an idea about function address boundaries. */
1358 prim_record_minimal_symbol_and_info
1359 ("<trampoline>", cs
->c_value
, mst_solib_trampoline
,
1360 (char *)NULL
, cs
->c_secnum
, objfile
);
1363 /* record trampoline code entries as mst_solib_trampoline symbol.
1364 When we lookup mst symbols, we will choose mst_text over
1365 mst_solib_trampoline. */
1367 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
,
1368 mst_solib_trampoline
,
1369 symname_alloced
, objfile
);
1375 default : /* all other XTY_XXXs */
1377 } /* switch CSECT_SMTYP() */ }
1379 switch (cs
->c_sclass
) {
1383 /* see if the last csect needs to be recorded. */
1385 if (last_csect_name
&& !misc_func_recorded
) {
1387 /* if no misc. function recorded in the last seen csect, enter
1388 it as a function. This will take care of functions like
1389 strcmp() compiled by xlc. */
1392 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1393 mst_text
, alloced
, last_csect_sec
, objfile
);
1396 /* c_value field contains symnum of next .file entry in table
1397 or symnum of first global after last .file. */
1399 next_file_symnum
= cs
->c_value
;
1401 /* complete symbol table for last object file containing
1402 debugging information. */
1404 /* Whether or not there was a csect in the previous file, we have to call
1405 `end_stabs' and `start_stabs' to reset type_vector,
1406 line_vector, etc. structures. */
1408 complete_symtab (filestring
, file_start_addr
);
1409 cur_src_end_addr
= file_end_addr
;
1410 end_symtab (file_end_addr
, 1, 0, objfile
, textsec
->target_index
);
1413 /* XCOFF, according to the AIX 3.2 documentation, puts the filename
1414 in cs->c_name. But xlc 1.3.0.2 has decided to do things the
1415 standard COFF way and put it in the auxent. We use the auxent if
1416 there is one, otherwise use the name. Simple enough. */
1418 filestring
= coff_getfilename (&main_aux
);
1420 filestring
= cs
->c_name
;
1423 start_symtab (filestring
, (char *)NULL
, (CORE_ADDR
)0);
1424 last_csect_name
= 0;
1426 /* reset file start and end addresses. A compilation unit with no text
1427 (only data) should have zero file boundaries. */
1428 file_start_addr
= file_end_addr
= 0;
1433 fcn_stab_saved
= *cs
;
1438 if (STREQ (cs
->c_name
, ".bf")) {
1440 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1441 0, cs
->c_naux
, &main_aux
);
1443 within_function
= 1;
1445 mark_first_line (fcn_line_offset
, cs
->c_symnum
);
1447 new = push_context (0, fcn_start_addr
);
1449 new->name
= define_symbol
1450 (fcn_cs_saved
.c_value
, fcn_stab_saved
.c_name
, 0, 0, objfile
);
1451 if (new->name
!= NULL
)
1452 SYMBOL_SECTION (new->name
) = cs
->c_secnum
;
1454 else if (STREQ (cs
->c_name
, ".ef")) {
1456 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1457 0, cs
->c_naux
, &main_aux
);
1459 /* the value of .ef is the address of epilogue code;
1460 not useful for gdb */
1461 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1462 contains number of lines to '}' */
1464 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1465 new = pop_context ();
1466 if (context_stack_depth
!= 0)
1467 error ("invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.",
1470 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1472 fcn_cs_saved
.c_value
+
1473 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
, objfile
);
1474 within_function
= 0;
1478 case C_BSTAT
: /* begin static block */
1480 struct internal_syment symbol
;
1482 read_symbol (&symbol
, cs
->c_value
);
1483 static_block_base
= symbol
.n_value
;
1484 static_block_section
= symbol
.n_scnum
;
1488 case C_ESTAT
: /* end of static block */
1489 static_block_base
= 0;
1490 static_block_section
= -1;
1493 case C_ARG
: /* These are not implemented. */
1499 printf_unfiltered ("ERROR: Unimplemented storage class: %d.\n", cs
->c_sclass
);
1502 case C_HIDEXT
: /* ignore these.. */
1507 case C_BINCL
: /* beginning of include file */
1509 /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1510 order. Thus, when wee see them, we might not know enough info
1511 to process them. Thus, we'll be saving them into a table
1512 (inclTable) and postpone their processing. */
1514 record_include_begin (cs
);
1517 case C_EINCL
: /* end of include file */
1518 /* see the comment after case C_BINCL. */
1519 record_include_end (cs
);
1523 if (STREQ (cs
->c_name
, ".bb")) {
1525 new = push_context (depth
, cs
->c_value
);
1527 else if (STREQ (cs
->c_name
, ".eb")) {
1528 new = pop_context ();
1529 if (depth
!= new->depth
)
1530 error ("Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
1534 if (local_symbols
&& context_stack_depth
> 0) {
1535 /* Make a block for the local symbols within. */
1536 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1537 new->start_addr
, cs
->c_value
, objfile
);
1539 local_symbols
= new->locals
;
1544 process_xcoff_symbol (cs
, objfile
);
1550 if (last_source_file
)
1552 end_symtab (cur_src_end_addr
, 1, 0, objfile
, textsec
->target_index
);
1557 current_objfile
= NULL
;
1559 /* Record the toc offset value of this symbol table into ldinfo structure.
1560 If no XMC_TC0 is found, toc_offset should be zero. Another place to obtain
1561 this information would be file auxiliary header. */
1563 #ifndef FAKING_RS6000
1564 xcoff_add_toc_to_loadinfo (toc_offset
);
1568 #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1569 (SYMBOL2) = (struct symbol *) \
1570 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1571 *(SYMBOL2) = *(SYMBOL1);
1574 #define SYMNAME_ALLOC(NAME, ALLOCED) \
1575 (ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME));
1578 /* process one xcoff symbol. */
1580 static struct symbol
*
1581 process_xcoff_symbol (cs
, objfile
)
1582 register struct coff_symbol
*cs
;
1583 struct objfile
*objfile
;
1585 struct symbol onesymbol
;
1586 register struct symbol
*sym
= &onesymbol
;
1587 struct symbol
*sym2
= NULL
;
1589 char *name
, *pp
, *qq
;
1590 int struct_and_type_combined
;
1597 memset (sym
, '\0', sizeof (struct symbol
));
1599 /* default assumptions */
1600 SYMBOL_VALUE (sym
) = cs
->c_value
;
1601 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1602 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1604 if (ISFCN (cs
->c_type
)) {
1606 /* At this point, we don't know the type of the function and assume it
1607 is int. This will be patched with the type from its stab entry later
1608 on in patch_block_stabs () */
1610 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1611 SYMBOL_TYPE (sym
) = lookup_function_type (lookup_fundamental_type (objfile
, FT_INTEGER
));
1613 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1614 SYMBOL_DUP (sym
, sym2
);
1616 if (cs
->c_sclass
== C_EXT
)
1617 add_symbol_to_list (sym2
, &global_symbols
);
1618 else if (cs
->c_sclass
== C_HIDEXT
|| cs
->c_sclass
== C_STAT
)
1619 add_symbol_to_list (sym2
, &file_symbols
);
1624 /* in case we can't figure out the type, default is `int'. */
1625 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
1627 switch (cs
->c_sclass
)
1631 if (fcn_cs_saved
.c_sclass
== C_EXT
)
1632 add_stab_to_list (name
, &global_stabs
);
1634 add_stab_to_list (name
, &file_stabs
);
1639 add_stab_to_list (name
, &global_stabs
);
1643 common_block_start (cs
->c_name
, objfile
);
1647 common_block_end (objfile
);
1651 complain (&storclass_complaint
, cs
->c_sclass
);
1659 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1662 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1668 /* For xlc (not GCC), the 'V' symbol descriptor is used for all
1669 statics and we need to distinguish file-scope versus function-scope
1670 using within_function. We do this by changing the string we pass
1671 to define_symbol to use 'S' where we need to, which is not necessarily
1672 super-clean, but seems workable enough. */
1674 if (*name
== ':' || (pp
= (char *) strchr(name
, ':')) == NULL
)
1678 if (*pp
== 'V' && !within_function
)
1680 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1683 SYMBOL_VALUE (sym
) += static_block_base
;
1684 SYMBOL_SECTION (sym
) = static_block_section
;
1689 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, N_LSYM
, objfile
);
1692 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1697 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1698 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1699 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1700 SYMBOL_DUP (sym
, sym2
);
1701 add_symbol_to_list (sym2
, &local_symbols
);
1705 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1706 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1707 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1708 SYMBOL_DUP (sym
, sym2
);
1709 add_symbol_to_list (sym2
, &global_symbols
);
1713 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1714 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1715 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1716 SYMBOL_DUP (sym
, sym2
);
1718 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1722 printf_unfiltered ("ERROR! C_REG is not fully implemented!\n");
1723 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1724 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1725 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1726 SYMBOL_DUP (sym
, sym2
);
1727 add_symbol_to_list (sym2
, &local_symbols
);
1731 pp
= (char*) strchr (name
, ':');
1733 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1735 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1739 complain (&rsym_complaint
, name
);
1747 /* Set *SYMBOL to symbol number symno in symtbl. */
1749 read_symbol (symbol
, symno
)
1750 struct internal_syment
*symbol
;
1753 if (symno
< 0 || symno
>= symtbl_num_syms
)
1755 static struct complaint msg
=
1756 {"Invalid symbol offset", 0, 0};
1758 symbol
->n_value
= 0;
1759 symbol
->n_scnum
= -1;
1762 bfd_coff_swap_sym_in (symfile_bfd
, symtbl
+ (symno
*local_symesz
), symbol
);
1765 /* Get value corresponding to symbol number symno in symtbl. */
1768 read_symbol_nvalue (symno
)
1771 struct internal_syment symbol
[1];
1773 read_symbol (symbol
, symno
);
1774 return symbol
->n_value
;
1778 /* Find the address of the function corresponding to symno, where
1779 symno is the symbol pointed to by the linetable. */
1782 read_symbol_lineno (symno
)
1785 struct internal_syment symbol
[1];
1786 union internal_auxent main_aux
[1];
1788 /* Note that just searching for a short distance (e.g. 50 symbols)
1789 is not enough, at least in the following case.
1792 [many .stabx entries]
1793 [a few functions, referring to foo]
1797 What happens here is that the assembler moves the .stabx entries
1798 to right before the ".bf" for foo, but the symbol for "foo" is before
1799 all the stabx entries. See PR gdb/2222. */
1800 while (symno
< symtbl_num_syms
) {
1801 bfd_coff_swap_sym_in (symfile_bfd
,
1802 symtbl
+ (symno
*local_symesz
), symbol
);
1803 if (symbol
->n_sclass
== C_FCN
&& STREQ (symbol
->n_name
, ".bf"))
1805 symno
+= symbol
->n_numaux
+1;
1808 complain (&bf_notfound_complaint
);
1812 /* take aux entry and return its lineno */
1814 bfd_coff_swap_aux_in (symfile_bfd
, symtbl
+(symno
*local_symesz
),
1815 symbol
->n_type
, symbol
->n_sclass
,
1816 0, symbol
->n_numaux
, main_aux
);
1818 return main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
1821 /* Support for line number handling */
1823 /* This function is called for every section; it finds the outer limits
1824 * of the line table (minimum and maximum file offset) so that the
1825 * mainline code can read the whole thing for efficiency.
1828 find_linenos(abfd
, asect
, vpinfo
)
1833 struct coff_symfile_info
*info
;
1835 file_ptr offset
, maxoff
;
1837 count
= asect
->lineno_count
;
1839 if (!STREQ (asect
->name
, ".text") || count
== 0)
1842 size
= count
* coff_data (symfile_bfd
)->local_linesz
;
1843 info
= (struct coff_symfile_info
*)vpinfo
;
1844 offset
= asect
->line_filepos
;
1845 maxoff
= offset
+ size
;
1847 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
1848 info
->min_lineno_offset
= offset
;
1850 if (maxoff
> info
->max_lineno_offset
)
1851 info
->max_lineno_offset
= maxoff
;
1855 /* Read in all the line numbers for fast lookups later. Leave them in
1856 external (unswapped) format in memory; we'll swap them as we enter
1857 them into GDB's data structures. */
1860 init_lineno (abfd
, offset
, size
)
1869 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
1872 linetab
= (char *) xmalloc(size
);
1874 val
= bfd_read(linetab
, 1, size
, abfd
);
1878 linetab_offset
= offset
;
1879 linetab_size
= size
;
1892 xcoff_new_init (objfile
)
1893 struct objfile
*objfile
;
1898 /* xcoff_symfile_init()
1899 is the xcoff-specific initialization routine for reading symbols.
1900 It is passed an objfile which contains, among other things,
1901 the BFD for the file whose symbols are being read, and a slot for
1902 a pointer to "private data" which we fill with cookies and other
1903 treats for xcoff_symfile_read().
1905 We will only be called if this is an XCOFF or XCOFF-like file.
1906 BFD handles figuring out the format of the file, and code in symfile.c
1907 uses BFD's determination to vector to us.
1909 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
1912 xcoff_symfile_init (objfile
)
1913 struct objfile
*objfile
;
1915 bfd
*abfd
= objfile
->obfd
;
1917 /* Allocate struct to keep track of the symfile */
1918 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
1919 sizeof (struct coff_symfile_info
));
1920 init_entry_point_info (objfile
);
1923 /* Perform any local cleanups required when we are done with a particular
1924 objfile. I.E, we are in the process of discarding all symbol information
1925 for an objfile, freeing up all memory held for it, and unlinking the
1926 objfile struct from the global list of known objfiles. */
1929 xcoff_symfile_finish (objfile
)
1930 struct objfile
*objfile
;
1932 if (objfile
-> sym_private
!= NULL
)
1934 mfree (objfile
-> md
, objfile
-> sym_private
);
1937 /* Start with a fresh include table for the next objfile. */
1944 inclIndx
= inclLength
= inclDepth
= 0;
1949 init_stringtab(abfd
, offset
, objfile
)
1952 struct objfile
*objfile
;
1956 unsigned char lengthbuf
[4];
1958 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
1961 val
= bfd_read((char *)lengthbuf
, 1, sizeof lengthbuf
, abfd
);
1962 length
= bfd_h_get_32(abfd
, lengthbuf
);
1964 /* If no string table is needed, then the file may end immediately
1965 after the symbols. Just return with `strtbl' set to null. */
1967 if (val
!= sizeof length
|| length
< sizeof length
)
1970 /* Allocate string table from symbol_obstack. We will need this table
1971 as long as we have its symbol table around. */
1973 strtbl
= (char*) obstack_alloc (&objfile
->symbol_obstack
, length
);
1977 memcpy(strtbl
, &length
, sizeof length
);
1978 if (length
== sizeof length
)
1981 val
= bfd_read(strtbl
+ sizeof length
, 1, length
- sizeof length
, abfd
);
1983 if (val
!= length
- sizeof length
|| strtbl
[length
- 1] != '\0')
1990 init_debugsection(abfd
)
1993 register sec_ptr secp
;
1994 bfd_size_type length
;
2001 secp
= bfd_get_section_by_name(abfd
, ".debug");
2005 if (!(length
= bfd_section_size(abfd
, secp
)))
2008 debugsec
= (char *) xmalloc ((unsigned)length
);
2009 if (debugsec
== NULL
)
2012 if (!bfd_get_section_contents(abfd
, secp
, debugsec
, (file_ptr
) 0, length
)) {
2013 printf_unfiltered ("Can't read .debug section from symbol file\n");
2028 /* xcoff version of symbol file read. */
2031 xcoff_symfile_read (objfile
, section_offset
, mainline
)
2032 struct objfile
*objfile
;
2033 struct section_offsets
*section_offset
;
2036 int num_symbols
; /* # of symbols */
2037 file_ptr symtab_offset
; /* symbol table and */
2038 file_ptr stringtab_offset
; /* string table file offsets */
2041 struct coff_symfile_info
*info
;
2043 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2045 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
2046 symfile_bfd
= abfd
= objfile
->obfd
;
2047 name
= objfile
->name
;
2049 num_symbols
= bfd_get_symcount (abfd
); /* # of symbols */
2050 symtab_offset
= obj_sym_filepos (abfd
); /* symbol table file offset */
2051 stringtab_offset
= symtab_offset
+
2052 num_symbols
* coff_data(abfd
)->local_symesz
;
2054 info
->min_lineno_offset
= 0;
2055 info
->max_lineno_offset
= 0;
2056 bfd_map_over_sections (abfd
, find_linenos
, info
);
2058 /* FIXME! This stuff should move into symfile_init */
2059 if (info
->min_lineno_offset
!= 0
2060 && info
->max_lineno_offset
> info
->min_lineno_offset
) {
2062 /* only read in the line # table if one exists */
2063 make_cleanup (free_linetab
, 0);
2064 val
= init_lineno(abfd
, info
->min_lineno_offset
,
2065 (int) (info
->max_lineno_offset
- info
->min_lineno_offset
));
2068 error("\"%s\": error reading line numbers\n", name
);
2071 if (num_symbols
> 0)
2073 val
= init_stringtab(abfd
, stringtab_offset
, objfile
);
2075 error ("\"%s\": can't get string table", name
);
2078 if (init_debugsection(abfd
) < 0) {
2079 error ("Error reading .debug section of `%s'\n", name
);
2083 /* Position to read the symbol table. Do not read it all at once. */
2084 val
= bfd_seek(abfd
, symtab_offset
, L_SET
);
2086 perror_with_name(name
);
2088 if (bfd_tell(abfd
) != symtab_offset
)
2091 init_minimal_symbol_collection ();
2092 make_cleanup (discard_minimal_symbols
, 0);
2094 #ifndef FAKING_RS6000
2095 /* Initialize load info structure. */
2097 xcoff_init_loadinfo ();
2100 /* Now that the executable file is positioned at symbol table,
2101 process it and define symbols accordingly. */
2103 read_xcoff_symtab(objfile
, num_symbols
);
2105 /* Free debug section. */
2106 free_debugsection ();
2108 /* Sort symbols alphabetically within each block. */
2111 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
2113 sort_symtab_syms (s
);
2117 /* Install any minimal symbols that have been collected as the current
2118 minimal symbols for this objfile. */
2120 install_minimal_symbols (objfile
);
2122 do_cleanups (back_to
);
2125 /* XCOFF-specific parsing routine for section offsets. */
2127 static int largest_section
;
2130 note_one_section (abfd
, asect
, ptr
)
2135 if (asect
->target_index
> largest_section
)
2136 largest_section
= asect
->target_index
;
2140 struct section_offsets
*
2141 xcoff_symfile_offsets (objfile
, addr
)
2142 struct objfile
*objfile
;
2145 struct section_offsets
*section_offsets
;
2148 largest_section
= 0;
2149 bfd_map_over_sections (objfile
->obfd
, note_one_section
, NULL
);
2150 objfile
->num_sections
= largest_section
+ 1;
2151 section_offsets
= (struct section_offsets
*)
2153 (&objfile
-> psymbol_obstack
,
2154 sizeof (struct section_offsets
)
2155 + sizeof (section_offsets
->offsets
) * (objfile
->num_sections
));
2157 /* syms_from_objfile kindly subtracts from addr the bfd_section_vma
2158 of the .text section. This strikes me as wrong--whether the
2159 offset to be applied to symbol reading is relative to the start
2160 address of the section depends on the symbol format. In any
2161 event, this whole "addr" concept is pretty broken (it doesn't
2162 handle any section but .text sensibly), so just ignore the addr
2163 parameter and use 0. That matches the fact that xcoff_symfile_read
2164 ignores the section_offsets). */
2165 for (i
= 0; i
< objfile
->num_sections
; i
++)
2166 ANOFFSET (section_offsets
, i
) = 0;
2168 return section_offsets
;
2171 /* Register our ability to parse symbols for xcoff BFD files. */
2173 static struct sym_fns xcoff_sym_fns
=
2176 /* Because the bfd uses coff_flavour, we need to specially kludge
2177 the flavour. FIXME: coff and xcoff and fundamentally similar
2178 except for debug format, and we should see if we can merge this
2179 file with coffread.c. For example, the extra storage classes
2180 used for stabs could presumably be recognized in any COFF file. */
2182 (enum bfd_flavour
)-1,
2184 xcoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2185 xcoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2186 xcoff_symfile_read
, /* sym_read: read a symbol file into symtab */
2187 xcoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2188 xcoff_symfile_offsets
, /* sym_offsets: xlate offsets ext->int form */
2189 NULL
/* next: pointer to next struct sym_fns */
2193 _initialize_xcoffread ()
2195 add_symtab_fns(&xcoff_sym_fns
);
2197 /* Initialize symbol template later used for arguments. */
2198 SYMBOL_NAME (&parmsym
) = "";
2199 SYMBOL_INIT_LANGUAGE_SPECIFIC (&parmsym
, language_c
);
2200 SYMBOL_NAMESPACE (&parmsym
) = VAR_NAMESPACE
;
2201 SYMBOL_CLASS (&parmsym
) = LOC_ARG
;
2202 /* Its other fields are zero, or are filled in later. */