1 /* Read AIX xcoff symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994
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>
38 #include <sys/param.h>
43 #include <sys/debug.h>
45 #include "coff/internal.h" /* FIXME, internal data from BFD */
46 #include "libcoff.h" /* FIXME, internal data from BFD */
47 #include "coff/rs6000.h" /* FIXME, raw file-format guts of xcoff */
54 #include "stabsread.h"
55 #include "complaints.h"
57 /* For interface with stabsread.c. */
58 #include "aout/stab_gnu.h"
60 /* Simplified internal version of coff symbol table information */
64 int c_symnum
; /* symbol number of this entry */
65 int c_naux
; /* 0 if syment only, 1 if syment + auxent */
67 unsigned char c_sclass
;
72 /* The COFF line table, in raw form. */
73 static char *linetab
= NULL
; /* Its actual contents */
74 static long linetab_offset
; /* Its offset in the file */
75 static unsigned long linetab_size
; /* Its size */
77 /* last function's saved coff symbol `cs' */
79 static struct coff_symbol fcn_cs_saved
;
81 static bfd
*symfile_bfd
;
83 /* Core address of start and end of text of current source file.
84 This is calculated from the first function seen after a C_FILE
88 static CORE_ADDR cur_src_end_addr
;
90 /* Core address of the end of the first object file. */
92 static CORE_ADDR first_object_file_end
;
94 /* pointer to the string table */
97 /* length of the string table */
98 static int strtbl_len
;
100 /* pointer to debug section */
101 static char *debugsec
;
103 /* pointer to the a.out symbol table */
106 /* Number of symbols in symtbl. */
107 static int symtbl_num_syms
;
109 /* initial symbol-table-debug-string vector length */
111 #define INITIAL_STABVECTOR_LENGTH 40
113 /* Nonzero if within a function (so symbols should be local,
114 if nothing says specifically). */
118 /* Local variables that hold the shift and mask values for the
119 COFF file that we are currently reading. These come back to us
120 from BFD, and are referenced by their macro names, as well as
121 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
122 macros from ../internalcoff.h . */
124 static unsigned local_n_btshft
;
125 static unsigned local_n_tmask
;
128 #define N_BTSHFT local_n_btshft
130 #define N_TMASK local_n_tmask
132 /* Local variables that hold the sizes in the file of various COFF structures.
133 (We only need to know this to read them from the file -- BFD will then
134 translate the data in them, into `internal_xxx' structs in the right
135 byte order, alignment, etc.) */
137 static unsigned local_symesz
;
139 struct coff_symfile_info
{
140 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
141 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
144 static struct complaint rsym_complaint
=
145 {"Non-stab C_RSYM `%s' needs special handling", 0, 0};
147 static struct complaint storclass_complaint
=
148 {"Unexpected storage class: %d", 0, 0};
150 static struct complaint bf_notfound_complaint
=
151 {"line numbers off, `.bf' symbol not found", 0, 0};
154 enter_line_range
PARAMS ((struct subfile
*, unsigned, unsigned,
155 CORE_ADDR
, CORE_ADDR
, unsigned *));
158 free_debugsection
PARAMS ((void));
161 init_debugsection
PARAMS ((bfd
*));
164 init_stringtab
PARAMS ((bfd
*, file_ptr
, struct objfile
*));
167 xcoff_symfile_init
PARAMS ((struct objfile
*));
170 xcoff_new_init
PARAMS ((struct objfile
*));
173 xcoff_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
176 xcoff_symfile_finish
PARAMS ((struct objfile
*));
178 static struct section_offsets
*
179 xcoff_symfile_offsets
PARAMS ((struct objfile
*, CORE_ADDR
));
182 init_lineno
PARAMS ((bfd
*, file_ptr
, int));
185 free_linetab
PARAMS ((void));
188 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
191 coff_getfilename
PARAMS ((union internal_auxent
*));
194 read_symbol
PARAMS ((struct internal_syment
*, int));
197 read_symbol_lineno
PARAMS ((int));
200 read_symbol_nvalue
PARAMS ((int));
202 static struct symbol
*
203 process_xcoff_symbol
PARAMS ((struct coff_symbol
*, struct objfile
*));
206 read_xcoff_symtab
PARAMS ((struct objfile
*, int));
209 add_stab_to_list
PARAMS ((char *, struct pending_stabs
**));
211 /* add a given stab string into given stab vector. */
214 add_stab_to_list (stabname
, stabvector
)
216 struct pending_stabs
**stabvector
;
218 if ( *stabvector
== NULL
) {
219 *stabvector
= (struct pending_stabs
*)
220 xmalloc (sizeof (struct pending_stabs
) +
221 INITIAL_STABVECTOR_LENGTH
* sizeof (char*));
222 (*stabvector
)->count
= 0;
223 (*stabvector
)->length
= INITIAL_STABVECTOR_LENGTH
;
225 else if ((*stabvector
)->count
>= (*stabvector
)->length
) {
226 (*stabvector
)->length
+= INITIAL_STABVECTOR_LENGTH
;
227 *stabvector
= (struct pending_stabs
*)
228 xrealloc ((char *) *stabvector
, sizeof (struct pending_stabs
) +
229 (*stabvector
)->length
* sizeof (char*));
231 (*stabvector
)->stab
[(*stabvector
)->count
++] = stabname
;
234 /* Linenos are processed on a file-by-file basis.
238 1) xlc (IBM's native c compiler) postpones static function code
239 emission to the end of a compilation unit. This way it can
240 determine if those functions (statics) are needed or not, and
241 can do some garbage collection (I think). This makes line
242 numbers and corresponding addresses unordered, and we end up
243 with a line table like:
260 and that breaks gdb's binary search on line numbers, if the
261 above table is not sorted on line numbers. And that sort
262 should be on function based, since gcc can emit line numbers
265 10 0x100 - for the init/test part of a for stmt.
268 10 0x400 - for the increment part of a for stmt.
270 arrange_linetable() will do this sorting.
272 2) aix symbol table might look like:
274 c_file // beginning of a new file
275 .bi // beginning of include file
276 .ei // end of include file
280 basically, .bi/.ei pairs do not necessarily encapsulate
281 their scope. They need to be recorded, and processed later
282 on when we come the end of the compilation unit.
283 Include table (inclTable) and process_linenos() handle
286 /* compare line table entry addresses. */
289 compare_lte (lte1
, lte2
)
290 struct linetable_entry
*lte1
, *lte2
;
292 return lte1
->pc
- lte2
->pc
;
295 /* Give a line table with function entries are marked, arrange its functions
296 in assending order and strip off function entry markers and return it in
297 a newly created table. If the old one is good enough, return the old one. */
298 /* FIXME: I think all this stuff can be replaced by just passing
299 sort_linevec = 1 to end_symtab. */
301 static struct linetable
*
302 arrange_linetable (oldLineTb
)
303 struct linetable
*oldLineTb
; /* old linetable */
306 newline
, /* new line count */
307 function_count
; /* # of functions */
309 struct linetable_entry
*fentry
; /* function entry vector */
310 int fentry_size
; /* # of function entries */
311 struct linetable
*newLineTb
; /* new line table */
313 #define NUM_OF_FUNCTIONS 20
315 fentry_size
= NUM_OF_FUNCTIONS
;
316 fentry
= (struct linetable_entry
*)
317 xmalloc (fentry_size
* sizeof (struct linetable_entry
));
319 for (function_count
=0, ii
=0; ii
<oldLineTb
->nitems
; ++ii
) {
321 if (oldLineTb
->item
[ii
].line
== 0) { /* function entry found. */
323 if (function_count
>= fentry_size
) { /* make sure you have room. */
325 fentry
= (struct linetable_entry
*)
326 xrealloc (fentry
, fentry_size
* sizeof (struct linetable_entry
));
328 fentry
[function_count
].line
= ii
;
329 fentry
[function_count
].pc
= oldLineTb
->item
[ii
].pc
;
334 if (function_count
== 0) {
338 else if (function_count
> 1)
339 qsort (fentry
, function_count
, sizeof(struct linetable_entry
), compare_lte
);
341 /* allocate a new line table. */
342 newLineTb
= (struct linetable
*)
344 (sizeof (struct linetable
) +
345 (oldLineTb
->nitems
- function_count
) * sizeof (struct linetable_entry
));
347 /* if line table does not start with a function beginning, copy up until
351 if (oldLineTb
->item
[0].line
!= 0)
353 newline
< oldLineTb
->nitems
&& oldLineTb
->item
[newline
].line
; ++newline
)
354 newLineTb
->item
[newline
] = oldLineTb
->item
[newline
];
356 /* Now copy function lines one by one. */
358 for (ii
=0; ii
< function_count
; ++ii
) {
359 for (jj
= fentry
[ii
].line
+ 1;
360 jj
< oldLineTb
->nitems
&& oldLineTb
->item
[jj
].line
!= 0;
362 newLineTb
->item
[newline
] = oldLineTb
->item
[jj
];
365 newLineTb
->nitems
= oldLineTb
->nitems
- function_count
;
371 /* We try to detect the beginning of a compilation unit. That info will
372 be used as an entry in line number recording routines (enter_line_range) */
374 static unsigned first_fun_line_offset
;
375 static unsigned first_fun_bf
;
377 #define mark_first_line(OFFSET, SYMNUM) \
378 if (!first_fun_line_offset) { \
379 first_fun_line_offset = OFFSET; \
380 first_fun_bf = SYMNUM; \
384 /* include file support: C_BINCL/C_EINCL pairs will be kept in the
385 following `IncludeChain'. At the end of each symtab (end_symtab),
386 we will determine if we should create additional symtab's to
387 represent if (the include files. */
390 typedef struct _inclTable
{
391 char *name
; /* include filename */
393 /* Offsets to the line table. end points to the last entry which is
394 part of this include file. */
397 struct subfile
*subfile
;
398 unsigned funStartLine
; /* start line # of its function */
401 #define INITIAL_INCLUDE_TABLE_LENGTH 20
402 static InclTable
*inclTable
; /* global include table */
403 static int inclIndx
; /* last entry to table */
404 static int inclLength
; /* table length */
405 static int inclDepth
; /* nested include depth */
407 static void allocate_include_entry
PARAMS ((void));
410 record_include_begin (cs
)
411 struct coff_symbol
*cs
;
415 /* In xcoff, we assume include files cannot be nested (not in .c files
416 of course, but in corresponding .s files.). */
418 /* This can happen with old versions of GCC.
419 GCC 2.3.3-930426 does not exhibit this on a test case which
420 a user said produced the message for him. */
421 static struct complaint msg
= {"Nested C_BINCL symbols", 0, 0};
426 allocate_include_entry ();
428 inclTable
[inclIndx
].name
= cs
->c_name
;
429 inclTable
[inclIndx
].begin
= cs
->c_value
;
433 record_include_end (cs
)
434 struct coff_symbol
*cs
;
440 static struct complaint msg
= {"Mismatched C_BINCL/C_EINCL pair", 0, 0};
444 allocate_include_entry ();
446 pTbl
= &inclTable
[inclIndx
];
447 pTbl
->end
= cs
->c_value
;
454 allocate_include_entry ()
456 if (inclTable
== NULL
)
458 inclTable
= (InclTable
*)
459 xmalloc (sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
461 '\0', sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
462 inclLength
= INITIAL_INCLUDE_TABLE_LENGTH
;
465 else if (inclIndx
>= inclLength
)
467 inclLength
+= INITIAL_INCLUDE_TABLE_LENGTH
;
468 inclTable
= (InclTable
*)
469 xrealloc (inclTable
, sizeof (InclTable
) * inclLength
);
470 memset (inclTable
+ inclLength
- INITIAL_INCLUDE_TABLE_LENGTH
,
471 '\0', sizeof (InclTable
)*INITIAL_INCLUDE_TABLE_LENGTH
);
475 /* given the start and end addresses of a compilation unit (or a csect,
476 at times) process its lines and create appropriate line vectors. */
479 process_linenos (start
, end
)
480 CORE_ADDR start
, end
;
485 struct subfile main_subfile
; /* subfile structure for the main
488 /* in the main source file, any time we see a function entry, we reset
489 this variable to function's absolute starting line number. All the
490 following line numbers in the function are relative to this, and
491 we record absolute line numbers in record_line(). */
493 int main_source_baseline
= 0;
499 if (!(offset
= first_fun_line_offset
))
500 goto return_after_cleanup
;
502 memset (&main_subfile
, '\0', sizeof (main_subfile
));
503 first_fun_line_offset
= 0;
506 /* All source lines were in the main source file. None in include files. */
508 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
509 &main_source_baseline
);
511 /* else, there was source with line numbers in include files */
514 main_source_baseline
= 0;
515 for (ii
=0; ii
< inclIndx
; ++ii
) {
517 struct subfile
*tmpSubfile
;
519 /* if there is main file source before include file, enter it. */
520 if (offset
< inclTable
[ii
].begin
) {
522 (&main_subfile
, offset
, inclTable
[ii
].begin
- LINESZ
, start
, 0,
523 &main_source_baseline
);
526 /* Have a new subfile for the include file */
528 tmpSubfile
= inclTable
[ii
].subfile
= (struct subfile
*)
529 xmalloc (sizeof (struct subfile
));
531 memset (tmpSubfile
, '\0', sizeof (struct subfile
));
532 firstLine
= &(inclTable
[ii
].funStartLine
);
534 /* enter include file's lines now. */
535 enter_line_range (tmpSubfile
, inclTable
[ii
].begin
,
536 inclTable
[ii
].end
, start
, 0, firstLine
);
538 offset
= inclTable
[ii
].end
+ LINESZ
;
541 /* all the include files' line have been processed at this point. Now,
542 enter remaining lines of the main file, if any left. */
543 if (offset
< (linetab_offset
+ linetab_size
+ 1 - LINESZ
)) {
544 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
545 &main_source_baseline
);
549 /* Process main file's line numbers. */
550 if (main_subfile
.line_vector
) {
551 struct linetable
*lineTb
, *lv
;
553 lv
= main_subfile
.line_vector
;
555 /* Line numbers are not necessarily ordered. xlc compilation will
556 put static function to the end. */
558 lineTb
= arrange_linetable (lv
);
560 current_subfile
->line_vector
= (struct linetable
*)
561 xrealloc (lv
, (sizeof (struct linetable
)
562 + lv
->nitems
* sizeof (struct linetable_entry
)));
567 current_subfile
->line_vector
= lineTb
;
570 current_subfile
->line_vector_length
=
571 current_subfile
->line_vector
->nitems
;
574 /* Now, process included files' line numbers. */
576 for (ii
=0; ii
< inclIndx
; ++ii
) {
578 if ( (inclTable
[ii
].subfile
)->line_vector
) { /* Useless if!!! FIXMEmgo */
579 struct linetable
*lineTb
, *lv
;
581 lv
= (inclTable
[ii
].subfile
)->line_vector
;
583 /* Line numbers are not necessarily ordered. xlc compilation will
584 put static function to the end. */
586 lineTb
= arrange_linetable (lv
);
590 /* For the same include file, we might want to have more than one subfile.
591 This happens if we have something like:
599 while foo.h including code in it. (stupid but possible)
600 Since start_subfile() looks at the name and uses an existing one if finds,
601 we need to provide a fake name and fool it. */
603 /* start_subfile (inclTable[ii].name, (char*)0); */
604 start_subfile (" ?", (char*)0);
605 free (current_subfile
->name
);
606 current_subfile
->name
= strdup (inclTable
[ii
].name
);
609 current_subfile
->line_vector
= (struct linetable
*)
610 xrealloc (lv
, (sizeof (struct linetable
)
611 + lv
->nitems
* sizeof (struct linetable_entry
)));
616 current_subfile
->line_vector
= lineTb
;
619 current_subfile
->line_vector_length
=
620 current_subfile
->line_vector
->nitems
;
621 start_subfile (pop_subfile (), (char*)0);
625 return_after_cleanup
:
627 /* We don't want to keep alloc/free'ing the global include file table. */
630 /* start with a fresh subfile structure for the next file. */
631 memset (&main_subfile
, '\0', sizeof (struct subfile
));
635 aix_process_linenos ()
637 /* process line numbers and enter them into line vector */
638 process_linenos (last_source_start_addr
, cur_src_end_addr
);
642 /* Enter a given range of lines into the line vector.
643 can be called in the following two ways:
644 enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or
645 enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine)
647 endoffset points to the last line table entry that we should pay
651 enter_line_range (subfile
, beginoffset
, endoffset
, startaddr
, endaddr
, firstLine
)
652 struct subfile
*subfile
;
653 unsigned beginoffset
, endoffset
; /* offsets to line table */
654 CORE_ADDR startaddr
, endaddr
;
660 /* Do Byte swapping, if needed. FIXME! */
661 #define P_LINENO(PP) (*(unsigned short*)((struct external_lineno*)(PP))->l_lnno)
662 #define P_LINEADDR(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_paddr)
663 #define P_LINESYM(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_symndx)
665 pp
= &linetab
[beginoffset
- linetab_offset
];
666 if (endoffset
!= 0 && endoffset
- linetab_offset
>= linetab_size
)
668 static struct complaint msg
=
669 {"Bad line table offset in C_EINCL directive", 0, 0};
673 limit
= endoffset
? &linetab
[endoffset
- linetab_offset
]
674 : &linetab
[linetab_size
-1];
676 while (pp
<= limit
) {
678 /* find the address this line represents */
679 addr
= P_LINENO(pp
) ?
680 P_LINEADDR(pp
) : read_symbol_nvalue (P_LINESYM(pp
));
682 if (addr
< startaddr
|| (endaddr
&& addr
>= endaddr
))
685 if (P_LINENO(pp
) == 0) {
686 *firstLine
= read_symbol_lineno (P_LINESYM(pp
));
687 record_line (subfile
, 0, addr
);
691 record_line (subfile
, *firstLine
+ P_LINENO(pp
), addr
);
698 int fsize
; /* file size */
699 int fixedparms
; /* number of fixed parms */
700 int floatparms
; /* number of float parms */
701 unsigned int parminfo
; /* parameter info.
702 See /usr/include/sys/debug.h
703 tbtable_ext.parminfo */
704 int framesize
; /* function frame size */
708 /* Given a function symbol, return its traceback information. */
711 retrieve_tracebackinfo (abfd
, textsec
, cs
)
714 struct coff_symbol
*cs
;
716 #define TBTABLE_BUFSIZ 2000
718 static TracebackInfo tbInfo
;
721 static char buffer
[TBTABLE_BUFSIZ
];
724 int bytesread
=0; /* total # of bytes read so far */
725 int bufferbytes
; /* number of bytes in the buffer */
727 int functionstart
= cs
->c_value
- textsec
->vma
;
729 memset (&tbInfo
, '\0', sizeof (tbInfo
));
731 /* keep reading blocks of data from the text section, until finding a zero
732 word and a traceback table. */
734 /* Note: The logical thing way to write this code would be to assign
735 to bufferbytes within the while condition. But that triggers a
736 compiler (xlc in AIX 3.2) bug, so simplify it... */
738 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
739 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
741 && (bfd_get_section_contents
742 (abfd
, textsec
, buffer
,
743 (file_ptr
)(functionstart
+ bytesread
), bufferbytes
)))
745 bytesread
+= bufferbytes
;
746 pinsn
= (int*) buffer
;
748 /* if this is the first time we filled the buffer, retrieve function
751 if (bytesread
== bufferbytes
) {
753 /* skip over unrelated instructions */
755 if (*pinsn
== 0x7c0802a6) /* mflr r0 */
757 if ((*pinsn
& 0xfc00003e) == 0x7c000026) /* mfcr Rx */
759 if ((*pinsn
& 0xfc000000) == 0x48000000) /* bl foo, save fprs */
761 if ((*pinsn
& 0xfc1f0000) == 0xbc010000) /* stm Rx, NUM(r1) */
765 int tmp
= (*pinsn
>> 16) & 0xffff;
767 if (tmp
== 0x9421) { /* stu r1, NUM(r1) */
768 tbInfo
.framesize
= 0x10000 - (*pinsn
& 0xffff);
771 else if ((*pinsn
== 0x93e1fffc) || /* st r31,-4(r1) */
772 (tmp
== 0x9001)) /* st r0, NUM(r1) */
774 /* else, could not find a frame size. */
778 } while (++pinsn
&& *pinsn
);
780 if (!tbInfo
.framesize
)
785 /* look for a zero word. */
787 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
790 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
795 /* function size is the amount of bytes we have skipped so far. */
796 tbInfo
.fsize
= bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
);
800 /* if we don't have the whole traceback table in the buffer, re-read
803 /* This is how much to read to get the traceback table.
804 8 bytes of the traceback table are always present, plus we
806 #define MIN_TBTABSIZ 12
808 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
810 /* In case if we are *very* close to the end of the text section
811 and cannot read properly from that point on, abort by returning
814 This could happen if the traceback table is only 8 bytes,
815 but we try to read 12 bytes of it.
816 Handle this case more graciously -- FIXME */
818 if (!bfd_get_section_contents (
819 abfd
, textsec
, buffer
,
820 (file_ptr
)(functionstart
+
821 bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
)),MIN_TBTABSIZ
))
822 { printf_unfiltered ("Abnormal return!..\n"); return NULL
; }
824 ptb
= (struct tbtable
*)buffer
;
827 ptb
= (struct tbtable
*)pinsn
;
829 tbInfo
.fixedparms
= ptb
->tb
.fixedparms
;
830 tbInfo
.floatparms
= ptb
->tb
.floatparms
;
831 tbInfo
.parminfo
= ptb
->tb_ext
.parminfo
;
835 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
836 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
842 /* Given a function symbol, return a pointer to its traceback table. */
845 retrieve_traceback (abfd
, textsec
, cs
, size
)
848 struct coff_symbol
*cs
;
849 int *size
; /* return function size */
851 #define TBTABLE_BUFSIZ 2000
852 #define MIN_TBTABSIZ 50 /* minimum buffer size to hold a
855 static char buffer
[TBTABLE_BUFSIZ
];
858 int bytesread
=0; /* total # of bytes read so far */
859 int bufferbytes
; /* number of bytes in the buffer */
861 int functionstart
= cs
->c_value
- textsec
->filepos
+ textsec
->vma
;
864 /* keep reading blocks of data from the text section, until finding a zero
865 word and a traceback table. */
867 while (bfd_get_section_contents (abfd
, textsec
, buffer
,
868 (file_ptr
)(functionstart
+ bytesread
),
870 (TBTABLE_BUFSIZ
< (textsec
->size
- functionstart
- bytesread
)) ?
871 TBTABLE_BUFSIZ
: (textsec
->size
- functionstart
- bytesread
))))
873 bytesread
+= bufferbytes
;
874 pinsn
= (int*) buffer
;
876 /* look for a zero word. */
878 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
881 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
886 /* function size is the amount of bytes we have skipped so far. */
887 *size
= bytesread
- (buffer
+ bufferbytes
- pinsn
);
891 /* if we don't have the whole traceback table in the buffer, re-read
894 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
896 /* In case if we are *very* close to the end of the text section
897 and cannot read properly from that point on, abort for now.
898 Handle this case more graciously -- FIXME */
900 if (!bfd_get_section_contents (
901 abfd
, textsec
, buffer
,
902 (file_ptr
)(functionstart
+
903 bytesread
- (buffer
+ bufferbytes
- pinsn
)),MIN_TBTABSIZ
))
904 /* abort (); */ { printf_unfiltered ("abort!!!\n"); return NULL
; }
906 return (struct tbtable
*)buffer
;
909 return (struct tbtable
*)pinsn
;
919 /* Save the vital information for use when closing off the current file.
920 NAME is the file name the symbols came from, START_ADDR is the first
921 text address for the file, and SIZE is the number of bytes of text. */
923 #define complete_symtab(name, start_addr) { \
924 last_source_file = savestring (name, strlen (name)); \
925 last_source_start_addr = start_addr; \
929 /* Refill the symbol table input buffer
930 and set the variables that control fetching entries from it.
931 Reports an error if no data available.
932 This function can read past the end of the symbol table
933 (into the string table) but this does no harm. */
935 /* Reading symbol table has to be fast! Keep the followings as macros, rather
938 #define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, ALLOCED, SECTION, OBJFILE) \
942 namestr = (NAME) + 1; \
945 obstack_copy0 (&objfile->symbol_obstack, (NAME) + 1, strlen ((NAME)+1)); \
948 prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \
949 (char *)NULL, (SECTION), (OBJFILE)); \
950 misc_func_recorded = 1; \
954 /* A parameter template, used by ADD_PARM_TO_PENDING. It is initialized
955 in our initializer function at the bottom of the file, to avoid
956 dependencies on the exact "struct symbol" format. */
958 static struct symbol parmsym
;
960 /* Add a parameter to a given pending symbol list. */
962 #define ADD_PARM_TO_PENDING(PARM, VALUE, PTYPE, PENDING_SYMBOLS) \
964 PARM = (struct symbol *) \
965 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
967 SYMBOL_TYPE (PARM) = PTYPE; \
968 SYMBOL_VALUE (PARM) = VALUE; \
969 add_symbol_to_list (PARM, &PENDING_SYMBOLS); \
973 /* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
974 nested. At any given time, a symbol can only be in one static block.
975 This is the base address of current static block, zero if non exists. */
977 static int static_block_base
= 0;
979 /* Section number for the current static block. */
981 static int static_block_section
= -1;
983 /* true if space for symbol name has been allocated. */
985 static int symname_alloced
= 0;
987 /* Next symbol to read. Pointer into raw seething symbol table. */
989 static char *raw_symbol
;
991 /* This is the function which stabsread.c calls to get symbol
994 xcoff_next_symbol_text ()
996 struct internal_syment symbol
;
997 static struct complaint msg
=
998 {"Unexpected symbol continuation", 0, 0};
1001 bfd_coff_swap_sym_in (current_objfile
->obfd
, raw_symbol
, &symbol
);
1002 if (symbol
.n_zeroes
)
1006 /* Return something which points to '\0' and hope the symbol reading
1007 code does something reasonable. */
1010 else if (symbol
.n_sclass
& 0x80)
1012 retval
= debugsec
+ symbol
.n_offset
;
1013 raw_symbol
+= coff_data (current_objfile
->obfd
)->local_symesz
;
1020 /* Return something which points to '\0' and hope the symbol reading
1021 code does something reasonable. */
1027 /* read the whole symbol table of a given bfd. */
1030 read_xcoff_symtab (objfile
, nsyms
)
1031 struct objfile
*objfile
; /* Object file we're reading from */
1032 int nsyms
; /* # of symbols */
1034 bfd
*abfd
= objfile
->obfd
;
1035 char *raw_auxptr
; /* Pointer to first raw aux entry for sym */
1036 sec_ptr textsec
; /* Pointer to text section */
1037 TracebackInfo
*ptb
; /* Pointer to traceback table */
1039 struct internal_syment symbol
[1];
1040 union internal_auxent main_aux
;
1041 struct coff_symbol cs
[1];
1042 CORE_ADDR file_start_addr
= 0;
1043 CORE_ADDR file_end_addr
= 0;
1045 int next_file_symnum
= -1;
1046 int just_started
= 1;
1048 int toc_offset
= 0; /* toc offset value in data section. */
1052 long fcn_line_offset
;
1055 struct coff_symbol fcn_stab_saved
;
1057 /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
1058 union internal_auxent fcn_aux_saved
;
1059 struct type
*fcn_type_saved
= NULL
;
1060 struct context_stack
*new;
1062 char *filestring
= " _start_ "; /* Name of the current file. */
1064 char *last_csect_name
; /* last seen csect's name and value */
1065 CORE_ADDR last_csect_val
;
1067 int misc_func_recorded
; /* true if any misc. function */
1069 current_objfile
= objfile
;
1071 /* Get the appropriate COFF "constants" related to the file we're handling. */
1072 N_TMASK
= coff_data (abfd
)->local_n_tmask
;
1073 N_BTSHFT
= coff_data (abfd
)->local_n_btshft
;
1074 local_symesz
= coff_data (abfd
)->local_symesz
;
1076 last_source_file
= NULL
;
1077 last_csect_name
= 0;
1079 misc_func_recorded
= 0;
1082 start_symtab (filestring
, (char *)NULL
, file_start_addr
);
1084 first_object_file_end
= 0;
1086 /* Allocate space for the entire symbol table at once, and read it
1087 all in. The bfd is already positioned at the beginning of
1088 the symbol table. */
1090 size
= coff_data (abfd
)->local_symesz
* nsyms
;
1091 symtbl
= xmalloc (size
);
1092 symtbl_num_syms
= nsyms
;
1094 val
= bfd_read (symtbl
, size
, 1, abfd
);
1096 perror_with_name ("reading symbol table");
1098 raw_symbol
= symtbl
;
1100 textsec
= bfd_get_section_by_name (abfd
, ".text");
1102 printf_unfiltered ("Unable to locate text section!\n");
1105 next_symbol_text_func
= xcoff_next_symbol_text
;
1107 while (symnum
< nsyms
) {
1109 QUIT
; /* make this command interruptable. */
1111 /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
1112 /* read one symbol into `cs' structure. After processing the whole symbol
1113 table, only string table will be kept in memory, symbol table and debug
1114 section of xcoff will be freed. Thus we can mark symbols with names
1115 in string table as `alloced'. */
1119 /* Swap and align the symbol into a reasonable C structure. */
1120 bfd_coff_swap_sym_in (abfd
, raw_symbol
, symbol
);
1122 cs
->c_symnum
= symnum
;
1123 cs
->c_naux
= symbol
->n_numaux
;
1124 if (symbol
->n_zeroes
) {
1125 symname_alloced
= 0;
1126 /* We must use the original, unswapped, name here so the name field
1127 pointed to by cs->c_name will persist throughout xcoffread. If
1128 we use the new field, it gets overwritten for each symbol. */
1129 cs
->c_name
= ((struct external_syment
*)raw_symbol
)->e
.e_name
;
1130 /* If it's exactly E_SYMNMLEN characters long it isn't
1132 if (cs
->c_name
[E_SYMNMLEN
- 1] != '\0')
1135 p
= obstack_alloc (&objfile
->symbol_obstack
, E_SYMNMLEN
+ 1);
1136 strncpy (p
, cs
->c_name
, E_SYMNMLEN
);
1137 p
[E_SYMNMLEN
] = '\0';
1139 symname_alloced
= 1;
1141 } else if (symbol
->n_sclass
& 0x80) {
1142 cs
->c_name
= debugsec
+ symbol
->n_offset
;
1143 symname_alloced
= 0;
1144 } else { /* in string table */
1145 cs
->c_name
= strtbl
+ (int)symbol
->n_offset
;
1146 symname_alloced
= 1;
1148 cs
->c_value
= symbol
->n_value
;
1149 cs
->c_sclass
= symbol
->n_sclass
;
1150 cs
->c_secnum
= symbol
->n_scnum
;
1151 cs
->c_type
= (unsigned)symbol
->n_type
;
1153 raw_symbol
+= coff_data (abfd
)->local_symesz
;
1156 raw_auxptr
= raw_symbol
; /* Save addr of first aux entry */
1158 /* Skip all the auxents associated with this symbol. */
1159 for (ii
= symbol
->n_numaux
; ii
; --ii
) {
1160 raw_symbol
+= coff_data (abfd
)->local_auxesz
;
1165 /* if symbol name starts with ".$" or "$", ignore it. */
1166 if (cs
->c_name
[0] == '$' || (cs
->c_name
[1] == '$' && cs
->c_name
[0] == '.'))
1169 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
) {
1170 if (last_source_file
)
1172 end_symtab (cur_src_end_addr
, 1, 0, objfile
, textsec
->target_index
);
1177 start_symtab ("_globals_", (char *)NULL
, (CORE_ADDR
)0);
1178 cur_src_end_addr
= first_object_file_end
;
1179 /* done with all files, everything from here on is globals */
1182 /* if explicitly specified as a function, treat is as one. */
1183 if (ISFCN(cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
) {
1184 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1185 0, cs
->c_naux
, &main_aux
);
1186 goto function_entry_point
;
1189 if ((cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_HIDEXT
) && cs
->c_naux
== 1)
1191 /* dealing with a symbol with a csect entry. */
1193 # define CSECT(PP) ((PP)->x_csect)
1194 # define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
1195 # define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1196 # define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1197 # define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1199 /* Convert the auxent to something we can access. */
1200 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1201 0, cs
->c_naux
, &main_aux
);
1203 switch (CSECT_SMTYP (&main_aux
)) {
1206 continue; /* ignore all external references. */
1208 case XTY_SD
: /* a section description. */
1210 switch (CSECT_SCLAS (&main_aux
)) {
1212 case XMC_PR
: /* a `.text' csect. */
1215 /* A program csect is seen. We have to allocate one
1216 symbol table for each program csect. Normally gdb
1217 prefers one symtab for each source file. In case
1218 of AIX, one source file might include more than one
1219 [PR] csect, and they don't have to be adjacent in
1220 terms of the space they occupy in memory. Thus, one
1221 single source file might get fragmented in the
1222 memory and gdb's file start and end address
1223 approach does not work! GCC (and I think xlc) seem
1224 to put all the code in the unnamed program csect. */
1226 if (last_csect_name
) {
1228 /* if no misc. function recorded in the last seen csect, enter
1229 it as a function. This will take care of functions like
1230 strcmp() compiled by xlc. */
1232 if (!misc_func_recorded
) {
1234 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1235 mst_text
, alloced
, last_csect_sec
,
1240 complete_symtab (filestring
, file_start_addr
);
1241 cur_src_end_addr
= file_end_addr
;
1242 end_symtab (file_end_addr
, 1, 0, objfile
,
1243 textsec
->target_index
);
1246 /* Give all csects for this source file the same
1248 start_symtab (filestring
, (char *)NULL
, (CORE_ADDR
)0);
1251 /* If this is the very first csect seen, basically `__start'. */
1253 first_object_file_end
= cs
->c_value
+ CSECT_LEN (&main_aux
);
1257 file_start_addr
= cs
->c_value
;
1258 file_end_addr
= cs
->c_value
+ CSECT_LEN (&main_aux
);
1260 if (cs
->c_name
&& cs
->c_name
[0] == '.') {
1261 last_csect_name
= cs
->c_name
;
1262 last_csect_val
= cs
->c_value
;
1263 last_csect_sec
= cs
->c_secnum
;
1266 misc_func_recorded
= 0;
1272 /* If the section is not a data description, ignore it. Note that
1273 uninitialized data will show up as XTY_CM/XMC_RW pair. */
1277 warning ("More than one xmc_tc0 symbol found.");
1278 toc_offset
= cs
->c_value
;
1281 case XMC_TC
: /* ignore toc entries */
1282 default : /* any other XMC_XXX */
1286 break; /* switch CSECT_SCLAS() */
1290 switch (CSECT_SCLAS (&main_aux
))
1293 /* a function entry point. */
1294 function_entry_point
:
1295 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
, mst_text
,
1296 symname_alloced
, cs
->c_secnum
, objfile
);
1298 fcn_line_offset
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1299 fcn_start_addr
= cs
->c_value
;
1301 /* save the function header info, which will be used
1302 when `.bf' is seen. */
1304 fcn_aux_saved
= main_aux
;
1309 /* If function has two auxent, then debugging information is
1310 already available for it. Process traceback table for
1311 functions with only one auxent. */
1313 if (cs
->c_naux
== 1)
1314 ptb
= retrieve_tracebackinfo (abfd
, textsec
, cs
);
1316 else if (cs
->c_naux
!= 2)
1318 static struct complaint msg
=
1319 {"Expected one or two auxents for function", 0, 0};
1323 /* If there is traceback info, create and add parameters for it. */
1325 if (ptb
&& (ptb
->fixedparms
|| ptb
->floatparms
)) {
1327 int parmcnt
= ptb
->fixedparms
+ ptb
->floatparms
;
1328 char *parmcode
= (char*) &ptb
->parminfo
;
1329 int parmvalue
= ptb
->framesize
+ 0x18; /* sizeof(LINK AREA) == 0x18 */
1330 unsigned int ii
, mask
;
1332 for (ii
=0, mask
= 0x80000000; ii
<parmcnt
; ++ii
) {
1333 struct symbol
*parm
;
1335 if (ptb
->parminfo
& mask
) { /* float or double */
1337 if (ptb
->parminfo
& mask
) { /* double parm */
1339 (parm
, parmvalue
, builtin_type_double
, local_symbols
);
1340 parmvalue
+= sizeof (double);
1342 else { /* float parm */
1344 (parm
, parmvalue
, builtin_type_float
, local_symbols
);
1345 parmvalue
+= sizeof (float);
1348 else { /* fixed parm, use (int*) for hex rep. */
1349 ADD_PARM_TO_PENDING (parm
, parmvalue
,
1350 lookup_pointer_type (builtin_type_int
),
1352 parmvalue
+= sizeof (int);
1357 /* Fake this as a function. Needed in process_xcoff_symbol() */
1360 finish_block(process_xcoff_symbol (cs
, objfile
), &local_symbols
,
1361 pending_blocks
, cs
->c_value
,
1362 cs
->c_value
+ ptb
->fsize
, objfile
);
1367 /* shared library function trampoline code entry point. */
1369 /* record trampoline code entries as mst_solib_trampoline symbol.
1370 When we lookup mst symbols, we will choose mst_text over
1371 mst_solib_trampoline. */
1372 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
,
1373 mst_solib_trampoline
,
1374 symname_alloced
, cs
->c_secnum
, objfile
);
1378 /* The symbols often have the same names as debug symbols for
1379 functions, and confuse lookup_symbol. */
1383 /* xlc puts each variable in a separate csect, so we get
1384 an XTY_SD for each variable. But gcc puts several
1385 variables in a csect, so that each variable only gets
1386 an XTY_LD. We still need to record them. This will
1387 typically be XMC_RW; I suspect XMC_RO and XMC_BS might
1392 default : /* all other XTY_XXXs */
1394 } /* switch CSECT_SMTYP() */ }
1396 switch (cs
->c_sclass
) {
1400 /* see if the last csect needs to be recorded. */
1402 if (last_csect_name
&& !misc_func_recorded
) {
1404 /* if no misc. function recorded in the last seen csect, enter
1405 it as a function. This will take care of functions like
1406 strcmp() compiled by xlc. */
1409 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1410 mst_text
, alloced
, last_csect_sec
, objfile
);
1413 /* c_value field contains symnum of next .file entry in table
1414 or symnum of first global after last .file. */
1416 next_file_symnum
= cs
->c_value
;
1418 /* complete symbol table for last object file containing
1419 debugging information. */
1421 /* Whether or not there was a csect in the previous file, we have to call
1422 `end_stabs' and `start_stabs' to reset type_vector,
1423 line_vector, etc. structures. */
1425 complete_symtab (filestring
, file_start_addr
);
1426 cur_src_end_addr
= file_end_addr
;
1427 end_symtab (file_end_addr
, 1, 0, objfile
, textsec
->target_index
);
1430 /* XCOFF, according to the AIX 3.2 documentation, puts the filename
1431 in cs->c_name. But xlc 1.3.0.2 has decided to do things the
1432 standard COFF way and put it in the auxent. We use the auxent if
1433 the symbol is ".file" and an auxent exists, otherwise use the symbol
1434 itself. Simple enough. */
1435 if (!strcmp (cs
->c_name
, ".file") && cs
->c_naux
> 0)
1437 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1438 0, cs
->c_naux
, &main_aux
);
1439 filestring
= coff_getfilename (&main_aux
);
1442 filestring
= cs
->c_name
;
1445 start_symtab (filestring
, (char *)NULL
, (CORE_ADDR
)0);
1446 last_csect_name
= 0;
1448 /* reset file start and end addresses. A compilation unit with no text
1449 (only data) should have zero file boundaries. */
1450 file_start_addr
= file_end_addr
= 0;
1455 fcn_stab_saved
= *cs
;
1460 if (STREQ (cs
->c_name
, ".bf")) {
1462 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1463 0, cs
->c_naux
, &main_aux
);
1465 within_function
= 1;
1467 mark_first_line (fcn_line_offset
, cs
->c_symnum
);
1469 new = push_context (0, fcn_start_addr
);
1471 new->name
= define_symbol
1472 (fcn_cs_saved
.c_value
, fcn_stab_saved
.c_name
, 0, 0, objfile
);
1473 if (new->name
!= NULL
)
1474 SYMBOL_SECTION (new->name
) = cs
->c_secnum
;
1476 else if (STREQ (cs
->c_name
, ".ef")) {
1478 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1479 0, cs
->c_naux
, &main_aux
);
1481 /* the value of .ef is the address of epilogue code;
1482 not useful for gdb */
1483 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1484 contains number of lines to '}' */
1486 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1487 new = pop_context ();
1488 if (context_stack_depth
!= 0)
1489 error ("invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.",
1492 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1494 fcn_cs_saved
.c_value
+
1495 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
, objfile
);
1496 within_function
= 0;
1500 case C_BSTAT
: /* begin static block */
1502 struct internal_syment symbol
;
1504 read_symbol (&symbol
, cs
->c_value
);
1505 static_block_base
= symbol
.n_value
;
1506 static_block_section
= symbol
.n_scnum
;
1510 case C_ESTAT
: /* end of static block */
1511 static_block_base
= 0;
1512 static_block_section
= -1;
1515 case C_ARG
: /* These are not implemented. */
1521 printf_unfiltered ("ERROR: Unimplemented storage class: %d.\n", cs
->c_sclass
);
1524 case C_HIDEXT
: /* ignore these.. */
1529 case C_BINCL
: /* beginning of include file */
1531 /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1532 order. Thus, when wee see them, we might not know enough info
1533 to process them. Thus, we'll be saving them into a table
1534 (inclTable) and postpone their processing. */
1536 record_include_begin (cs
);
1539 case C_EINCL
: /* end of include file */
1540 /* see the comment after case C_BINCL. */
1541 record_include_end (cs
);
1545 if (STREQ (cs
->c_name
, ".bb")) {
1547 new = push_context (depth
, cs
->c_value
);
1549 else if (STREQ (cs
->c_name
, ".eb")) {
1550 new = pop_context ();
1551 if (depth
!= new->depth
)
1552 error ("Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
1556 if (local_symbols
&& context_stack_depth
> 0) {
1557 /* Make a block for the local symbols within. */
1558 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1559 new->start_addr
, cs
->c_value
, objfile
);
1561 local_symbols
= new->locals
;
1566 process_xcoff_symbol (cs
, objfile
);
1572 if (last_source_file
)
1574 end_symtab (cur_src_end_addr
, 1, 0, objfile
, textsec
->target_index
);
1579 current_objfile
= NULL
;
1581 /* Record the toc offset value of this symbol table into ldinfo structure.
1582 If no XMC_TC0 is found, toc_offset should be zero. Another place to obtain
1583 this information would be file auxiliary header. */
1585 #ifndef FAKING_RS6000
1586 xcoff_add_toc_to_loadinfo (toc_offset
);
1590 #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1591 (SYMBOL2) = (struct symbol *) \
1592 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1593 *(SYMBOL2) = *(SYMBOL1);
1596 #define SYMNAME_ALLOC(NAME, ALLOCED) \
1597 (ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME));
1600 /* process one xcoff symbol. */
1602 static struct symbol
*
1603 process_xcoff_symbol (cs
, objfile
)
1604 register struct coff_symbol
*cs
;
1605 struct objfile
*objfile
;
1607 struct symbol onesymbol
;
1608 register struct symbol
*sym
= &onesymbol
;
1609 struct symbol
*sym2
= NULL
;
1611 char *name
, *pp
, *qq
;
1612 int struct_and_type_combined
;
1619 memset (sym
, '\0', sizeof (struct symbol
));
1621 /* default assumptions */
1622 SYMBOL_VALUE (sym
) = cs
->c_value
;
1623 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1624 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1626 if (ISFCN (cs
->c_type
)) {
1628 /* At this point, we don't know the type of the function and assume it
1629 is int. This will be patched with the type from its stab entry later
1630 on in patch_block_stabs () */
1632 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1633 SYMBOL_TYPE (sym
) = lookup_function_type (lookup_fundamental_type (objfile
, FT_INTEGER
));
1635 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1636 SYMBOL_DUP (sym
, sym2
);
1638 if (cs
->c_sclass
== C_EXT
)
1639 add_symbol_to_list (sym2
, &global_symbols
);
1640 else if (cs
->c_sclass
== C_HIDEXT
|| cs
->c_sclass
== C_STAT
)
1641 add_symbol_to_list (sym2
, &file_symbols
);
1646 /* in case we can't figure out the type, default is `int'. */
1647 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
1649 switch (cs
->c_sclass
)
1653 if (fcn_cs_saved
.c_sclass
== C_EXT
)
1654 add_stab_to_list (name
, &global_stabs
);
1656 add_stab_to_list (name
, &file_stabs
);
1661 add_stab_to_list (name
, &global_stabs
);
1665 common_block_start (cs
->c_name
, objfile
);
1669 common_block_end (objfile
);
1673 complain (&storclass_complaint
, cs
->c_sclass
);
1681 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1684 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1690 /* For xlc (not GCC), the 'V' symbol descriptor is used for all
1691 statics and we need to distinguish file-scope versus function-scope
1692 using within_function. We do this by changing the string we pass
1693 to define_symbol to use 'S' where we need to, which is not necessarily
1694 super-clean, but seems workable enough. */
1696 if (*name
== ':' || (pp
= (char *) strchr(name
, ':')) == NULL
)
1700 if (*pp
== 'V' && !within_function
)
1702 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1705 SYMBOL_VALUE (sym
) += static_block_base
;
1706 SYMBOL_SECTION (sym
) = static_block_section
;
1711 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, N_LSYM
, objfile
);
1714 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1719 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1720 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1721 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1722 SYMBOL_DUP (sym
, sym2
);
1723 add_symbol_to_list (sym2
, &local_symbols
);
1727 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1728 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1729 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1730 SYMBOL_DUP (sym
, sym2
);
1731 add_symbol_to_list (sym2
, &global_symbols
);
1735 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1736 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1737 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1738 SYMBOL_DUP (sym
, sym2
);
1740 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1744 printf_unfiltered ("ERROR! C_REG is not fully implemented!\n");
1745 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1746 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1747 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1748 SYMBOL_DUP (sym
, sym2
);
1749 add_symbol_to_list (sym2
, &local_symbols
);
1753 pp
= (char*) strchr (name
, ':');
1755 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1757 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1761 complain (&rsym_complaint
, name
);
1769 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1770 only the last component of the name. Result is in static storage and
1771 is only good for temporary use. */
1774 coff_getfilename (aux_entry
)
1775 union internal_auxent
*aux_entry
;
1777 static char buffer
[BUFSIZ
];
1778 register char *temp
;
1781 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1782 strcpy (buffer
, strtbl
+ aux_entry
->x_file
.x_n
.x_offset
);
1785 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1786 buffer
[FILNMLEN
] = '\0';
1790 /* FIXME: We should not be throwing away the information about what
1791 directory. It should go into dirname of the symtab, or some such
1793 if ((temp
= strrchr (result
, '/')) != NULL
)
1798 /* Set *SYMBOL to symbol number symno in symtbl. */
1800 read_symbol (symbol
, symno
)
1801 struct internal_syment
*symbol
;
1804 if (symno
< 0 || symno
>= symtbl_num_syms
)
1806 static struct complaint msg
=
1807 {"Invalid symbol offset", 0, 0};
1809 symbol
->n_value
= 0;
1810 symbol
->n_scnum
= -1;
1813 bfd_coff_swap_sym_in (symfile_bfd
, symtbl
+ (symno
*local_symesz
), symbol
);
1816 /* Get value corresponding to symbol number symno in symtbl. */
1819 read_symbol_nvalue (symno
)
1822 struct internal_syment symbol
[1];
1824 read_symbol (symbol
, symno
);
1825 return symbol
->n_value
;
1829 /* Find the address of the function corresponding to symno, where
1830 symno is the symbol pointed to by the linetable. */
1833 read_symbol_lineno (symno
)
1836 struct internal_syment symbol
[1];
1837 union internal_auxent main_aux
[1];
1839 /* Note that just searching for a short distance (e.g. 50 symbols)
1840 is not enough, at least in the following case.
1843 [many .stabx entries]
1844 [a few functions, referring to foo]
1848 What happens here is that the assembler moves the .stabx entries
1849 to right before the ".bf" for foo, but the symbol for "foo" is before
1850 all the stabx entries. See PR gdb/2222. */
1851 while (symno
< symtbl_num_syms
) {
1852 bfd_coff_swap_sym_in (symfile_bfd
,
1853 symtbl
+ (symno
*local_symesz
), symbol
);
1854 if (symbol
->n_sclass
== C_FCN
&& STREQ (symbol
->n_name
, ".bf"))
1856 symno
+= symbol
->n_numaux
+1;
1859 complain (&bf_notfound_complaint
);
1863 /* take aux entry and return its lineno */
1865 bfd_coff_swap_aux_in (symfile_bfd
, symtbl
+(symno
*local_symesz
),
1866 symbol
->n_type
, symbol
->n_sclass
,
1867 0, symbol
->n_numaux
, main_aux
);
1869 return main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
1872 /* Support for line number handling */
1874 /* This function is called for every section; it finds the outer limits
1875 * of the line table (minimum and maximum file offset) so that the
1876 * mainline code can read the whole thing for efficiency.
1879 find_linenos(abfd
, asect
, vpinfo
)
1884 struct coff_symfile_info
*info
;
1886 file_ptr offset
, maxoff
;
1888 count
= asect
->lineno_count
;
1890 if (!STREQ (asect
->name
, ".text") || count
== 0)
1893 size
= count
* coff_data (symfile_bfd
)->local_linesz
;
1894 info
= (struct coff_symfile_info
*)vpinfo
;
1895 offset
= asect
->line_filepos
;
1896 maxoff
= offset
+ size
;
1898 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
1899 info
->min_lineno_offset
= offset
;
1901 if (maxoff
> info
->max_lineno_offset
)
1902 info
->max_lineno_offset
= maxoff
;
1906 /* Read in all the line numbers for fast lookups later. Leave them in
1907 external (unswapped) format in memory; we'll swap them as we enter
1908 them into GDB's data structures. */
1911 init_lineno (abfd
, offset
, size
)
1920 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
1923 linetab
= (char *) xmalloc(size
);
1925 val
= bfd_read(linetab
, 1, size
, abfd
);
1929 linetab_offset
= offset
;
1930 linetab_size
= size
;
1943 xcoff_new_init (objfile
)
1944 struct objfile
*objfile
;
1949 /* xcoff_symfile_init()
1950 is the xcoff-specific initialization routine for reading symbols.
1951 It is passed an objfile which contains, among other things,
1952 the BFD for the file whose symbols are being read, and a slot for
1953 a pointer to "private data" which we fill with cookies and other
1954 treats for xcoff_symfile_read().
1956 We will only be called if this is an XCOFF or XCOFF-like file.
1957 BFD handles figuring out the format of the file, and code in symfile.c
1958 uses BFD's determination to vector to us.
1960 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
1963 xcoff_symfile_init (objfile
)
1964 struct objfile
*objfile
;
1966 bfd
*abfd
= objfile
->obfd
;
1968 /* Allocate struct to keep track of the symfile */
1969 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
1970 sizeof (struct coff_symfile_info
));
1971 init_entry_point_info (objfile
);
1974 /* Perform any local cleanups required when we are done with a particular
1975 objfile. I.E, we are in the process of discarding all symbol information
1976 for an objfile, freeing up all memory held for it, and unlinking the
1977 objfile struct from the global list of known objfiles. */
1980 xcoff_symfile_finish (objfile
)
1981 struct objfile
*objfile
;
1983 if (objfile
-> sym_private
!= NULL
)
1985 mfree (objfile
-> md
, objfile
-> sym_private
);
1988 /* Start with a fresh include table for the next objfile. */
1995 inclIndx
= inclLength
= inclDepth
= 0;
2000 init_stringtab(abfd
, offset
, objfile
)
2003 struct objfile
*objfile
;
2007 unsigned char lengthbuf
[4];
2009 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
2012 val
= bfd_read((char *)lengthbuf
, 1, sizeof lengthbuf
, abfd
);
2013 length
= bfd_h_get_32(abfd
, lengthbuf
);
2015 /* If no string table is needed, then the file may end immediately
2016 after the symbols. Just return with `strtbl' set to null. */
2018 if (val
!= sizeof length
|| length
< sizeof length
)
2021 /* Allocate string table from symbol_obstack. We will need this table
2022 as long as we have its symbol table around. */
2024 strtbl
= (char*) obstack_alloc (&objfile
->symbol_obstack
, length
);
2028 memcpy(strtbl
, &length
, sizeof length
);
2029 if (length
== sizeof length
)
2032 val
= bfd_read(strtbl
+ sizeof length
, 1, length
- sizeof length
, abfd
);
2034 if (val
!= length
- sizeof length
|| strtbl
[length
- 1] != '\0')
2041 init_debugsection(abfd
)
2044 register sec_ptr secp
;
2045 bfd_size_type length
;
2052 secp
= bfd_get_section_by_name(abfd
, ".debug");
2056 if (!(length
= bfd_section_size(abfd
, secp
)))
2059 debugsec
= (char *) xmalloc ((unsigned)length
);
2060 if (debugsec
== NULL
)
2063 if (!bfd_get_section_contents(abfd
, secp
, debugsec
, (file_ptr
) 0, length
)) {
2064 printf_unfiltered ("Can't read .debug section from symbol file\n");
2079 /* xcoff version of symbol file read. */
2082 xcoff_symfile_read (objfile
, section_offset
, mainline
)
2083 struct objfile
*objfile
;
2084 struct section_offsets
*section_offset
;
2087 int num_symbols
; /* # of symbols */
2088 file_ptr symtab_offset
; /* symbol table and */
2089 file_ptr stringtab_offset
; /* string table file offsets */
2092 struct coff_symfile_info
*info
;
2094 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2096 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
2097 symfile_bfd
= abfd
= objfile
->obfd
;
2098 name
= objfile
->name
;
2100 num_symbols
= bfd_get_symcount (abfd
); /* # of symbols */
2101 symtab_offset
= obj_sym_filepos (abfd
); /* symbol table file offset */
2102 stringtab_offset
= symtab_offset
+
2103 num_symbols
* coff_data(abfd
)->local_symesz
;
2105 info
->min_lineno_offset
= 0;
2106 info
->max_lineno_offset
= 0;
2107 bfd_map_over_sections (abfd
, find_linenos
, info
);
2109 /* FIXME! This stuff should move into symfile_init */
2110 if (info
->min_lineno_offset
!= 0
2111 && info
->max_lineno_offset
> info
->min_lineno_offset
) {
2113 /* only read in the line # table if one exists */
2114 make_cleanup (free_linetab
, 0);
2115 val
= init_lineno(abfd
, info
->min_lineno_offset
,
2116 (int) (info
->max_lineno_offset
- info
->min_lineno_offset
));
2119 error("\"%s\": error reading line numbers\n", name
);
2122 if (num_symbols
> 0)
2124 val
= init_stringtab(abfd
, stringtab_offset
, objfile
);
2126 error ("\"%s\": can't get string table", name
);
2129 if (init_debugsection(abfd
) < 0) {
2130 error ("Error reading .debug section of `%s'\n", name
);
2134 /* Position to read the symbol table. Do not read it all at once. */
2135 val
= bfd_seek(abfd
, symtab_offset
, L_SET
);
2137 perror_with_name(name
);
2139 if (bfd_tell(abfd
) != symtab_offset
)
2142 init_minimal_symbol_collection ();
2143 make_cleanup (discard_minimal_symbols
, 0);
2145 #ifndef FAKING_RS6000
2146 /* Initialize load info structure. */
2148 xcoff_init_loadinfo ();
2151 /* Now that the executable file is positioned at symbol table,
2152 process it and define symbols accordingly. */
2154 read_xcoff_symtab(objfile
, num_symbols
);
2156 /* Free debug section. */
2157 free_debugsection ();
2159 /* Sort symbols alphabetically within each block. */
2162 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
2164 sort_symtab_syms (s
);
2168 /* Install any minimal symbols that have been collected as the current
2169 minimal symbols for this objfile. */
2171 install_minimal_symbols (objfile
);
2173 do_cleanups (back_to
);
2176 /* XCOFF-specific parsing routine for section offsets. */
2178 static int largest_section
;
2181 note_one_section (abfd
, asect
, ptr
)
2186 if (asect
->target_index
> largest_section
)
2187 largest_section
= asect
->target_index
;
2191 struct section_offsets
*
2192 xcoff_symfile_offsets (objfile
, addr
)
2193 struct objfile
*objfile
;
2196 struct section_offsets
*section_offsets
;
2199 largest_section
= 0;
2200 bfd_map_over_sections (objfile
->obfd
, note_one_section
, NULL
);
2201 objfile
->num_sections
= largest_section
+ 1;
2202 section_offsets
= (struct section_offsets
*)
2204 (&objfile
-> psymbol_obstack
,
2205 sizeof (struct section_offsets
)
2206 + sizeof (section_offsets
->offsets
) * (objfile
->num_sections
));
2208 /* syms_from_objfile kindly subtracts from addr the bfd_section_vma
2209 of the .text section. This strikes me as wrong--whether the
2210 offset to be applied to symbol reading is relative to the start
2211 address of the section depends on the symbol format. In any
2212 event, this whole "addr" concept is pretty broken (it doesn't
2213 handle any section but .text sensibly), so just ignore the addr
2214 parameter and use 0. That matches the fact that xcoff_symfile_read
2215 ignores the section_offsets). */
2216 for (i
= 0; i
< objfile
->num_sections
; i
++)
2217 ANOFFSET (section_offsets
, i
) = 0;
2219 return section_offsets
;
2222 /* Register our ability to parse symbols for xcoff BFD files. */
2224 static struct sym_fns xcoff_sym_fns
=
2227 /* Because the bfd uses coff_flavour, we need to specially kludge
2228 the flavour. FIXME: coff and xcoff and fundamentally similar
2229 except for debug format, and we should see if we can merge this
2230 file with coffread.c. For example, the extra storage classes
2231 used for stabs could presumably be recognized in any COFF file. */
2233 (enum bfd_flavour
)-1,
2235 xcoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2236 xcoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2237 xcoff_symfile_read
, /* sym_read: read a symbol file into symtab */
2238 xcoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2239 xcoff_symfile_offsets
, /* sym_offsets: xlate offsets ext->int form */
2240 NULL
/* next: pointer to next struct sym_fns */
2244 _initialize_xcoffread ()
2246 add_symtab_fns(&xcoff_sym_fns
);
2248 /* Initialize symbol template later used for arguments. */
2249 SYMBOL_NAME (&parmsym
) = "";
2250 SYMBOL_INIT_LANGUAGE_SPECIFIC (&parmsym
, language_c
);
2251 SYMBOL_NAMESPACE (&parmsym
) = VAR_NAMESPACE
;
2252 SYMBOL_CLASS (&parmsym
) = LOC_ARG
;
2253 /* Its other fields are zero, or are filled in later. */