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>
49 #include "stabsread.h"
50 #include "complaints.h"
52 #include "coff/internal.h" /* FIXME, internal data from BFD */
53 #include "libcoff.h" /* FIXME, internal data from BFD */
54 #include "coff/rs6000.h" /* FIXME, raw file-format guts of xcoff */
57 /* Define this if you want gdb use the old xcoff symbol processing. This
58 way it won't use common `define_symbol()' function and Sun dbx stab
59 string grammar. And likely it won't be able to do G++ debugging. */
61 /* #define NO_DEFINE_SYMBOL 1 */
63 /* Define this if you want gdb to ignore typdef stabs. This was needed for
64 one of Transarc, to reduce the size of the symbol table. Types won't be
65 recognized, but tag names will be. */
67 /* #define NO_TYPEDEFS 1 */
69 /* Simplified internal version of coff symbol table information */
73 int c_symnum
; /* symbol number of this entry */
74 int c_nsyms
; /* 0 if syment only, 1 if syment + auxent */
81 /* The COFF line table, in raw form. */
82 static char *linetab
= NULL
; /* Its actual contents */
83 static long linetab_offset
; /* Its offset in the file */
84 static unsigned long linetab_size
; /* Its size */
86 /* last function's saved coff symbol `cs' */
88 static struct coff_symbol fcn_cs_saved
;
90 static bfd
*symfile_bfd
;
92 /* Core address of start and end of text of current source file.
93 This is calculated from the first function seen after a C_FILE
97 static CORE_ADDR cur_src_end_addr
;
99 /* Core address of the end of the first object file. */
101 static CORE_ADDR first_object_file_end
;
103 /* pointer to the string table */
106 /* length of the string table */
107 static int strtbl_len
;
109 /* pointer to debug section */
110 static char *debugsec
;
112 /* pointer to the a.out symbol table */
115 /* Number of symbols in symtbl. */
116 static int symtbl_num_syms
;
118 /* initial symbol-table-debug-string vector length */
120 #define INITIAL_STABVECTOR_LENGTH 40
122 /* Nonzero if within a function (so symbols should be local,
123 if nothing says specifically). */
127 /* Local variables that hold the shift and mask values for the
128 COFF file that we are currently reading. These come back to us
129 from BFD, and are referenced by their macro names, as well as
130 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
131 macros from ../internalcoff.h . */
133 static unsigned local_n_btshft
;
134 static unsigned local_n_tmask
;
137 #define N_BTSHFT local_n_btshft
139 #define N_TMASK local_n_tmask
141 /* Local variables that hold the sizes in the file of various COFF structures.
142 (We only need to know this to read them from the file -- BFD will then
143 translate the data in them, into `internal_xxx' structs in the right
144 byte order, alignment, etc.) */
146 static unsigned local_symesz
;
148 struct coff_symfile_info
{
149 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
150 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
153 static struct complaint rsym_complaint
=
154 {"Non-stab C_RSYM `%s' needs special handling", 0, 0};
156 static struct complaint storclass_complaint
=
157 {"Unexpected storage class: %d", 0, 0};
159 static struct complaint bf_notfound_complaint
=
160 {"line numbers off, `.bf' symbol not found", 0, 0};
163 enter_line_range
PARAMS ((struct subfile
*, unsigned, unsigned,
164 CORE_ADDR
, CORE_ADDR
, unsigned *));
167 free_debugsection
PARAMS ((void));
170 init_debugsection
PARAMS ((bfd
*));
173 init_stringtab
PARAMS ((bfd
*, file_ptr
, struct objfile
*));
176 xcoff_symfile_init
PARAMS ((struct objfile
*));
179 xcoff_new_init
PARAMS ((struct objfile
*));
182 struct section_offset
;
186 xcoff_symfile_read
PARAMS ((struct objfile
*, struct section_offset
*, int));
189 xcoff_symfile_finish
PARAMS ((struct objfile
*));
191 static struct section_offsets
*
192 xcoff_symfile_offsets
PARAMS ((struct objfile
*, CORE_ADDR
));
195 init_lineno
PARAMS ((bfd
*, file_ptr
, int));
198 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
201 read_symbol
PARAMS ((struct internal_syment
*, int));
204 read_symbol_lineno
PARAMS ((int));
207 read_symbol_nvalue
PARAMS ((int));
209 static struct symbol
*
210 process_xcoff_symbol
PARAMS ((struct coff_symbol
*, struct objfile
*));
213 read_xcoff_symtab
PARAMS ((struct objfile
*, int));
216 add_stab_to_list
PARAMS ((char *, struct pending_stabs
**));
218 /* add a given stab string into given stab vector. */
221 add_stab_to_list (stabname
, stabvector
)
223 struct pending_stabs
**stabvector
;
225 if ( *stabvector
== NULL
) {
226 *stabvector
= (struct pending_stabs
*)
227 xmalloc (sizeof (struct pending_stabs
) +
228 INITIAL_STABVECTOR_LENGTH
* sizeof (char*));
229 (*stabvector
)->count
= 0;
230 (*stabvector
)->length
= INITIAL_STABVECTOR_LENGTH
;
232 else if ((*stabvector
)->count
>= (*stabvector
)->length
) {
233 (*stabvector
)->length
+= INITIAL_STABVECTOR_LENGTH
;
234 *stabvector
= (struct pending_stabs
*)
235 xrealloc ((char *) *stabvector
, sizeof (struct pending_stabs
) +
236 (*stabvector
)->length
* sizeof (char*));
238 (*stabvector
)->stab
[(*stabvector
)->count
++] = stabname
;
243 /* for all the stabs in a given stab vector, build appropriate types
244 and fix their symbols in given symbol vector. */
247 patch_block_stabs (symbols
, stabs
)
248 struct pending
*symbols
;
249 struct pending_stabs
*stabs
;
256 /* for all the stab entries, find their corresponding symbols and
257 patch their types! */
259 for (ii
=0; ii
< stabs
->count
; ++ii
) {
260 char *name
= stabs
->stab
[ii
];
261 char *pp
= (char*) index (name
, ':');
262 struct symbol
*sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
265 /* printf ("ERROR! stab symbol not found!\n"); */ /* FIXME */
266 /* The above is a false alarm. There are cases the we can have
267 a stab, without its symbol. xlc generates this for the extern
268 definitions in inner blocks. */
273 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
274 SYMBOL_TYPE (sym
) = lookup_function_type (read_type (&pp
, objfile
));
276 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
283 /* compare line table entry addresses. */
286 compare_lte (lte1
, lte2
)
287 struct linetable_entry
*lte1
, *lte2
;
289 return lte1
->pc
- lte2
->pc
;
292 /* Give a line table with function entries are marked, arrange its functions
293 in assending order and strip off function entry markers and return it in
294 a newly created table. If the old one is good enough, return the old one. */
296 static struct linetable
*
297 arrange_linetable (oldLineTb
)
298 struct linetable
*oldLineTb
; /* old linetable */
301 newline
, /* new line count */
302 function_count
; /* # of functions */
304 struct linetable_entry
*fentry
; /* function entry vector */
305 int fentry_size
; /* # of function entries */
306 struct linetable
*newLineTb
; /* new line table */
308 #define NUM_OF_FUNCTIONS 20
310 fentry_size
= NUM_OF_FUNCTIONS
;
311 fentry
= (struct linetable_entry
*)
312 xmalloc (fentry_size
* sizeof (struct linetable_entry
));
314 for (function_count
=0, ii
=0; ii
<oldLineTb
->nitems
; ++ii
) {
316 if (oldLineTb
->item
[ii
].line
== 0) { /* function entry found. */
318 if (function_count
>= fentry_size
) { /* make sure you have room. */
320 fentry
= (struct linetable_entry
*)
321 xrealloc (fentry
, fentry_size
* sizeof (struct linetable_entry
));
323 fentry
[function_count
].line
= ii
;
324 fentry
[function_count
].pc
= oldLineTb
->item
[ii
].pc
;
329 if (function_count
== 0) {
333 else if (function_count
> 1)
334 qsort (fentry
, function_count
, sizeof(struct linetable_entry
), compare_lte
);
336 /* allocate a new line table. */
337 newLineTb
= (struct linetable
*)
339 (sizeof (struct linetable
) +
340 (oldLineTb
->nitems
- function_count
) * sizeof (struct linetable_entry
));
342 /* if line table does not start with a function beginning, copy up until
346 if (oldLineTb
->item
[0].line
!= 0)
348 newline
< oldLineTb
->nitems
&& oldLineTb
->item
[newline
].line
; ++newline
)
349 newLineTb
->item
[newline
] = oldLineTb
->item
[newline
];
351 /* Now copy function lines one by one. */
353 for (ii
=0; ii
< function_count
; ++ii
) {
354 for (jj
= fentry
[ii
].line
+ 1;
355 jj
< oldLineTb
->nitems
&& oldLineTb
->item
[jj
].line
!= 0;
357 newLineTb
->item
[newline
] = oldLineTb
->item
[jj
];
360 newLineTb
->nitems
= oldLineTb
->nitems
- function_count
;
366 /* We try to detect the beginning of a compilation unit. That info will
367 be used as an entry in line number recording routines (enter_line_range) */
369 static unsigned first_fun_line_offset
;
370 static unsigned first_fun_bf
;
372 #define mark_first_line(OFFSET, SYMNUM) \
373 if (!first_fun_line_offset) { \
374 first_fun_line_offset = OFFSET; \
375 first_fun_bf = SYMNUM; \
379 /* include file support: C_BINCL/C_EINCL pairs will be kept in the
380 following `IncludeChain'. At the end of each symtab (end_symtab),
381 we will determine if we should create additional symtab's to
382 represent if (the include files. */
385 typedef struct _inclTable
{
386 char *name
; /* include filename */
388 /* Offsets to the line table. end points to the last entry which is
389 part of this include file. */
392 struct subfile
*subfile
;
393 unsigned funStartLine
; /* start line # of its function */
396 #define INITIAL_INCLUDE_TABLE_LENGTH 20
397 static InclTable
*inclTable
; /* global include table */
398 static int inclIndx
; /* last entry to table */
399 static int inclLength
; /* table length */
400 static int inclDepth
; /* nested include depth */
404 record_include_begin (cs
)
405 struct coff_symbol
*cs
;
407 /* In xcoff, we assume include files cannot be nested (not in .c files
408 of course, but in corresponding .s files.) */
411 fatal ("xcoff internal: pending include file exists.");
415 /* allocate an include file, or make room for the new entry */
416 if (inclLength
== 0) {
417 inclTable
= (InclTable
*)
418 xmalloc (sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
419 bzero (inclTable
, sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
420 inclLength
= INITIAL_INCLUDE_TABLE_LENGTH
;
423 else if (inclIndx
>= inclLength
) {
424 inclLength
+= INITIAL_INCLUDE_TABLE_LENGTH
;
425 inclTable
= (InclTable
*)
426 xrealloc (inclTable
, sizeof (InclTable
) * inclLength
);
427 bzero (inclTable
+inclLength
-INITIAL_INCLUDE_TABLE_LENGTH
,
428 sizeof (InclTable
)*INITIAL_INCLUDE_TABLE_LENGTH
);
431 inclTable
[inclIndx
].name
= cs
->c_name
;
432 inclTable
[inclIndx
].begin
= cs
->c_value
;
437 record_include_end (cs
)
438 struct coff_symbol
*cs
;
443 fatal ("xcoff internal: Mismatch C_BINCL/C_EINCL pair found.");
445 pTbl
= &inclTable
[inclIndx
];
446 pTbl
->end
= cs
->c_value
;
453 /* given the start and end addresses of a compilation unit (or a csect, at times)
454 process its lines and create appropriate line vectors. */
457 process_linenos (start
, end
)
458 CORE_ADDR start
, end
;
463 struct subfile main_subfile
; /* subfile structure for the main
466 /* in the main source file, any time we see a function entry, we reset
467 this variable to function's absolute starting line number. All the
468 following line numbers in the function are relative to this, and
469 we record absolute line numbers in record_line(). */
471 int main_source_baseline
= 0;
477 if (!(offset
= first_fun_line_offset
))
478 goto return_after_cleanup
;
480 bzero (&main_subfile
, sizeof (main_subfile
));
481 first_fun_line_offset
= 0;
484 /* All source lines were in the main source file. None in include files. */
486 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
487 &main_source_baseline
);
489 /* else, there was source with line numbers in include files */
492 main_source_baseline
= 0;
493 for (ii
=0; ii
< inclIndx
; ++ii
) {
495 struct subfile
*tmpSubfile
;
497 /* if there is main file source before include file, enter it. */
498 if (offset
< inclTable
[ii
].begin
) {
500 (&main_subfile
, offset
, inclTable
[ii
].begin
- LINESZ
, start
, 0,
501 &main_source_baseline
);
504 /* Have a new subfile for the include file */
506 tmpSubfile
= inclTable
[ii
].subfile
= (struct subfile
*)
507 xmalloc (sizeof (struct subfile
));
509 bzero (tmpSubfile
, sizeof (struct subfile
));
510 firstLine
= &(inclTable
[ii
].funStartLine
);
512 /* enter include file's lines now. */
513 enter_line_range (tmpSubfile
, inclTable
[ii
].begin
,
514 inclTable
[ii
].end
, start
, 0, firstLine
);
516 offset
= inclTable
[ii
].end
+ LINESZ
;
519 /* all the include files' line have been processed at this point. Now,
520 enter remaining lines of the main file, if any left. */
521 if (offset
< (linetab_offset
+ linetab_size
+ 1 - LINESZ
)) {
522 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
523 &main_source_baseline
);
527 /* Process main file's line numbers. */
528 if (main_subfile
.line_vector
) {
529 struct linetable
*lineTb
, *lv
;
531 lv
= main_subfile
.line_vector
;
533 /* Line numbers are not necessarily ordered. xlc compilation will
534 put static function to the end. */
536 lineTb
= arrange_linetable (lv
);
538 current_subfile
->line_vector
= (struct linetable
*)
539 xrealloc (lv
, (sizeof (struct linetable
)
540 + lv
->nitems
* sizeof (struct linetable_entry
)));
545 current_subfile
->line_vector
= lineTb
;
548 current_subfile
->line_vector_length
=
549 current_subfile
->line_vector
->nitems
;
552 /* Now, process included files' line numbers. */
554 for (ii
=0; ii
< inclIndx
; ++ii
) {
556 if ( (inclTable
[ii
].subfile
)->line_vector
) { /* Useless if!!! FIXMEmgo */
557 struct linetable
*lineTb
, *lv
;
559 lv
= (inclTable
[ii
].subfile
)->line_vector
;
561 /* Line numbers are not necessarily ordered. xlc compilation will
562 put static function to the end. */
564 lineTb
= arrange_linetable (lv
);
568 /* For the same include file, we might want to have more than one subfile.
569 This happens if we have something like:
577 while foo.h including code in it. (stupid but possible)
578 Since start_subfile() looks at the name and uses an existing one if finds,
579 we need to provide a fake name and fool it. */
581 /* start_subfile (inclTable[ii].name, (char*)0); */
582 start_subfile (" ?", (char*)0);
583 free (current_subfile
->name
);
584 current_subfile
->name
= strdup (inclTable
[ii
].name
);
587 current_subfile
->line_vector
= (struct linetable
*)
588 xrealloc (lv
, (sizeof (struct linetable
)
589 + lv
->nitems
* sizeof (struct linetable_entry
)));
594 current_subfile
->line_vector
= lineTb
;
597 current_subfile
->line_vector_length
=
598 current_subfile
->line_vector
->nitems
;
599 start_subfile (pop_subfile (), (char*)0);
603 return_after_cleanup
:
605 /* We don't want to keep alloc/free'ing the global include file table. */
608 /* start with a fresh subfile structure for the next file. */
609 bzero (&main_subfile
, sizeof (struct subfile
));
613 aix_process_linenos ()
615 /* process line numbers and enter them into line vector */
616 process_linenos (last_source_start_addr
, cur_src_end_addr
);
620 /* Enter a given range of lines into the line vector.
621 can be called in the following two ways:
622 enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or
623 enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine)
625 endoffset points to the last line table entry that we should pay
629 enter_line_range (subfile
, beginoffset
, endoffset
, startaddr
, endaddr
, firstLine
)
630 struct subfile
*subfile
;
631 unsigned beginoffset
, endoffset
; /* offsets to line table */
632 CORE_ADDR startaddr
, endaddr
;
638 /* Do Byte swapping, if needed. FIXME! */
639 #define P_LINENO(PP) (*(unsigned short*)((struct external_lineno*)(PP))->l_lnno)
640 #define P_LINEADDR(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_paddr)
641 #define P_LINESYM(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_symndx)
643 pp
= &linetab
[beginoffset
- linetab_offset
];
644 if (endoffset
!= 0 && endoffset
- linetab_offset
>= linetab_size
)
646 static struct complaint msg
=
647 {"Bad line table offset in C_EINCL directive", 0, 0};
651 limit
= endoffset
? &linetab
[endoffset
- linetab_offset
]
652 : &linetab
[linetab_size
-1];
654 while (pp
<= limit
) {
656 /* find the address this line represents */
657 addr
= P_LINENO(pp
) ?
658 P_LINEADDR(pp
) : read_symbol_nvalue (P_LINESYM(pp
));
660 if (addr
< startaddr
|| (endaddr
&& addr
>= endaddr
))
663 if (P_LINENO(pp
) == 0) {
664 *firstLine
= read_symbol_lineno (P_LINESYM(pp
));
665 record_line (subfile
, 0, addr
);
669 record_line (subfile
, *firstLine
+ P_LINENO(pp
), addr
);
676 int fsize
; /* file size */
677 int fixedparms
; /* number of fixed parms */
678 int floatparms
; /* number of float parms */
679 unsigned int parminfo
; /* parameter info.
680 See /usr/include/sys/debug.h
681 tbtable_ext.parminfo */
682 int framesize
; /* function frame size */
686 /* Given a function symbol, return its traceback information. */
689 retrieve_tracebackinfo (abfd
, textsec
, cs
)
692 struct coff_symbol
*cs
;
694 #define TBTABLE_BUFSIZ 2000
696 static TracebackInfo tbInfo
;
699 static char buffer
[TBTABLE_BUFSIZ
];
702 int bytesread
=0; /* total # of bytes read so far */
703 int bufferbytes
; /* number of bytes in the buffer */
705 int functionstart
= cs
->c_value
- textsec
->vma
;
707 bzero (&tbInfo
, sizeof (tbInfo
));
709 /* keep reading blocks of data from the text section, until finding a zero
710 word and a traceback table. */
712 /* Note: The logical thing way to write this code would be to assign
713 to bufferbytes within the while condition. But that triggers a
714 compiler (xlc in AIX 3.2) bug, so simplify it... */
716 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
717 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
719 && (bfd_get_section_contents
720 (abfd
, textsec
, buffer
,
721 (file_ptr
)(functionstart
+ bytesread
), bufferbytes
)))
723 bytesread
+= bufferbytes
;
724 pinsn
= (int*) buffer
;
726 /* if this is the first time we filled the buffer, retrieve function
729 if (bytesread
== bufferbytes
) {
731 /* skip over unrelated instructions */
733 if (*pinsn
== 0x7c0802a6) /* mflr r0 */
735 if ((*pinsn
& 0xfc00003e) == 0x7c000026) /* mfcr Rx */
737 if ((*pinsn
& 0xfc000000) == 0x48000000) /* bl foo, save fprs */
739 if ((*pinsn
& 0xfc1f0000) == 0xbc010000) /* stm Rx, NUM(r1) */
743 int tmp
= (*pinsn
>> 16) & 0xffff;
745 if (tmp
== 0x9421) { /* stu r1, NUM(r1) */
746 tbInfo
.framesize
= 0x10000 - (*pinsn
& 0xffff);
749 else if ((*pinsn
== 0x93e1fffc) || /* st r31,-4(r1) */
750 (tmp
== 0x9001)) /* st r0, NUM(r1) */
752 /* else, could not find a frame size. */
756 } while (++pinsn
&& *pinsn
);
758 if (!tbInfo
.framesize
)
763 /* look for a zero word. */
765 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
768 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
773 /* function size is the amount of bytes we have skipped so far. */
774 tbInfo
.fsize
= bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
);
778 /* if we don't have the whole traceback table in the buffer, re-read
781 /* This is how much to read to get the traceback table.
782 8 bytes of the traceback table are always present, plus we
784 #define MIN_TBTABSIZ 12
786 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
788 /* In case if we are *very* close to the end of the text section
789 and cannot read properly from that point on, abort by returning
792 This could happen if the traceback table is only 8 bytes,
793 but we try to read 12 bytes of it.
794 Handle this case more graciously -- FIXME */
796 if (!bfd_get_section_contents (
797 abfd
, textsec
, buffer
,
798 (file_ptr
)(functionstart
+
799 bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
)),MIN_TBTABSIZ
))
800 { printf ("Abnormal return!..\n"); return NULL
; }
802 ptb
= (struct tbtable
*)buffer
;
805 ptb
= (struct tbtable
*)pinsn
;
807 tbInfo
.fixedparms
= ptb
->tb
.fixedparms
;
808 tbInfo
.floatparms
= ptb
->tb
.floatparms
;
809 tbInfo
.parminfo
= ptb
->tb_ext
.parminfo
;
813 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
814 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
820 /* Given a function symbol, return a pointer to its traceback table. */
823 retrieve_traceback (abfd
, textsec
, cs
, size
)
826 struct coff_symbol
*cs
;
827 int *size
; /* return function size */
829 #define TBTABLE_BUFSIZ 2000
830 #define MIN_TBTABSIZ 50 /* minimum buffer size to hold a
833 static char buffer
[TBTABLE_BUFSIZ
];
836 int bytesread
=0; /* total # of bytes read so far */
837 int bufferbytes
; /* number of bytes in the buffer */
839 int functionstart
= cs
->c_value
- textsec
->filepos
+ textsec
->vma
;
842 /* keep reading blocks of data from the text section, until finding a zero
843 word and a traceback table. */
845 while (bfd_get_section_contents (abfd
, textsec
, buffer
,
846 (file_ptr
)(functionstart
+ bytesread
),
848 (TBTABLE_BUFSIZ
< (textsec
->size
- functionstart
- bytesread
)) ?
849 TBTABLE_BUFSIZ
: (textsec
->size
- functionstart
- bytesread
))))
851 bytesread
+= bufferbytes
;
852 pinsn
= (int*) buffer
;
854 /* look for a zero word. */
856 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
859 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
864 /* function size is the amount of bytes we have skipped so far. */
865 *size
= bytesread
- (buffer
+ bufferbytes
- pinsn
);
869 /* if we don't have the whole traceback table in the buffer, re-read
872 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
874 /* In case if we are *very* close to the end of the text section
875 and cannot read properly from that point on, abort for now.
876 Handle this case more graciously -- FIXME */
878 if (!bfd_get_section_contents (
879 abfd
, textsec
, buffer
,
880 (file_ptr
)(functionstart
+
881 bytesread
- (buffer
+ bufferbytes
- pinsn
)),MIN_TBTABSIZ
))
882 /* abort (); */ { printf ("abort!!!\n"); return NULL
; }
884 return (struct tbtable
*)buffer
;
887 return (struct tbtable
*)pinsn
;
897 /* Save the vital information for use when closing off the current file.
898 NAME is the file name the symbols came from, START_ADDR is the first
899 text address for the file, and SIZE is the number of bytes of text. */
901 #define complete_symtab(name, start_addr) { \
902 last_source_file = savestring (name, strlen (name)); \
903 last_source_start_addr = start_addr; \
907 /* Refill the symbol table input buffer
908 and set the variables that control fetching entries from it.
909 Reports an error if no data available.
910 This function can read past the end of the symbol table
911 (into the string table) but this does no harm. */
913 /* Reading symbol table has to be fast! Keep the followings as macros, rather
916 #define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, ALLOCED, SECTION) \
920 namestr = (NAME) + 1; \
923 obstack_copy0 (&objfile->symbol_obstack, (NAME) + 1, strlen ((NAME)+1)); \
926 prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \
927 (char *)NULL, (SECTION)); \
928 misc_func_recorded = 1; \
932 /* A parameter template, used by ADD_PARM_TO_PENDING. It is initialized
933 in our initializer function at the bottom of the file, to avoid
934 dependencies on the exact "struct symbol" format. */
936 static struct symbol parmsym
;
938 /* Add a parameter to a given pending symbol list. */
940 #define ADD_PARM_TO_PENDING(PARM, VALUE, PTYPE, PENDING_SYMBOLS) \
942 PARM = (struct symbol *) \
943 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
945 SYMBOL_TYPE (PARM) = PTYPE; \
946 SYMBOL_VALUE (PARM) = VALUE; \
947 add_symbol_to_list (PARM, &PENDING_SYMBOLS); \
951 /* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
952 nested. At any given time, a symbol can only be in one static block.
953 This is the base address of current static block, zero if non exists. */
955 static int static_block_base
= 0;
957 /* Section number for the current static block. */
959 static int static_block_section
= -1;
961 /* true if space for symbol name has been allocated. */
963 static int symname_alloced
= 0;
965 /* read the whole symbol table of a given bfd. */
968 read_xcoff_symtab (objfile
, nsyms
)
969 struct objfile
*objfile
; /* Object file we're reading from */
970 int nsyms
; /* # of symbols */
972 bfd
*abfd
= objfile
->obfd
;
973 char *raw_symbol
; /* Pointer into raw seething symbol table */
974 char *raw_auxptr
; /* Pointer to first raw aux entry for sym */
975 sec_ptr textsec
; /* Pointer to text section */
976 TracebackInfo
*ptb
; /* Pointer to traceback table */
978 struct internal_syment symbol
[1];
979 union internal_auxent main_aux
[1];
980 struct coff_symbol cs
[1];
981 CORE_ADDR file_start_addr
= 0;
982 CORE_ADDR file_end_addr
= 0;
984 int next_file_symnum
= -1;
985 int just_started
= 1;
987 int toc_offset
= 0; /* toc offset value in data section. */
991 long fcn_line_offset
;
994 struct coff_symbol fcn_stab_saved
;
996 /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
997 union internal_auxent fcn_aux_saved
;
998 struct type
*fcn_type_saved
= NULL
;
999 struct context_stack
*new;
1001 char *filestring
= " _start_ "; /* Name of the current file. */
1003 char *last_csect_name
; /* last seen csect's name and value */
1004 CORE_ADDR last_csect_val
;
1006 int misc_func_recorded
; /* true if any misc. function */
1008 current_objfile
= objfile
;
1010 /* Get the appropriate COFF "constants" related to the file we're handling. */
1011 N_TMASK
= coff_data (abfd
)->local_n_tmask
;
1012 N_BTSHFT
= coff_data (abfd
)->local_n_btshft
;
1013 local_symesz
= coff_data (abfd
)->local_symesz
;
1015 last_source_file
= NULL
;
1016 last_csect_name
= 0;
1018 misc_func_recorded
= 0;
1021 start_symtab (filestring
, (char *)NULL
, file_start_addr
);
1023 first_object_file_end
= 0;
1025 /* Allocate space for the entire symbol table at once, and read it
1026 all in. The bfd is already positioned at the beginning of
1027 the symbol table. */
1029 size
= coff_data (abfd
)->local_symesz
* nsyms
;
1030 symtbl
= xmalloc (size
);
1031 symtbl_num_syms
= nsyms
;
1033 val
= bfd_read (symtbl
, size
, 1, abfd
);
1035 perror_with_name ("reading symbol table");
1037 raw_symbol
= symtbl
;
1039 textsec
= bfd_get_section_by_name (abfd
, ".text");
1041 printf ("Unable to locate text section!\n");
1044 while (symnum
< nsyms
) {
1046 QUIT
; /* make this command interruptable. */
1048 /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
1049 /* read one symbol into `cs' structure. After processing the whole symbol
1050 table, only string table will be kept in memory, symbol table and debug
1051 section of xcoff will be freed. Thus we can mark symbols with names
1052 in string table as `alloced'. */
1056 /* Swap and align the symbol into a reasonable C structure. */
1057 bfd_coff_swap_sym_in (abfd
, raw_symbol
, symbol
);
1059 cs
->c_symnum
= symnum
;
1060 cs
->c_nsyms
= symbol
->n_numaux
;
1061 if (symbol
->n_zeroes
) {
1062 symname_alloced
= 0;
1063 /* We must use the original, unswapped, name here so the name field
1064 pointed to by cs->c_name will persist throughout xcoffread. If
1065 we use the new field, it gets overwritten for each symbol. */
1066 cs
->c_name
= ((struct external_syment
*)raw_symbol
)->e
.e_name
;
1067 /* If it's exactly E_SYMNMLEN characters long it isn't
1069 if (cs
->c_name
[E_SYMNMLEN
- 1] != '\0')
1072 p
= obstack_alloc (&objfile
->symbol_obstack
, E_SYMNMLEN
+ 1);
1073 strncpy (p
, cs
->c_name
, E_SYMNMLEN
);
1074 p
[E_SYMNMLEN
] = '\0';
1076 symname_alloced
= 1;
1078 } else if (symbol
->n_sclass
& 0x80) {
1079 cs
->c_name
= debugsec
+ symbol
->n_offset
;
1080 symname_alloced
= 0;
1081 } else { /* in string table */
1082 cs
->c_name
= strtbl
+ (int)symbol
->n_offset
;
1083 symname_alloced
= 1;
1085 cs
->c_value
= symbol
->n_value
;
1086 /* n_sclass is signed (FIXME), so we had better not mask off any
1087 high bits it contains, since the values we will be comparing
1088 it to are also signed (FIXME). Defined in <coff/internal.h>.
1089 At this point (3Jun92, gnu@cygnus.com) I think the fix is to
1090 make the fields and values unsigned chars, but changing the next
1091 line is a simple patch late in the release cycle, for now. */
1092 cs
->c_sclass
= symbol
->n_sclass
/* & 0xff */;
1093 cs
->c_secnum
= symbol
->n_scnum
;
1094 cs
->c_type
= (unsigned)symbol
->n_type
;
1096 raw_symbol
+= coff_data (abfd
)->local_symesz
;
1099 raw_auxptr
= raw_symbol
; /* Save addr of first aux entry */
1101 /* Skip all the auxents associated with this symbol. */
1102 for (ii
= symbol
->n_numaux
; ii
; --ii
) {
1103 raw_symbol
+= coff_data (abfd
)->local_auxesz
;
1108 /* if symbol name starts with ".$" or "$", ignore it. */
1109 if (cs
->c_name
[0] == '$' || (cs
->c_name
[1] == '$' && cs
->c_name
[0] == '.'))
1112 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
) {
1113 if (last_source_file
)
1115 end_symtab (cur_src_end_addr
, 1, 0, objfile
, textsec
->target_index
);
1120 start_symtab ("_globals_", (char *)NULL
, (CORE_ADDR
)0);
1121 cur_src_end_addr
= first_object_file_end
;
1122 /* done with all files, everything from here on is globals */
1125 /* if explicitly specified as a function, treat is as one. */
1126 if (ISFCN(cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
) {
1127 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1129 goto function_entry_point
;
1132 if ((cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_HIDEXT
) && cs
->c_nsyms
== 1)
1134 /* dealing with a symbol with a csect entry. */
1136 # define CSECT(PP) ((PP)->x_csect)
1137 # define CSECT_LEN(PP) (CSECT(PP).x_scnlen)
1138 # define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1139 # define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1140 # define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1142 /* Convert the auxent to something we can access. */
1143 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1146 switch (CSECT_SMTYP (main_aux
)) {
1149 continue; /* ignore all external references. */
1151 case XTY_SD
: /* a section description. */
1153 switch (CSECT_SCLAS (main_aux
)) {
1155 case XMC_PR
: /* a `.text' csect. */
1158 /* A program csect is seen.
1160 We have to allocate one symbol table for each program csect. Normally
1161 gdb prefers one symtab for each compilation unit (CU). In case of AIX, one
1162 CU might include more than one prog csect, and they don't have to be
1163 adjacent in terms of the space they occupy in memory. Thus, one single
1164 CU might get fragmented in the memory and gdb's file start and end address
1165 approach does not work! */
1167 if (last_csect_name
) {
1169 /* if no misc. function recorded in the last seen csect, enter
1170 it as a function. This will take care of functions like
1171 strcmp() compiled by xlc. */
1173 if (!misc_func_recorded
) {
1175 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1176 mst_text
, alloced
, last_csect_sec
);
1180 complete_symtab (filestring
, file_start_addr
);
1181 cur_src_end_addr
= file_end_addr
;
1182 end_symtab (file_end_addr
, 1, 0, objfile
,
1183 textsec
->target_index
);
1186 start_symtab ((char *)NULL
, (char *)NULL
, (CORE_ADDR
)0);
1189 /* If this is the very first csect seen, basically `__start'. */
1191 first_object_file_end
= cs
->c_value
+ CSECT_LEN (main_aux
);
1195 file_start_addr
= cs
->c_value
;
1196 file_end_addr
= cs
->c_value
+ CSECT_LEN (main_aux
);
1198 if (cs
->c_name
&& cs
->c_name
[0] == '.') {
1199 last_csect_name
= cs
->c_name
;
1200 last_csect_val
= cs
->c_value
;
1201 last_csect_sec
= cs
->c_secnum
;
1204 misc_func_recorded
= 0;
1210 /* If the section is not a data description, ignore it. Note that
1211 uninitialized data will show up as XTY_CM/XMC_RW pair. */
1215 warning ("More than one xmc_tc0 symbol found.");
1216 toc_offset
= cs
->c_value
;
1219 case XMC_TC
: /* ignore toc entries */
1220 default : /* any other XMC_XXX */
1224 break; /* switch CSECT_SCLAS() */
1228 /* a function entry point. */
1229 if (CSECT_SCLAS (main_aux
) == XMC_PR
) {
1231 function_entry_point
:
1232 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
, mst_text
,
1233 symname_alloced
, cs
->c_secnum
);
1235 fcn_line_offset
= main_aux
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1236 fcn_start_addr
= cs
->c_value
;
1238 /* save the function header info, which will be used
1239 when `.bf' is seen. */
1241 fcn_aux_saved
= *main_aux
;
1246 /* If function has two auxent, then debugging information is
1247 already available for it. Process traceback table for
1248 functions with only one auxent. */
1250 if (cs
->c_nsyms
== 1)
1251 ptb
= retrieve_tracebackinfo (abfd
, textsec
, cs
);
1253 else if (cs
->c_nsyms
!= 2)
1256 /* If there is traceback info, create and add parameters for it. */
1258 if (ptb
&& (ptb
->fixedparms
|| ptb
->floatparms
)) {
1260 int parmcnt
= ptb
->fixedparms
+ ptb
->floatparms
;
1261 char *parmcode
= (char*) &ptb
->parminfo
;
1262 int parmvalue
= ptb
->framesize
+ 0x18; /* sizeof(LINK AREA) == 0x18 */
1263 unsigned int ii
, mask
;
1265 for (ii
=0, mask
= 0x80000000; ii
<parmcnt
; ++ii
) {
1266 struct symbol
*parm
;
1268 if (ptb
->parminfo
& mask
) { /* float or double */
1270 if (ptb
->parminfo
& mask
) { /* double parm */
1272 (parm
, parmvalue
, builtin_type_double
, local_symbols
);
1273 parmvalue
+= sizeof (double);
1275 else { /* float parm */
1277 (parm
, parmvalue
, builtin_type_float
, local_symbols
);
1278 parmvalue
+= sizeof (float);
1281 else { /* fixed parm, use (int*) for hex rep. */
1282 ADD_PARM_TO_PENDING (parm
, parmvalue
,
1283 lookup_pointer_type (builtin_type_int
),
1285 parmvalue
+= sizeof (int);
1290 /* Fake this as a function. Needed in process_xcoff_symbol() */
1293 finish_block(process_xcoff_symbol (cs
, objfile
), &local_symbols
,
1294 pending_blocks
, cs
->c_value
,
1295 cs
->c_value
+ ptb
->fsize
, objfile
);
1299 /* shared library function trampoline code entry point. */
1300 else if (CSECT_SCLAS (main_aux
) == XMC_GL
) {
1302 /* record trampoline code entries as mst_unknown symbol. When we
1303 lookup mst symbols, we will choose mst_text over mst_unknown. */
1306 /* After the implementation of incremental loading of shared
1307 libraries, we don't want to access trampoline entries. This
1308 approach has a consequence of the necessity to bring the whole
1309 shared library at first, in order do anything with it (putting
1310 breakpoints, using malloc, etc). On the other side, this is
1311 consistient with gdb's behaviour on a SUN platform. */
1313 /* Trying to prefer *real* function entry over its trampoline,
1314 by assigning `mst_unknown' type to trampoline entries fails.
1315 Gdb treats those entries as chars. FIXME. */
1317 /* Recording this entry is necessary. Single stepping relies on
1318 this vector to get an idea about function address boundaries. */
1320 prim_record_minimal_symbol_and_info
1321 ("<trampoline>", cs
->c_value
, mst_unknown
,
1322 (char *)NULL
, cs
->c_secnum
);
1325 /* record trampoline code entries as mst_unknown symbol. When we
1326 lookup mst symbols, we will choose mst_text over mst_unknown. */
1328 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
, mst_unknown
,
1335 default : /* all other XTY_XXXs */
1337 } /* switch CSECT_SMTYP() */ }
1339 switch (cs
->c_sclass
) {
1343 /* see if the last csect needs to be recorded. */
1345 if (last_csect_name
&& !misc_func_recorded
) {
1347 /* if no misc. function recorded in the last seen csect, enter
1348 it as a function. This will take care of functions like
1349 strcmp() compiled by xlc. */
1352 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1353 mst_text
, alloced
, last_csect_sec
);
1356 /* c_value field contains symnum of next .file entry in table
1357 or symnum of first global after last .file. */
1359 next_file_symnum
= cs
->c_value
;
1361 /* complete symbol table for last object file containing
1362 debugging information. */
1364 /* Whether or not there was a csect in the previous file, we have to call
1365 `end_stabs' and `start_stabs' to reset type_vector,
1366 line_vector, etc. structures. */
1368 complete_symtab (filestring
, file_start_addr
);
1369 cur_src_end_addr
= file_end_addr
;
1370 end_symtab (file_end_addr
, 1, 0, objfile
, textsec
->target_index
);
1373 start_symtab (cs
->c_name
, (char *)NULL
, (CORE_ADDR
)0);
1374 last_csect_name
= 0;
1376 /* reset file start and end addresses. A compilation unit with no text
1377 (only data) should have zero file boundaries. */
1378 file_start_addr
= file_end_addr
= 0;
1380 filestring
= cs
->c_name
;
1386 #ifdef NO_DEFINE_SYMBOL
1387 /* For a function stab, just save its type in `fcn_type_saved', and leave
1388 it for the `.bf' processing. */
1390 char *pp
= (char*) index (cs
->c_name
, ':');
1392 if (!pp
|| ( *(pp
+1) != 'F' && *(pp
+1) != 'f'))
1393 fatal ("Unrecognized stab");
1397 fatal ("Unprocessed function type");
1399 fcn_type_saved
= lookup_function_type (read_type (&pp
, objfile
));
1402 fcn_stab_saved
= *cs
;
1408 if (STREQ (cs
->c_name
, ".bf")) {
1410 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1413 within_function
= 1;
1415 /* Linenos are now processed on a file-by-file, not fn-by-fn, basis.
1416 Metin did it, I'm not sure why. FIXME. -- gnu@cygnus.com */
1420 1) xlc (IBM's native c compiler) postpones static function code
1421 emission to the end of a compilation unit. This way it can
1422 determine if those functions (statics) are needed or not, and
1423 can do some garbage collection (I think). This makes line
1424 numbers and corresponding addresses unordered, and we end up
1425 with a line table like:
1442 and that breaks gdb's binary search on line numbers, if the
1443 above table is not sorted on line numbers. And that sort
1444 should be on function based, since gcc can emit line numbers
1447 10 0x100 - for the init/test part of a for stmt.
1450 10 0x400 - for the increment part of a for stmt.
1452 arrange_linenos() will do this sorting.
1455 2) aix symbol table might look like:
1457 c_file // beginning of a new file
1458 .bi // beginning of include file
1459 .ei // end of include file
1463 basically, .bi/.ei pairs do not necessarily encapsulate
1464 their scope. They need to be recorded, and processed later
1465 on when we come the end of the compilation unit.
1466 Include table (inclTable) and process_linenos() handle
1469 mark_first_line (fcn_line_offset
, cs
->c_symnum
);
1471 new = push_context (0, fcn_start_addr
);
1473 #ifdef NO_DEFINE_SYMBOL
1474 new->name
= process_xcoff_symbol (&fcn_cs_saved
, objfile
);
1476 /* Between a function symbol and `.bf', there always will be a function
1477 stab. We save function type when processing that stab. */
1479 if (fcn_type_saved
== NULL
) {
1480 printf ("Unknown function type: symbol 0x%x\n", cs
->c_symnum
);
1481 SYMBOL_TYPE (new->name
) = lookup_function_type (builtin_type_int
);
1484 SYMBOL_TYPE (new->name
) = fcn_type_saved
;
1485 fcn_type_saved
= NULL
;
1488 new->name
= define_symbol
1489 (fcn_cs_saved
.c_value
, fcn_stab_saved
.c_name
, 0, 0, objfile
);
1490 if (new->name
!= NULL
)
1491 SYMBOL_SECTION (new->name
) = cs
->c_secnum
;
1494 else if (STREQ (cs
->c_name
, ".ef")) {
1496 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1499 /* the value of .ef is the address of epilogue code;
1500 not useful for gdb */
1501 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1502 contains number of lines to '}' */
1504 fcn_last_line
= main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
1505 new = pop_context ();
1506 if (context_stack_depth
!= 0)
1507 error ("invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.",
1510 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1512 fcn_cs_saved
.c_value
+
1513 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
, objfile
);
1514 within_function
= 0;
1518 case C_BSTAT
: /* begin static block */
1520 struct internal_syment symbol
;
1522 read_symbol (&symbol
, cs
->c_value
);
1523 static_block_base
= symbol
.n_value
;
1524 static_block_section
= symbol
.n_scnum
;
1528 case C_ESTAT
: /* end of static block */
1529 static_block_base
= 0;
1530 static_block_section
= -1;
1533 case C_ARG
: /* These are not implemented. */
1539 printf ("ERROR: Unimplemented storage class: %d.\n", cs
->c_sclass
);
1542 case C_HIDEXT
: /* ignore these.. */
1547 case C_BINCL
: /* beginning of include file */
1549 /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1550 order. Thus, when wee see them, we might not know enough info
1551 to process them. Thus, we'll be saving them into a table
1552 (inclTable) and postpone their processing. */
1554 record_include_begin (cs
);
1557 case C_EINCL
: /* end of include file */
1558 /* see the comment after case C_BINCL. */
1559 record_include_end (cs
);
1563 if (STREQ (cs
->c_name
, ".bb")) {
1565 new = push_context (depth
, cs
->c_value
);
1567 else if (STREQ (cs
->c_name
, ".eb")) {
1568 new = pop_context ();
1569 if (depth
!= new->depth
)
1570 error ("Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
1574 if (local_symbols
&& context_stack_depth
> 0) {
1575 /* Make a block for the local symbols within. */
1576 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1577 new->start_addr
, cs
->c_value
, objfile
);
1579 local_symbols
= new->locals
;
1584 process_xcoff_symbol (cs
, objfile
);
1590 if (last_source_file
)
1592 end_symtab (cur_src_end_addr
, 1, 0, objfile
, textsec
->target_index
);
1597 current_objfile
= NULL
;
1599 /* Record the toc offset value of this symbol table into ldinfo structure.
1600 If no XMC_TC0 is found, toc_offset should be zero. Another place to obtain
1601 this information would be file auxiliary header. */
1603 #ifndef FAKING_RS6000
1604 xcoff_add_toc_to_loadinfo (toc_offset
);
1608 #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1609 (SYMBOL2) = (struct symbol *) \
1610 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1611 *(SYMBOL2) = *(SYMBOL1);
1614 #define SYMNAME_ALLOC(NAME, ALLOCED) \
1615 (ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME));
1618 /* process one xcoff symbol. */
1620 static struct symbol
*
1621 process_xcoff_symbol (cs
, objfile
)
1622 register struct coff_symbol
*cs
;
1623 struct objfile
*objfile
;
1625 struct symbol onesymbol
;
1626 register struct symbol
*sym
= &onesymbol
;
1627 struct symbol
*sym2
= NULL
;
1629 char *name
, *pp
, *qq
;
1630 int struct_and_type_combined
;
1637 bzero (sym
, sizeof (struct symbol
));
1639 /* default assumptions */
1640 SYMBOL_VALUE (sym
) = cs
->c_value
;
1641 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1642 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1644 if (ISFCN (cs
->c_type
)) {
1646 /* At this point, we don't know the type of the function and assume it
1647 is int. This will be patched with the type from its stab entry later
1648 on in patch_block_stabs () */
1650 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1651 SYMBOL_TYPE (sym
) = lookup_function_type (lookup_fundamental_type (objfile
, FT_INTEGER
));
1653 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1654 SYMBOL_DUP (sym
, sym2
);
1656 if (cs
->c_sclass
== C_EXT
)
1657 add_symbol_to_list (sym2
, &global_symbols
);
1658 else if (cs
->c_sclass
== C_HIDEXT
|| cs
->c_sclass
== C_STAT
)
1659 add_symbol_to_list (sym2
, &file_symbols
);
1664 /* in case we can't figure out the type, default is `int'. */
1665 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
1667 switch (cs
->c_sclass
)
1671 if (fcn_cs_saved
.c_sclass
== C_EXT
)
1672 add_stab_to_list (name
, &global_stabs
);
1674 add_stab_to_list (name
, &file_stabs
);
1678 case C_DECL
: /* a type decleration?? */
1680 #if defined(NO_TYPEDEFS) || defined(NO_DEFINE_SYMBOL)
1681 qq
= (char*) strchr (name
, ':');
1682 if (!qq
) /* skip if there is no ':' */
1685 nameless
= (qq
== name
);
1687 struct_and_type_combined
= (qq
[1] == 'T' && qq
[2] == 't');
1688 pp
= qq
+ (struct_and_type_combined
? 3 : 2);
1691 /* To handle GNU C++ typename abbreviation, we need to be able to fill
1692 in a type's name as soon as space for that type is allocated. */
1694 if (struct_and_type_combined
&& name
!= qq
) {
1697 struct type
*tmp_type
;
1700 read_type_number (&tmp_pp
, typenums
);
1701 tmp_type
= dbx_alloc_type (typenums
, objfile
);
1703 if (tmp_type
&& !TYPE_NAME (tmp_type
) && !nameless
)
1704 TYPE_NAME (tmp_type
) = SYMBOL_NAME (sym
) =
1705 obsavestring (name
, qq
-name
,
1706 &objfile
->symbol_obstack
);
1708 ttype
= SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1710 /* if there is no name for this typedef, you don't have to keep its
1711 symbol, since nobody could ask for it. Otherwise, build a symbol
1712 and add it into symbol_list. */
1718 /* Transarc wants to eliminate type definitions from the symbol table.
1719 Limited debugging capabilities, but faster symbol table processing
1720 and less memory usage. Note that tag definitions (starting with
1721 'T') will remain intact. */
1723 if (qq
[1] != 'T' && (!TYPE_NAME (ttype
) || *(TYPE_NAME (ttype
)) == '\0')) {
1725 if (SYMBOL_NAME (sym
))
1726 TYPE_NAME (ttype
) = SYMBOL_NAME (sym
);
1728 TYPE_NAME (ttype
) = obsavestring (name
, qq
-name
);
1733 #endif /* !NO_TYPEDEFS */
1735 /* read_type() will return null if type (or tag) definition was
1736 unnnecessarily duplicated. Also, if the symbol doesn't have a name,
1737 there is no need to keep it in symbol table. */
1738 /* The above argument no longer valid. read_type() never returns NULL. */
1743 /* if there is no name for this typedef, you don't have to keep its
1744 symbol, since nobody could ask for it. Otherwise, build a symbol
1745 and add it into symbol_list. */
1748 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1749 else if (qq
[1] == 't')
1750 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1752 warning ("Unrecognized stab string.\n");
1756 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1757 if (!SYMBOL_NAME (sym
))
1758 SYMBOL_NAME (sym
) = obsavestring (name
, qq
-name
);
1760 SYMBOL_DUP (sym
, sym2
);
1762 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1764 /* For a combination of struct and type, add one more symbol
1767 if (struct_and_type_combined
) {
1768 SYMBOL_DUP (sym
, sym2
);
1769 SYMBOL_NAMESPACE (sym2
) = VAR_NAMESPACE
;
1771 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1774 /* assign a name to the type node. */
1776 if (!TYPE_NAME (ttype
) || *(TYPE_NAME (ttype
)) == '\0') {
1777 if (struct_and_type_combined
)
1778 TYPE_NAME (ttype
) = SYMBOL_NAME (sym
);
1779 else if (qq
[1] == 'T') /* struct namespace */
1780 TYPE_NAME (ttype
) = concat (
1781 TYPE_CODE (ttype
) == TYPE_CODE_UNION
? "union " :
1782 TYPE_CODE (ttype
) == TYPE_CODE_STRUCT
? "struct " : "enum ",
1783 SYMBOL_NAME (sym
), NULL
);
1787 #else /* !NO_DEFINE_SYMBOL */
1788 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1790 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1795 add_stab_to_list (name
, &global_stabs
);
1801 #ifdef NO_DEFINE_SYMBOL
1802 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1804 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1805 SYMBOL_CLASS (sym
) = (cs
->c_sclass
== C_PSYM
) ? LOC_ARG
: LOC_REGPARM
;
1807 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1808 SYMBOL_DUP (sym
, sym2
);
1809 add_symbol_to_list (sym2
, &local_symbols
);
1812 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1815 SYMBOL_CLASS (sym
) =
1816 (cs
->c_sclass
== C_PSYM
) ? LOC_ARG
: LOC_REGPARM
;
1817 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1824 #ifdef NO_DEFINE_SYMBOL
1825 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1827 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1828 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1829 SYMBOL_VALUE (sym
) += static_block_base
;
1831 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1832 SYMBOL_DUP (sym
, sym2
);
1834 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1837 /* If we are going to use Sun dbx's define_symbol(), we need to
1838 massage our stab string a little. Change 'V' type to 'S' to be
1839 comparible with Sun. */
1841 if (*name
== ':' || (pp
= (char *) index (name
, ':')) == NULL
)
1845 if (*pp
== 'V') *pp
= 'S';
1846 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1849 SYMBOL_VALUE (sym
) += static_block_base
;
1850 SYMBOL_SECTION (sym
) = static_block_section
;
1856 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1858 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1859 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1861 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1862 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1863 SYMBOL_DUP (sym
, sym2
);
1864 add_symbol_to_list (sym2
, &local_symbols
);
1868 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1869 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1870 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1871 SYMBOL_DUP (sym
, sym2
);
1872 add_symbol_to_list (sym2
, &local_symbols
);
1876 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1877 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1878 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1879 SYMBOL_DUP (sym
, sym2
);
1880 add_symbol_to_list (sym2
, &global_symbols
);
1884 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1885 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1886 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1887 SYMBOL_DUP (sym
, sym2
);
1889 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1893 printf ("ERROR! C_REG is not fully implemented!\n");
1894 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1895 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1896 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1897 SYMBOL_DUP (sym
, sym2
);
1898 add_symbol_to_list (sym2
, &local_symbols
);
1902 pp
= (char*) strchr (name
, ':');
1903 #ifdef NO_DEFINE_SYMBOL
1904 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1905 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (cs
->c_value
);
1907 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1910 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1913 /* else this is not a stab entry, suppose the type is either
1914 `int' or `float', depending on the register class. */
1916 SYMBOL_TYPE (sym
) = (SYMBOL_VALUE (sym
) < 32)
1917 ? lookup_fundamental_type (objfile
, FT_INTEGER
)
1918 : lookup_fundamental_type (objfile
, FT_FLOAT
);
1920 SYMBOL_DUP (sym
, sym2
);
1921 add_symbol_to_list (sym2
, &local_symbols
);
1925 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1927 SYMBOL_SECTION (sym
) = cs
->c_secnum
;
1931 complain (&rsym_complaint
, name
);
1937 complain (&storclass_complaint
, cs
->c_sclass
);
1944 /* Set *SYMBOL to symbol number symno in symtbl. */
1946 read_symbol (symbol
, symno
)
1947 struct internal_syment
*symbol
;
1950 if (symno
< 0 || symno
>= symtbl_num_syms
)
1952 struct complaint msg
=
1953 {"Invalid symbol offset", 0, 0};
1955 symbol
->n_value
= 0;
1956 symbol
->n_scnum
= -1;
1959 bfd_coff_swap_sym_in (symfile_bfd
, symtbl
+ (symno
*local_symesz
), symbol
);
1962 /* Get value corresponding to symbol number symno in symtbl. */
1965 read_symbol_nvalue (symno
)
1968 struct internal_syment symbol
[1];
1970 read_symbol (symbol
, symno
);
1971 return symbol
->n_value
;
1975 /* Find the address of the function corresponding to symno, where
1976 symno is the symbol pointed to by the linetable. */
1979 read_symbol_lineno (symno
)
1982 struct internal_syment symbol
[1];
1983 union internal_auxent main_aux
[1];
1985 /* Note that just searching for a short distance (e.g. 50 symbols)
1986 is not enough, at least in the following case.
1989 [many .stabx entries]
1990 [a few functions, referring to foo]
1994 What happens here is that the assembler moves the .stabx entries
1995 to right before the ".bf" for foo, but the symbol for "foo" is before
1996 all the stabx entries. See PR gdb/2222. */
1997 while (symno
< symtbl_num_syms
) {
1998 bfd_coff_swap_sym_in (symfile_bfd
,
1999 symtbl
+ (symno
*local_symesz
), symbol
);
2000 if (symbol
->n_sclass
== C_FCN
&& STREQ (symbol
->n_name
, ".bf"))
2002 symno
+= symbol
->n_numaux
+1;
2005 complain (&bf_notfound_complaint
);
2009 /* take aux entry and return its lineno */
2011 bfd_coff_swap_aux_in (symfile_bfd
, symtbl
+(symno
*local_symesz
),
2012 symbol
->n_type
, symbol
->n_sclass
, main_aux
);
2014 return main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2017 /* Support for line number handling */
2019 /* This function is called for every section; it finds the outer limits
2020 * of the line table (minimum and maximum file offset) so that the
2021 * mainline code can read the whole thing for efficiency.
2024 find_linenos(abfd
, asect
, vpinfo
)
2029 struct coff_symfile_info
*info
;
2031 file_ptr offset
, maxoff
;
2033 count
= asect
->lineno_count
;
2035 if (!STREQ (asect
->name
, ".text") || count
== 0)
2038 size
= count
* coff_data (symfile_bfd
)->local_linesz
;
2039 info
= (struct coff_symfile_info
*)vpinfo
;
2040 offset
= asect
->line_filepos
;
2041 maxoff
= offset
+ size
;
2043 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
2044 info
->min_lineno_offset
= offset
;
2046 if (maxoff
> info
->max_lineno_offset
)
2047 info
->max_lineno_offset
= maxoff
;
2051 /* Read in all the line numbers for fast lookups later. Leave them in
2052 external (unswapped) format in memory; we'll swap them as we enter
2053 them into GDB's data structures. */
2056 init_lineno (abfd
, offset
, size
)
2063 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
2066 linetab
= (char *) xmalloc(size
);
2068 val
= bfd_read(linetab
, 1, size
, abfd
);
2072 linetab_offset
= offset
;
2073 linetab_size
= size
;
2074 make_cleanup (free
, linetab
); /* Be sure it gets de-allocated. */
2078 /* dbx allows the text of a symbol name to be continued into the
2079 next symbol name! When such a continuation is encountered
2080 (a \ at the end of the text of a name)
2081 call this function to get the continuation. */
2082 /* So far, I haven't seen this happenning xlc output. I doubt we'll need this
2085 #undef next_symbol_text
2086 #define next_symbol_text() \
2087 printf ("Gdb Error: symbol names on multiple lines not implemented.\n")
2091 xcoff_new_init (objfile
)
2092 struct objfile
*objfile
;
2097 /* xcoff_symfile_init()
2098 is the xcoff-specific initialization routine for reading symbols.
2099 It is passed an objfile which contains, among other things,
2100 the BFD for the file whose symbols are being read, and a slot for
2101 a pointer to "private data" which we fill with cookies and other
2102 treats for xcoff_symfile_read().
2104 We will only be called if this is an XCOFF or XCOFF-like file.
2105 BFD handles figuring out the format of the file, and code in symfile.c
2106 uses BFD's determination to vector to us.
2108 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
2111 xcoff_symfile_init (objfile
)
2112 struct objfile
*objfile
;
2114 bfd
*abfd
= objfile
->obfd
;
2116 /* Allocate struct to keep track of the symfile */
2117 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
2118 sizeof (struct coff_symfile_info
));
2119 init_entry_point_info (objfile
);
2122 /* Perform any local cleanups required when we are done with a particular
2123 objfile. I.E, we are in the process of discarding all symbol information
2124 for an objfile, freeing up all memory held for it, and unlinking the
2125 objfile struct from the global list of known objfiles. */
2128 xcoff_symfile_finish (objfile
)
2129 struct objfile
*objfile
;
2131 if (objfile
-> sym_private
!= NULL
)
2133 mfree (objfile
-> md
, objfile
-> sym_private
);
2136 /* Start with a fresh include table for the next objfile. */
2143 inclIndx
= inclLength
= inclDepth
= 0;
2148 init_stringtab(abfd
, offset
, objfile
)
2151 struct objfile
*objfile
;
2155 unsigned char lengthbuf
[4];
2157 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
2160 val
= bfd_read((char *)lengthbuf
, 1, sizeof lengthbuf
, abfd
);
2161 length
= bfd_h_get_32(abfd
, lengthbuf
);
2163 /* If no string table is needed, then the file may end immediately
2164 after the symbols. Just return with `strtbl' set to null. */
2166 if (val
!= sizeof length
|| length
< sizeof length
)
2169 /* Allocate string table from symbol_obstack. We will need this table
2170 as long as we have its symbol table around. */
2172 strtbl
= (char*) obstack_alloc (&objfile
->symbol_obstack
, length
);
2176 bcopy(&length
, strtbl
, sizeof length
);
2177 if (length
== sizeof length
)
2180 val
= bfd_read(strtbl
+ sizeof length
, 1, length
- sizeof length
, abfd
);
2182 if (val
!= length
- sizeof length
|| strtbl
[length
- 1] != '\0')
2189 init_debugsection(abfd
)
2192 register sec_ptr secp
;
2193 bfd_size_type length
;
2200 secp
= bfd_get_section_by_name(abfd
, ".debug");
2204 if (!(length
= bfd_section_size(abfd
, secp
)))
2207 debugsec
= (char *) xmalloc ((unsigned)length
);
2208 if (debugsec
== NULL
)
2211 if (!bfd_get_section_contents(abfd
, secp
, debugsec
, (file_ptr
) 0, length
)) {
2212 printf ("Can't read .debug section from symbol file\n");
2227 /* xcoff version of symbol file read. */
2230 xcoff_symfile_read (objfile
, section_offset
, mainline
)
2231 struct objfile
*objfile
;
2232 struct section_offset
*section_offset
;
2235 int num_symbols
; /* # of symbols */
2236 file_ptr symtab_offset
; /* symbol table and */
2237 file_ptr stringtab_offset
; /* string table file offsets */
2240 struct coff_symfile_info
*info
;
2243 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
2244 symfile_bfd
= abfd
= objfile
->obfd
;
2245 name
= objfile
->name
;
2247 num_symbols
= bfd_get_symcount (abfd
); /* # of symbols */
2248 symtab_offset
= obj_sym_filepos (abfd
); /* symbol table file offset */
2249 stringtab_offset
= symtab_offset
+
2250 num_symbols
* coff_data(abfd
)->local_symesz
;
2252 info
->min_lineno_offset
= 0;
2253 info
->max_lineno_offset
= 0;
2254 bfd_map_over_sections (abfd
, find_linenos
, info
);
2256 /* FIXME! This stuff should move into symfile_init */
2257 if (info
->min_lineno_offset
!= 0
2258 && info
->max_lineno_offset
> info
->min_lineno_offset
) {
2260 /* only read in the line # table if one exists */
2261 val
= init_lineno(abfd
, info
->min_lineno_offset
,
2262 (int) (info
->max_lineno_offset
- info
->min_lineno_offset
));
2265 error("\"%s\": error reading line numbers\n", name
);
2268 if (num_symbols
> 0)
2270 val
= init_stringtab(abfd
, stringtab_offset
, objfile
);
2272 error ("\"%s\": can't get string table", name
);
2275 if (init_debugsection(abfd
) < 0) {
2276 error ("Error reading .debug section of `%s'\n", name
);
2280 /* Position to read the symbol table. Do not read it all at once. */
2281 val
= bfd_seek(abfd
, symtab_offset
, L_SET
);
2283 perror_with_name(name
);
2285 if (bfd_tell(abfd
) != symtab_offset
)
2288 init_minimal_symbol_collection ();
2289 make_cleanup (discard_minimal_symbols
, 0);
2291 #ifndef FAKING_RS6000
2292 /* Initialize load info structure. */
2294 xcoff_init_loadinfo ();
2297 /* Now that the executable file is positioned at symbol table,
2298 process it and define symbols accordingly. */
2300 read_xcoff_symtab(objfile
, num_symbols
);
2302 /* Free debug section. */
2303 free_debugsection ();
2305 /* Sort symbols alphabetically within each block. */
2306 sort_all_symtab_syms ();
2308 /* Install any minimal symbols that have been collected as the current
2309 minimal symbols for this objfile. */
2311 install_minimal_symbols (objfile
);
2313 /* Make a default for file to list. */
2314 select_source_symtab (0);
2317 /* XCOFF-specific parsing routine for section offsets. */
2319 static int largest_section
;
2322 note_one_section (abfd
, asect
, ptr
)
2327 if (asect
->target_index
> largest_section
)
2328 largest_section
= asect
->target_index
;
2332 struct section_offsets
*
2333 xcoff_symfile_offsets (objfile
, addr
)
2334 struct objfile
*objfile
;
2337 struct section_offsets
*section_offsets
;
2340 largest_section
= 0;
2341 bfd_map_over_sections (objfile
->obfd
, note_one_section
, NULL
);
2342 objfile
->num_sections
= largest_section
+ 1;
2343 section_offsets
= (struct section_offsets
*)
2345 (&objfile
-> psymbol_obstack
,
2346 sizeof (struct section_offsets
)
2347 + sizeof (section_offsets
->offsets
) * (objfile
->num_sections
));
2349 /* syms_from_objfile kindly subtracts from addr the bfd_section_vma
2350 of the .text section. This strikes me as wrong--whether the
2351 offset to be applied to symbol reading is relative to the start
2352 address of the section depends on the symbol format. In any
2353 event, this whole "addr" concept is pretty broken (it doesn't
2354 handle any section but .text sensibly), so just ignore the addr
2355 parameter and use 0. That matches the fact that xcoff_symfile_read
2356 ignores the section_offsets). */
2357 for (i
= 0; i
< objfile
->num_sections
; i
++)
2358 ANOFFSET (section_offsets
, i
) = 0;
2360 return section_offsets
;
2362 /* Register our ability to parse symbols for xcoff BFD files. */
2364 static struct sym_fns xcoff_sym_fns
=
2366 "aixcoff-rs6000", /* sym_name: name or name prefix of BFD target type */
2367 15, /* sym_namelen: number of significant sym_name chars */
2368 xcoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2369 xcoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2370 xcoff_symfile_read
, /* sym_read: read a symbol file into symtab */
2371 xcoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2372 xcoff_symfile_offsets
, /* sym_offsets: xlate offsets ext->int form */
2373 NULL
/* next: pointer to next struct sym_fns */
2377 _initialize_xcoffread ()
2379 add_symtab_fns(&xcoff_sym_fns
);
2381 /* Initialize symbol template later used for arguments. */
2382 SYMBOL_NAME (&parmsym
) = "";
2383 SYMBOL_INIT_LANGUAGE_SPECIFIC (&parmsym
, language_c
);
2384 SYMBOL_NAMESPACE (&parmsym
) = VAR_NAMESPACE
;
2385 SYMBOL_CLASS (&parmsym
) = LOC_ARG
;
2386 /* Its other fields are zero, or are filled in later. */