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 /* AIX XCOFF names have a preceeding dot `.' */
33 #define NAMES_HAVE_DOT 1
35 #include <sys/types.h>
40 #include <sys/param.h>
45 #include <sys/debug.h>
52 #include "stabsread.h"
53 #include "gdb-stabs.h"
54 #include "complaints.h"
56 #include "coff/internal.h" /* FIXME, internal data from BFD */
57 #include "libcoff.h" /* FIXME, internal data from BFD */
58 #include "coff/rs6000.h" /* FIXME, raw file-format guts of xcoff */
61 /* Define this if you want gdb use the old xcoff symbol processing. This
62 way it won't use common `define_symbol()' function and Sun dbx stab
63 string grammar. And likely it won't be able to do G++ debugging. */
65 /* #define NO_DEFINE_SYMBOL 1 */
67 /* Define this if you want gdb to ignore typdef stabs. This was needed for
68 one of Transarc, to reduce the size of the symbol table. Types won't be
69 recognized, but tag names will be. */
71 /* #define NO_TYPEDEFS 1 */
73 /* Simplified internal version of coff symbol table information */
77 int c_symnum
; /* symbol number of this entry */
78 int c_nsyms
; /* 0 if syment only, 1 if syment + auxent */
85 /* The COFF line table, in raw form. */
86 static char *linetab
= NULL
; /* Its actual contents */
87 static long linetab_offset
; /* Its offset in the file */
88 static unsigned long linetab_size
; /* Its size */
90 /* last function's saved coff symbol `cs' */
92 static struct coff_symbol fcn_cs_saved
;
94 static bfd
*symfile_bfd
;
96 /* Core address of start and end of text of current source file.
97 This is calculated from the first function seen after a C_FILE
101 static CORE_ADDR cur_src_end_addr
;
103 /* Core address of the end of the first object file. */
105 static CORE_ADDR first_object_file_end
;
107 /* pointer to the string table */
110 /* length of the string table */
111 static int strtbl_len
;
113 /* pointer to debug section */
114 static char *debugsec
;
116 /* pointer to the a.out symbol table */
119 /* Number of symbols in symtbl. */
120 static int symtbl_num_syms
;
122 /* initial symbol-table-debug-string vector length */
124 #define INITIAL_STABVECTOR_LENGTH 40
126 /* Nonzero if within a function (so symbols should be local,
127 if nothing says specifically). */
131 /* Local variables that hold the shift and mask values for the
132 COFF file that we are currently reading. These come back to us
133 from BFD, and are referenced by their macro names, as well as
134 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
135 macros from ../internalcoff.h . */
137 static unsigned local_n_btshft
;
138 static unsigned local_n_tmask
;
141 #define N_BTSHFT local_n_btshft
143 #define N_TMASK local_n_tmask
145 /* Local variables that hold the sizes in the file of various COFF structures.
146 (We only need to know this to read them from the file -- BFD will then
147 translate the data in them, into `internal_xxx' structs in the right
148 byte order, alignment, etc.) */
150 static unsigned local_symesz
;
152 struct coff_symfile_info
{
153 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
154 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
157 static struct complaint rsym_complaint
=
158 {"Non-stab C_RSYM `%s' needs special handling", 0, 0};
160 static struct complaint storclass_complaint
=
161 {"Unexpected storage class: %d", 0, 0};
163 static struct complaint bf_notfound_complaint
=
164 {"line numbers off, `.bf' symbol not found", 0, 0};
167 enter_line_range
PARAMS ((struct subfile
*, unsigned, unsigned,
168 CORE_ADDR
, CORE_ADDR
, unsigned *));
171 free_debugsection
PARAMS ((void));
174 init_debugsection
PARAMS ((bfd
*));
177 init_stringtab
PARAMS ((bfd
*, file_ptr
, struct objfile
*));
180 xcoff_symfile_init
PARAMS ((struct objfile
*));
183 xcoff_new_init
PARAMS ((struct objfile
*));
186 struct section_offset
;
190 xcoff_symfile_read
PARAMS ((struct objfile
*, struct section_offset
*, int));
193 xcoff_symfile_finish
PARAMS ((struct objfile
*));
195 static struct section_offsets
*
196 xcoff_symfile_offsets
PARAMS ((struct objfile
*, CORE_ADDR
));
199 init_lineno
PARAMS ((bfd
*, file_ptr
, int));
202 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
205 read_symbol_lineno
PARAMS ((int));
208 read_symbol_nvalue
PARAMS ((int));
210 static struct symbol
*
211 process_xcoff_symbol
PARAMS ((struct coff_symbol
*, struct objfile
*));
214 read_xcoff_symtab
PARAMS ((struct objfile
*, int));
217 add_stab_to_list
PARAMS ((char *, struct pending_stabs
**));
220 sort_syms
PARAMS ((void));
223 compare_symbols
PARAMS ((const void *, const void *));
225 /* Call sort_syms to sort alphabetically
226 the symbols of each block of each symtab. */
229 compare_symbols (s1p
, s2p
)
233 /* Names that are less should come first. */
234 register struct symbol
**s1
= (struct symbol
**) s1p
;
235 register struct symbol
**s2
= (struct symbol
**) s2p
;
236 register int namediff
= STRCMP (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
));
240 /* For symbols of the same name, registers should come first. */
241 return ((SYMBOL_CLASS (*s2
) == LOC_REGISTER
)
242 - (SYMBOL_CLASS (*s1
) == LOC_REGISTER
));
246 /* Sort a vector of symbols by their value. */
251 register struct symtab
*s
;
252 register struct objfile
*objfile
;
254 register struct blockvector
*bv
;
255 register struct block
*b
;
257 for (objfile
= object_files
; objfile
!= NULL
; objfile
= objfile
-> next
)
259 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
261 bv
= BLOCKVECTOR (s
);
262 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
263 for (i
= 0; i
< nbl
; i
++)
265 b
= BLOCKVECTOR_BLOCK (bv
, i
);
266 if (BLOCK_SHOULD_SORT (b
))
268 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
269 sizeof (struct symbol
*), compare_symbols
);
277 /* add a given stab string into given stab vector. */
280 add_stab_to_list (stabname
, stabvector
)
282 struct pending_stabs
**stabvector
;
284 if ( *stabvector
== NULL
) {
285 *stabvector
= (struct pending_stabs
*)
286 xmalloc (sizeof (struct pending_stabs
) +
287 INITIAL_STABVECTOR_LENGTH
* sizeof (char*));
288 (*stabvector
)->count
= 0;
289 (*stabvector
)->length
= INITIAL_STABVECTOR_LENGTH
;
291 else if ((*stabvector
)->count
>= (*stabvector
)->length
) {
292 (*stabvector
)->length
+= INITIAL_STABVECTOR_LENGTH
;
293 *stabvector
= (struct pending_stabs
*)
294 xrealloc ((char *) *stabvector
, sizeof (struct pending_stabs
) +
295 (*stabvector
)->length
* sizeof (char*));
297 (*stabvector
)->stab
[(*stabvector
)->count
++] = stabname
;
302 /* for all the stabs in a given stab vector, build appropriate types
303 and fix their symbols in given symbol vector. */
306 patch_block_stabs (symbols
, stabs
)
307 struct pending
*symbols
;
308 struct pending_stabs
*stabs
;
315 /* for all the stab entries, find their corresponding symbols and
316 patch their types! */
318 for (ii
=0; ii
< stabs
->count
; ++ii
) {
319 char *name
= stabs
->stab
[ii
];
320 char *pp
= (char*) index (name
, ':');
321 struct symbol
*sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
324 /* printf ("ERROR! stab symbol not found!\n"); */ /* FIXME */
325 /* The above is a false alarm. There are cases the we can have
326 a stab, without its symbol. xlc generates this for the extern
327 definitions in inner blocks. */
332 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
333 SYMBOL_TYPE (sym
) = lookup_function_type (read_type (&pp
, objfile
));
335 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
342 /* compare line table entry addresses. */
345 compare_lte (lte1
, lte2
)
346 struct linetable_entry
*lte1
, *lte2
;
348 return lte1
->pc
- lte2
->pc
;
351 /* Give a line table with function entries are marked, arrange its functions
352 in assending order and strip off function entry markers and return it in
353 a newly created table. If the old one is good enough, return the old one. */
355 static struct linetable
*
356 arrange_linetable (oldLineTb
)
357 struct linetable
*oldLineTb
; /* old linetable */
360 newline
, /* new line count */
361 function_count
; /* # of functions */
363 struct linetable_entry
*fentry
; /* function entry vector */
364 int fentry_size
; /* # of function entries */
365 struct linetable
*newLineTb
; /* new line table */
367 #define NUM_OF_FUNCTIONS 20
369 fentry_size
= NUM_OF_FUNCTIONS
;
370 fentry
= (struct linetable_entry
*)
371 malloc (fentry_size
* sizeof (struct linetable_entry
));
373 for (function_count
=0, ii
=0; ii
<oldLineTb
->nitems
; ++ii
) {
375 if (oldLineTb
->item
[ii
].line
== 0) { /* function entry found. */
377 if (function_count
>= fentry_size
) { /* make sure you have room. */
379 fentry
= (struct linetable_entry
*)
380 realloc (fentry
, fentry_size
* sizeof (struct linetable_entry
));
382 fentry
[function_count
].line
= ii
;
383 fentry
[function_count
].pc
= oldLineTb
->item
[ii
].pc
;
388 if (function_count
== 0) {
392 else if (function_count
> 1)
393 qsort (fentry
, function_count
, sizeof(struct linetable_entry
), compare_lte
);
395 /* allocate a new line table. */
396 newLineTb
= (struct linetable
*) malloc (sizeof (struct linetable
) +
397 (oldLineTb
->nitems
- function_count
) * sizeof (struct linetable_entry
));
399 /* if line table does not start with a function beginning, copy up until
403 if (oldLineTb
->item
[0].line
!= 0)
405 newline
< oldLineTb
->nitems
&& oldLineTb
->item
[newline
].line
; ++newline
)
406 newLineTb
->item
[newline
] = oldLineTb
->item
[newline
];
408 /* Now copy function lines one by one. */
410 for (ii
=0; ii
< function_count
; ++ii
) {
411 for (jj
= fentry
[ii
].line
+ 1;
412 jj
< oldLineTb
->nitems
&& oldLineTb
->item
[jj
].line
!= 0;
414 newLineTb
->item
[newline
] = oldLineTb
->item
[jj
];
417 newLineTb
->nitems
= oldLineTb
->nitems
- function_count
;
423 /* We try to detect the beginning of a compilation unit. That info will
424 be used as an entry in line number recording routines (enter_line_range) */
426 static unsigned first_fun_line_offset
;
427 static unsigned first_fun_bf
;
429 #define mark_first_line(OFFSET, SYMNUM) \
430 if (!first_fun_line_offset) { \
431 first_fun_line_offset = OFFSET; \
432 first_fun_bf = SYMNUM; \
436 /* include file support: C_BINCL/C_EINCL pairs will be kept in the
437 following `IncludeChain'. At the end of each symtab (end_symtab),
438 we will determine if we should create additional symtab's to
439 represent if (the include files. */
442 typedef struct _inclTable
{
443 char *name
; /* include filename */
445 /* Offsets to the line table. end points to the last entry which is
446 part of this include file. */
449 struct subfile
*subfile
;
450 unsigned funStartLine
; /* start line # of its function */
453 #define INITIAL_INCLUDE_TABLE_LENGTH 20
454 static InclTable
*inclTable
; /* global include table */
455 static int inclIndx
; /* last entry to table */
456 static int inclLength
; /* table length */
457 static int inclDepth
; /* nested include depth */
461 record_include_begin (cs
)
462 struct coff_symbol
*cs
;
464 /* In xcoff, we assume include files cannot be nested (not in .c files
465 of course, but in corresponding .s files.) */
468 fatal ("xcoff internal: pending include file exists.");
472 /* allocate an include file, or make room for the new entry */
473 if (inclLength
== 0) {
474 inclTable
= (InclTable
*)
475 xmalloc (sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
476 bzero (inclTable
, sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
477 inclLength
= INITIAL_INCLUDE_TABLE_LENGTH
;
480 else if (inclIndx
>= inclLength
) {
481 inclLength
+= INITIAL_INCLUDE_TABLE_LENGTH
;
482 inclTable
= (InclTable
*)
483 xrealloc (inclTable
, sizeof (InclTable
) * inclLength
);
484 bzero (inclTable
+inclLength
-INITIAL_INCLUDE_TABLE_LENGTH
,
485 sizeof (InclTable
)*INITIAL_INCLUDE_TABLE_LENGTH
);
488 inclTable
[inclIndx
].name
= cs
->c_name
;
489 inclTable
[inclIndx
].begin
= cs
->c_value
;
494 record_include_end (cs
)
495 struct coff_symbol
*cs
;
500 fatal ("xcoff internal: Mismatch C_BINCL/C_EINCL pair found.");
502 pTbl
= &inclTable
[inclIndx
];
503 pTbl
->end
= cs
->c_value
;
510 /* given the start and end addresses of a compilation unit (or a csect, at times)
511 process its lines and create appropriate line vectors. */
514 process_linenos (start
, end
)
515 CORE_ADDR start
, end
;
520 struct subfile main_subfile
; /* subfile structure for the main
523 /* in the main source file, any time we see a function entry, we reset
524 this variable to function's absolute starting line number. All the
525 following line numbers in the function are relative to this, and
526 we record absolute line numbers in record_line(). */
528 int main_source_baseline
= 0;
534 if (!(offset
= first_fun_line_offset
))
535 goto return_after_cleanup
;
537 bzero (&main_subfile
, sizeof (main_subfile
));
538 first_fun_line_offset
= 0;
541 /* All source lines were in the main source file. None in include files. */
543 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
544 &main_source_baseline
);
546 /* else, there was source with line numbers in include files */
549 main_source_baseline
= 0;
550 for (ii
=0; ii
< inclIndx
; ++ii
) {
552 struct subfile
*tmpSubfile
;
554 /* if there is main file source before include file, enter it. */
555 if (offset
< inclTable
[ii
].begin
) {
557 (&main_subfile
, offset
, inclTable
[ii
].begin
- LINESZ
, start
, 0,
558 &main_source_baseline
);
561 /* Have a new subfile for the include file */
563 tmpSubfile
= inclTable
[ii
].subfile
= (struct subfile
*)
564 xmalloc (sizeof (struct subfile
));
566 bzero (tmpSubfile
, sizeof (struct subfile
));
567 firstLine
= &(inclTable
[ii
].funStartLine
);
569 /* enter include file's lines now. */
570 enter_line_range (tmpSubfile
, inclTable
[ii
].begin
,
571 inclTable
[ii
].end
, start
, 0, firstLine
);
573 offset
= inclTable
[ii
].end
+ LINESZ
;
576 /* all the include files' line have been processed at this point. Now,
577 enter remaining lines of the main file, if any left. */
578 if (offset
< (linetab_offset
+ linetab_size
+ 1 - LINESZ
)) {
579 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
580 &main_source_baseline
);
584 /* Process main file's line numbers. */
585 if (main_subfile
.line_vector
) {
586 struct linetable
*lineTb
, *lv
;
588 lv
= main_subfile
.line_vector
;
590 /* Line numbers are not necessarily ordered. xlc compilation will
591 put static function to the end. */
593 lineTb
= arrange_linetable (lv
);
595 current_subfile
->line_vector
= (struct linetable
*)
596 xrealloc (lv
, (sizeof (struct linetable
)
597 + lv
->nitems
* sizeof (struct linetable_entry
)));
602 current_subfile
->line_vector
= lineTb
;
605 current_subfile
->line_vector_length
=
606 current_subfile
->line_vector
->nitems
;
609 /* Now, process included files' line numbers. */
611 for (ii
=0; ii
< inclIndx
; ++ii
) {
613 if ( (inclTable
[ii
].subfile
)->line_vector
) { /* Useless if!!! FIXMEmgo */
614 struct linetable
*lineTb
, *lv
;
616 lv
= (inclTable
[ii
].subfile
)->line_vector
;
618 /* Line numbers are not necessarily ordered. xlc compilation will
619 put static function to the end. */
621 lineTb
= arrange_linetable (lv
);
625 /* For the same include file, we might want to have more than one subfile.
626 This happens if we have something like:
634 while foo.h including code in it. (stupid but possible)
635 Since start_subfile() looks at the name and uses an existing one if finds,
636 we need to provide a fake name and fool it. */
638 /* start_subfile (inclTable[ii].name, (char*)0); */
639 start_subfile (" ?", (char*)0);
640 free (current_subfile
->name
);
641 current_subfile
->name
= strdup (inclTable
[ii
].name
);
644 current_subfile
->line_vector
= (struct linetable
*)
645 xrealloc (lv
, (sizeof (struct linetable
)
646 + lv
->nitems
* sizeof (struct linetable_entry
)));
651 current_subfile
->line_vector
= lineTb
;
654 current_subfile
->line_vector_length
=
655 current_subfile
->line_vector
->nitems
;
656 start_subfile (pop_subfile (), (char*)0);
660 return_after_cleanup
:
662 /* We don't want to keep alloc/free'ing the global include file table. */
665 /* start with a fresh subfile structure for the next file. */
666 bzero (&main_subfile
, sizeof (struct subfile
));
670 aix_process_linenos ()
672 /* process line numbers and enter them into line vector */
673 process_linenos (last_source_start_addr
, cur_src_end_addr
);
677 /* Enter a given range of lines into the line vector.
678 can be called in the following two ways:
679 enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or
680 enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine)
682 endoffset points to the last line table entry that we should pay
686 enter_line_range (subfile
, beginoffset
, endoffset
, startaddr
, endaddr
, firstLine
)
687 struct subfile
*subfile
;
688 unsigned beginoffset
, endoffset
; /* offsets to line table */
689 CORE_ADDR startaddr
, endaddr
;
695 /* Do Byte swapping, if needed. FIXME! */
696 #define P_LINENO(PP) (*(unsigned short*)((struct external_lineno*)(PP))->l_lnno)
697 #define P_LINEADDR(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_paddr)
698 #define P_LINESYM(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_symndx)
700 pp
= &linetab
[beginoffset
- linetab_offset
];
701 if (endoffset
!= 0 && endoffset
- linetab_offset
>= linetab_size
)
703 static struct complaint msg
=
704 {"Bad line table offset in C_EINCL directive", 0, 0};
708 limit
= endoffset
? &linetab
[endoffset
- linetab_offset
]
709 : &linetab
[linetab_size
-1];
711 while (pp
<= limit
) {
713 /* find the address this line represents */
714 addr
= P_LINENO(pp
) ?
715 P_LINEADDR(pp
) : read_symbol_nvalue (P_LINESYM(pp
));
717 if (addr
< startaddr
|| (endaddr
&& addr
> endaddr
))
720 if (P_LINENO(pp
) == 0) {
721 *firstLine
= read_symbol_lineno (P_LINESYM(pp
));
722 record_line (subfile
, 0, addr
);
726 record_line (subfile
, *firstLine
+ P_LINENO(pp
), addr
);
733 int fsize
; /* file size */
734 int fixedparms
; /* number of fixed parms */
735 int floatparms
; /* number of float parms */
736 unsigned int parminfo
; /* parameter info.
737 See /usr/include/sys/debug.h
738 tbtable_ext.parminfo */
739 int framesize
; /* function frame size */
743 /* Given a function symbol, return its traceback information. */
746 retrieve_tracebackinfo (abfd
, textsec
, cs
)
749 struct coff_symbol
*cs
;
751 #define TBTABLE_BUFSIZ 2000
753 static TracebackInfo tbInfo
;
756 static char buffer
[TBTABLE_BUFSIZ
];
759 int bytesread
=0; /* total # of bytes read so far */
760 int bufferbytes
; /* number of bytes in the buffer */
762 int functionstart
= cs
->c_value
- textsec
->vma
;
764 bzero (&tbInfo
, sizeof (tbInfo
));
766 /* keep reading blocks of data from the text section, until finding a zero
767 word and a traceback table. */
769 /* Note: The logical thing way to write this code would be to assign
770 to bufferbytes within the while condition. But that triggers a
771 compiler (xlc in AIX 3.2) bug, so simplify it... */
773 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
774 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
776 && (bfd_get_section_contents
777 (abfd
, textsec
, buffer
,
778 (file_ptr
)(functionstart
+ bytesread
), bufferbytes
)))
780 bytesread
+= bufferbytes
;
781 pinsn
= (int*) buffer
;
783 /* if this is the first time we filled the buffer, retrieve function
786 if (bytesread
== bufferbytes
) {
788 /* skip over unrelated instructions */
790 if (*pinsn
== 0x7c0802a6) /* mflr r0 */
792 if ((*pinsn
& 0xfc00003e) == 0x7c000026) /* mfcr Rx */
794 if ((*pinsn
& 0xfc000000) == 0x48000000) /* bl foo, save fprs */
796 if ((*pinsn
& 0xfc1f0000) == 0xbc010000) /* stm Rx, NUM(r1) */
800 int tmp
= (*pinsn
>> 16) & 0xffff;
802 if (tmp
== 0x9421) { /* stu r1, NUM(r1) */
803 tbInfo
.framesize
= 0x10000 - (*pinsn
& 0xffff);
806 else if ((*pinsn
== 0x93e1fffc) || /* st r31,-4(r1) */
807 (tmp
== 0x9001)) /* st r0, NUM(r1) */
809 /* else, could not find a frame size. */
813 } while (++pinsn
&& *pinsn
);
815 if (!tbInfo
.framesize
)
820 /* look for a zero word. */
822 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
825 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
830 /* function size is the amount of bytes we have skipped so far. */
831 tbInfo
.fsize
= bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
);
835 /* if we don't have the whole traceback table in the buffer, re-read
838 /* This is how much to read to get the traceback table.
839 8 bytes of the traceback table are always present, plus we
841 #define MIN_TBTABSIZ 12
843 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
845 /* In case if we are *very* close to the end of the text section
846 and cannot read properly from that point on, abort by returning
849 This could happen if the traceback table is only 8 bytes,
850 but we try to read 12 bytes of it.
851 Handle this case more graciously -- FIXME */
853 if (!bfd_get_section_contents (
854 abfd
, textsec
, buffer
,
855 (file_ptr
)(functionstart
+
856 bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
)),MIN_TBTABSIZ
))
857 { printf ("Abnormal return!..\n"); return NULL
; }
859 ptb
= (struct tbtable
*)buffer
;
862 ptb
= (struct tbtable
*)pinsn
;
864 tbInfo
.fixedparms
= ptb
->tb
.fixedparms
;
865 tbInfo
.floatparms
= ptb
->tb
.floatparms
;
866 tbInfo
.parminfo
= ptb
->tb_ext
.parminfo
;
870 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
871 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
877 /* Given a function symbol, return a pointer to its traceback table. */
880 retrieve_traceback (abfd
, textsec
, cs
, size
)
883 struct coff_symbol
*cs
;
884 int *size
; /* return function size */
886 #define TBTABLE_BUFSIZ 2000
887 #define MIN_TBTABSIZ 50 /* minimum buffer size to hold a
890 static char buffer
[TBTABLE_BUFSIZ
];
893 int bytesread
=0; /* total # of bytes read so far */
894 int bufferbytes
; /* number of bytes in the buffer */
896 int functionstart
= cs
->c_value
- textsec
->filepos
+ textsec
->vma
;
899 /* keep reading blocks of data from the text section, until finding a zero
900 word and a traceback table. */
902 while (bfd_get_section_contents (abfd
, textsec
, buffer
,
903 (file_ptr
)(functionstart
+ bytesread
),
905 (TBTABLE_BUFSIZ
< (textsec
->size
- functionstart
- bytesread
)) ?
906 TBTABLE_BUFSIZ
: (textsec
->size
- functionstart
- bytesread
))))
908 bytesread
+= bufferbytes
;
909 pinsn
= (int*) buffer
;
911 /* look for a zero word. */
913 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
916 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
921 /* function size is the amount of bytes we have skipped so far. */
922 *size
= bytesread
- (buffer
+ bufferbytes
- pinsn
);
926 /* if we don't have the whole traceback table in the buffer, re-read
929 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
931 /* In case if we are *very* close to the end of the text section
932 and cannot read properly from that point on, abort for now.
933 Handle this case more graciously -- FIXME */
935 if (!bfd_get_section_contents (
936 abfd
, textsec
, buffer
,
937 (file_ptr
)(functionstart
+
938 bytesread
- (buffer
+ bufferbytes
- pinsn
)),MIN_TBTABSIZ
))
939 /* abort (); */ { printf ("abort!!!\n"); return NULL
; }
941 return (struct tbtable
*)buffer
;
944 return (struct tbtable
*)pinsn
;
954 /* Save the vital information for use when closing off the current file.
955 NAME is the file name the symbols came from, START_ADDR is the first
956 text address for the file, and SIZE is the number of bytes of text. */
958 #define complete_symtab(name, start_addr) { \
959 last_source_file = savestring (name, strlen (name)); \
960 last_source_start_addr = start_addr; \
964 /* Refill the symbol table input buffer
965 and set the variables that control fetching entries from it.
966 Reports an error if no data available.
967 This function can read past the end of the symbol table
968 (into the string table) but this does no harm. */
970 /* Reading symbol table has to be fast! Keep the followings as macros, rather
973 #define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, ALLOCED) \
977 namestr = (NAME) + 1; \
980 obstack_copy0 (&objfile->symbol_obstack, (NAME) + 1, strlen ((NAME)+1)); \
983 prim_record_minimal_symbol (namestr, (ADDR), (TYPE)); \
984 misc_func_recorded = 1; \
988 /* A parameter template, used by ADD_PARM_TO_PENDING. It is initialized
989 in our initializer function at the bottom of the file, to avoid
990 dependencies on the exact "struct symbol" format. */
992 static struct symbol parmsym
;
994 /* Add a parameter to a given pending symbol list. */
996 #define ADD_PARM_TO_PENDING(PARM, VALUE, PTYPE, PENDING_SYMBOLS) \
998 PARM = (struct symbol *) \
999 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1000 *(PARM) = parmsym; \
1001 SYMBOL_TYPE (PARM) = PTYPE; \
1002 SYMBOL_VALUE (PARM) = VALUE; \
1003 add_symbol_to_list (PARM, &PENDING_SYMBOLS); \
1007 /* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
1008 nested. At any given time, a symbol can only be in one static block.
1009 This is the base address of current static block, zero if non exists. */
1011 static int static_block_base
= 0;
1013 /* true if space for symbol name has been allocated. */
1015 static int symname_alloced
= 0;
1017 /* read the whole symbol table of a given bfd. */
1020 read_xcoff_symtab (objfile
, nsyms
)
1021 struct objfile
*objfile
; /* Object file we're reading from */
1022 int nsyms
; /* # of symbols */
1024 bfd
*abfd
= objfile
->obfd
;
1025 char *raw_symbol
; /* Pointer into raw seething symbol table */
1026 char *raw_auxptr
; /* Pointer to first raw aux entry for sym */
1027 sec_ptr textsec
; /* Pointer to text section */
1028 TracebackInfo
*ptb
; /* Pointer to traceback table */
1030 struct internal_syment symbol
[1];
1031 union internal_auxent main_aux
[1];
1032 struct coff_symbol cs
[1];
1033 CORE_ADDR file_start_addr
= 0;
1034 CORE_ADDR file_end_addr
= 0;
1036 int next_file_symnum
= -1;
1037 int just_started
= 1;
1039 int toc_offset
= 0; /* toc offset value in data section. */
1043 long fcn_line_offset
;
1046 struct coff_symbol fcn_stab_saved
;
1048 /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
1049 union internal_auxent fcn_aux_saved
;
1050 struct type
*fcn_type_saved
= NULL
;
1051 struct context_stack
*new;
1053 char *filestring
= " _start_ "; /* Name of the current file. */
1055 char *last_csect_name
; /* last seen csect's name and value */
1056 CORE_ADDR last_csect_val
;
1057 int misc_func_recorded
; /* true if any misc. function */
1059 current_objfile
= objfile
;
1061 /* Get the appropriate COFF "constants" related to the file we're handling. */
1062 N_TMASK
= coff_data (abfd
)->local_n_tmask
;
1063 N_BTSHFT
= coff_data (abfd
)->local_n_btshft
;
1064 local_symesz
= coff_data (abfd
)->local_symesz
;
1066 last_source_file
= NULL
;
1067 last_csect_name
= 0;
1069 misc_func_recorded
= 0;
1072 start_symtab (filestring
, (char *)NULL
, file_start_addr
);
1074 first_object_file_end
= 0;
1076 /* Allocate space for the entire symbol table at once, and read it
1077 all in. The bfd is already positioned at the beginning of
1078 the symbol table. */
1080 size
= coff_data (abfd
)->local_symesz
* nsyms
;
1081 symtbl
= xmalloc (size
);
1082 symtbl_num_syms
= nsyms
;
1084 val
= bfd_read (symtbl
, size
, 1, abfd
);
1086 perror_with_name ("reading symbol table");
1088 raw_symbol
= symtbl
;
1090 textsec
= bfd_get_section_by_name (abfd
, ".text");
1092 printf ("Unable to locate text section!\n");
1095 while (symnum
< nsyms
) {
1097 QUIT
; /* make this command interruptable. */
1099 /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
1100 /* read one symbol into `cs' structure. After processing the whole symbol
1101 table, only string table will be kept in memory, symbol table and debug
1102 section of xcoff will be freed. Thus we can mark symbols with names
1103 in string table as `alloced'. */
1107 /* Swap and align the symbol into a reasonable C structure. */
1108 bfd_coff_swap_sym_in (abfd
, raw_symbol
, symbol
);
1110 cs
->c_symnum
= symnum
;
1111 cs
->c_nsyms
= symbol
->n_numaux
;
1112 if (symbol
->n_zeroes
) {
1113 symname_alloced
= 0;
1114 /* We must use the original, unswapped, name here so the name field
1115 pointed to by cs->c_name will persist throughout xcoffread. If
1116 we use the new field, it gets overwritten for each symbol. */
1117 cs
->c_name
= ((struct external_syment
*)raw_symbol
)->e
.e_name
;
1118 } else if (symbol
->n_sclass
& 0x80) {
1119 cs
->c_name
= debugsec
+ symbol
->n_offset
;
1120 symname_alloced
= 0;
1121 } else { /* in string table */
1122 cs
->c_name
= strtbl
+ (int)symbol
->n_offset
;
1123 symname_alloced
= 1;
1125 cs
->c_value
= symbol
->n_value
;
1126 /* n_sclass is signed (FIXME), so we had better not mask off any
1127 high bits it contains, since the values we will be comparing
1128 it to are also signed (FIXME). Defined in <coff/internal.h>.
1129 At this point (3Jun92, gnu@cygnus.com) I think the fix is to
1130 make the fields and values unsigned chars, but changing the next
1131 line is a simple patch late in the release cycle, for now. */
1132 cs
->c_sclass
= symbol
->n_sclass
/* & 0xff */;
1133 cs
->c_secnum
= symbol
->n_scnum
;
1134 cs
->c_type
= (unsigned)symbol
->n_type
;
1136 raw_symbol
+= coff_data (abfd
)->local_symesz
;
1139 raw_auxptr
= raw_symbol
; /* Save addr of first aux entry */
1141 /* Skip all the auxents associated with this symbol. */
1142 for (ii
= symbol
->n_numaux
; ii
; --ii
) {
1143 raw_symbol
+= coff_data (abfd
)->local_auxesz
;
1148 /* if symbol name starts with ".$" or "$", ignore it. */
1149 if (cs
->c_name
[0] == '$' || (cs
->c_name
[1] == '$' && cs
->c_name
[0] == '.'))
1152 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
) {
1153 if (last_source_file
)
1155 end_symtab (cur_src_end_addr
, 1, 0, objfile
);
1160 start_symtab ("_globals_", (char *)NULL
, (CORE_ADDR
)0);
1161 cur_src_end_addr
= first_object_file_end
;
1162 /* done with all files, everything from here on is globals */
1165 /* if explicitly specified as a function, treat is as one. */
1166 if (ISFCN(cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
) {
1167 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1169 goto function_entry_point
;
1172 if ((cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_HIDEXT
) && cs
->c_nsyms
== 1)
1174 /* dealing with a symbol with a csect entry. */
1176 # define CSECT(PP) ((PP)->x_csect)
1177 # define CSECT_LEN(PP) (CSECT(PP).x_scnlen)
1178 # define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1179 # define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1180 # define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1182 /* Convert the auxent to something we can access. */
1183 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1186 switch (CSECT_SMTYP (main_aux
)) {
1189 continue; /* ignore all external references. */
1191 case XTY_SD
: /* a section description. */
1193 switch (CSECT_SCLAS (main_aux
)) {
1195 case XMC_PR
: /* a `.text' csect. */
1198 /* A program csect is seen.
1200 We have to allocate one symbol table for each program csect. Normally
1201 gdb prefers one symtab for each compilation unit (CU). In case of AIX, one
1202 CU might include more than one prog csect, and they don't have to be
1203 adjacent in terms of the space they occupy in memory. Thus, one single
1204 CU might get fragmented in the memory and gdb's file start and end address
1205 approach does not work! */
1207 if (last_csect_name
) {
1209 /* if no misc. function recorded in the last seen csect, enter
1210 it as a function. This will take care of functions like
1211 strcmp() compiled by xlc. */
1213 if (!misc_func_recorded
) {
1215 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1220 complete_symtab (filestring
, file_start_addr
);
1221 cur_src_end_addr
= file_end_addr
;
1222 end_symtab (file_end_addr
, 1, 0, objfile
);
1225 start_symtab ((char *)NULL
, (char *)NULL
, (CORE_ADDR
)0);
1228 /* If this is the very first csect seen, basically `__start'. */
1230 first_object_file_end
= cs
->c_value
+ CSECT_LEN (main_aux
);
1234 file_start_addr
= cs
->c_value
;
1235 file_end_addr
= cs
->c_value
+ CSECT_LEN (main_aux
);
1237 if (cs
->c_name
&& cs
->c_name
[0] == '.') {
1238 last_csect_name
= cs
->c_name
;
1239 last_csect_val
= cs
->c_value
;
1242 misc_func_recorded
= 0;
1248 /* If the section is not a data description, ignore it. Note that
1249 uninitialized data will show up as XTY_CM/XMC_RW pair. */
1253 warning ("More than one xmc_tc0 symbol found.");
1254 toc_offset
= cs
->c_value
;
1257 case XMC_TC
: /* ignore toc entries */
1258 default : /* any other XMC_XXX */
1262 break; /* switch CSECT_SCLAS() */
1266 /* a function entry point. */
1267 if (CSECT_SCLAS (main_aux
) == XMC_PR
) {
1269 function_entry_point
:
1270 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
, mst_text
,
1273 fcn_line_offset
= main_aux
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1274 fcn_start_addr
= cs
->c_value
;
1276 /* save the function header info, which will be used
1277 when `.bf' is seen. */
1279 fcn_aux_saved
= *main_aux
;
1284 /* If function has two auxent, then debugging information is
1285 already available for it. Process traceback table for
1286 functions with only one auxent. */
1288 if (cs
->c_nsyms
== 1)
1289 ptb
= retrieve_tracebackinfo (abfd
, textsec
, cs
);
1291 else if (cs
->c_nsyms
!= 2)
1294 /* If there is traceback info, create and add parameters for it. */
1296 if (ptb
&& (ptb
->fixedparms
|| ptb
->floatparms
)) {
1298 int parmcnt
= ptb
->fixedparms
+ ptb
->floatparms
;
1299 char *parmcode
= (char*) &ptb
->parminfo
;
1300 int parmvalue
= ptb
->framesize
+ 0x18; /* sizeof(LINK AREA) == 0x18 */
1301 unsigned int ii
, mask
;
1303 for (ii
=0, mask
= 0x80000000; ii
<parmcnt
; ++ii
) {
1304 struct symbol
*parm
;
1306 if (ptb
->parminfo
& mask
) { /* float or double */
1308 if (ptb
->parminfo
& mask
) { /* double parm */
1310 (parm
, parmvalue
, builtin_type_double
, local_symbols
);
1311 parmvalue
+= sizeof (double);
1313 else { /* float parm */
1315 (parm
, parmvalue
, builtin_type_float
, local_symbols
);
1316 parmvalue
+= sizeof (float);
1319 else { /* fixed parm, use (int*) for hex rep. */
1320 ADD_PARM_TO_PENDING (parm
, parmvalue
,
1321 lookup_pointer_type (builtin_type_int
),
1323 parmvalue
+= sizeof (int);
1328 /* Fake this as a function. Needed in process_xcoff_symbol() */
1331 finish_block(process_xcoff_symbol (cs
, objfile
), &local_symbols
,
1332 pending_blocks
, cs
->c_value
,
1333 cs
->c_value
+ ptb
->fsize
, objfile
);
1337 /* shared library function trampoline code entry point. */
1338 else if (CSECT_SCLAS (main_aux
) == XMC_GL
) {
1340 /* record trampoline code entries as mst_unknown symbol. When we
1341 lookup mst symbols, we will choose mst_text over mst_unknown. */
1344 /* After the implementation of incremental loading of shared
1345 libraries, we don't want to access trampoline entries. This
1346 approach has a consequence of the necessity to bring the whole
1347 shared library at first, in order do anything with it (putting
1348 breakpoints, using malloc, etc). On the other side, this is
1349 consistient with gdb's behaviour on a SUN platform. */
1351 /* Trying to prefer *real* function entry over its trampoline,
1352 by assigning `mst_unknown' type to trampoline entries fails.
1353 Gdb treats those entries as chars. FIXME. */
1355 /* Recording this entry is necessary. Single stepping relies on
1356 this vector to get an idea about function address boundaries. */
1358 prim_record_minimal_symbol ("<trampoline>", cs
->c_value
,
1362 /* record trampoline code entries as mst_unknown symbol. When we
1363 lookup mst symbols, we will choose mst_text over mst_unknown. */
1365 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
, mst_unknown
,
1372 default : /* all other XTY_XXXs */
1374 } /* switch CSECT_SMTYP() */ }
1376 switch (cs
->c_sclass
) {
1380 /* see if the last csect needs to be recorded. */
1382 if (last_csect_name
&& !misc_func_recorded
) {
1384 /* if no misc. function recorded in the last seen csect, enter
1385 it as a function. This will take care of functions like
1386 strcmp() compiled by xlc. */
1389 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1393 /* c_value field contains symnum of next .file entry in table
1394 or symnum of first global after last .file. */
1396 next_file_symnum
= cs
->c_value
;
1398 /* complete symbol table for last object file containing
1399 debugging information. */
1401 /* Whether or not there was a csect in the previous file, we have to call
1402 `end_stabs' and `start_stabs' to reset type_vector,
1403 line_vector, etc. structures. */
1405 complete_symtab (filestring
, file_start_addr
);
1406 cur_src_end_addr
= file_end_addr
;
1407 end_symtab (file_end_addr
, 1, 0, objfile
);
1410 start_symtab (cs
->c_name
, (char *)NULL
, (CORE_ADDR
)0);
1411 last_csect_name
= 0;
1413 /* reset file start and end addresses. A compilation unit with no text
1414 (only data) should have zero file boundaries. */
1415 file_start_addr
= file_end_addr
= 0;
1417 filestring
= cs
->c_name
;
1423 #ifdef NO_DEFINE_SYMBOL
1424 /* For a function stab, just save its type in `fcn_type_saved', and leave
1425 it for the `.bf' processing. */
1427 char *pp
= (char*) index (cs
->c_name
, ':');
1429 if (!pp
|| ( *(pp
+1) != 'F' && *(pp
+1) != 'f'))
1430 fatal ("Unrecognized stab");
1434 fatal ("Unprocessed function type");
1436 fcn_type_saved
= lookup_function_type (read_type (&pp
, objfile
));
1439 fcn_stab_saved
= *cs
;
1445 if (STREQ (cs
->c_name
, ".bf")) {
1447 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1450 within_function
= 1;
1452 /* Linenos are now processed on a file-by-file, not fn-by-fn, basis.
1453 Metin did it, I'm not sure why. FIXME. -- gnu@cygnus.com */
1457 1) xlc (IBM's native c compiler) postpones static function code
1458 emission to the end of a compilation unit. This way it can
1459 determine if those functions (statics) are needed or not, and
1460 can do some garbage collection (I think). This makes line
1461 numbers and corresponding addresses unordered, and we end up
1462 with a line table like:
1479 and that breaks gdb's binary search on line numbers, if the
1480 above table is not sorted on line numbers. And that sort
1481 should be on function based, since gcc can emit line numbers
1484 10 0x100 - for the init/test part of a for stmt.
1487 10 0x400 - for the increment part of a for stmt.
1489 arrange_linenos() will do this sorting.
1492 2) aix symbol table might look like:
1494 c_file // beginning of a new file
1495 .bi // beginning of include file
1496 .ei // end of include file
1500 basically, .bi/.ei pairs do not necessarily encapsulate
1501 their scope. They need to be recorded, and processed later
1502 on when we come the end of the compilation unit.
1503 Include table (inclTable) and process_linenos() handle
1506 mark_first_line (fcn_line_offset
, cs
->c_symnum
);
1508 new = push_context (0, fcn_start_addr
);
1510 #ifdef NO_DEFINE_SYMBOL
1511 new->name
= process_xcoff_symbol (&fcn_cs_saved
, objfile
);
1513 /* Between a function symbol and `.bf', there always will be a function
1514 stab. We save function type when processing that stab. */
1516 if (fcn_type_saved
== NULL
) {
1517 printf ("Unknown function type: symbol 0x%x\n", cs
->c_symnum
);
1518 SYMBOL_TYPE (new->name
) = lookup_function_type (builtin_type_int
);
1521 SYMBOL_TYPE (new->name
) = fcn_type_saved
;
1522 fcn_type_saved
= NULL
;
1525 new->name
= define_symbol
1526 (fcn_cs_saved
.c_value
, fcn_stab_saved
.c_name
, 0, 0, objfile
);
1529 else if (STREQ (cs
->c_name
, ".ef")) {
1531 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1534 /* the value of .ef is the address of epilogue code;
1535 not useful for gdb */
1536 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1537 contains number of lines to '}' */
1539 fcn_last_line
= main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
1540 new = pop_context ();
1541 if (context_stack_depth
!= 0)
1542 error ("invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.",
1545 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1547 fcn_cs_saved
.c_value
+
1548 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
, objfile
);
1549 within_function
= 0;
1553 case C_BSTAT
: /* begin static block */
1554 static_block_base
= read_symbol_nvalue (cs
->c_value
);
1557 case C_ESTAT
: /* end of static block */
1558 static_block_base
= 0;
1561 case C_ARG
: /* These are not implemented. */
1567 printf ("ERROR: Unimplemented storage class: %d.\n", cs
->c_sclass
);
1570 case C_HIDEXT
: /* ignore these.. */
1575 case C_BINCL
: /* beginning of include file */
1577 /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1578 order. Thus, when wee see them, we might not know enough info
1579 to process them. Thus, we'll be saving them into a table
1580 (inclTable) and postpone their processing. */
1582 record_include_begin (cs
);
1585 case C_EINCL
: /* end of include file */
1586 /* see the comment after case C_BINCL. */
1587 record_include_end (cs
);
1591 if (STREQ (cs
->c_name
, ".bb")) {
1593 new = push_context (depth
, cs
->c_value
);
1595 else if (STREQ (cs
->c_name
, ".eb")) {
1596 new = pop_context ();
1597 if (depth
!= new->depth
)
1598 error ("Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
1602 if (local_symbols
&& context_stack_depth
> 0) {
1603 /* Make a block for the local symbols within. */
1604 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1605 new->start_addr
, cs
->c_value
, objfile
);
1607 local_symbols
= new->locals
;
1612 process_xcoff_symbol (cs
, objfile
);
1618 if (last_source_file
)
1620 end_symtab (cur_src_end_addr
, 1, 0, objfile
);
1625 current_objfile
= NULL
;
1627 /* Record the toc offset value of this symbol table into ldinfo structure.
1628 If no XMC_TC0 is found, toc_offset should be zero. Another place to obtain
1629 this information would be file auxiliary header. */
1631 #ifndef FAKING_RS6000
1632 xcoff_add_toc_to_loadinfo (toc_offset
);
1636 #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1637 (SYMBOL2) = (struct symbol *) \
1638 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1639 *(SYMBOL2) = *(SYMBOL1);
1642 #define SYMNAME_ALLOC(NAME, ALLOCED) \
1643 (ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME));
1646 /* process one xcoff symbol. */
1648 static struct symbol
*
1649 process_xcoff_symbol (cs
, objfile
)
1650 register struct coff_symbol
*cs
;
1651 struct objfile
*objfile
;
1653 struct symbol onesymbol
;
1654 register struct symbol
*sym
= &onesymbol
;
1655 struct symbol
*sym2
= NULL
;
1657 char *name
, *pp
, *qq
;
1658 int struct_and_type_combined
;
1665 bzero (sym
, sizeof (struct symbol
));
1667 /* default assumptions */
1668 SYMBOL_VALUE (sym
) = cs
->c_value
;
1669 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1671 if (ISFCN (cs
->c_type
)) {
1673 /* At this point, we don't know the type of the function and assume it
1674 is int. This will be patched with the type from its stab entry later
1675 on in patch_block_stabs () */
1677 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1678 SYMBOL_TYPE (sym
) = lookup_function_type (lookup_fundamental_type (objfile
, FT_INTEGER
));
1680 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1681 SYMBOL_DUP (sym
, sym2
);
1683 if (cs
->c_sclass
== C_EXT
)
1684 add_symbol_to_list (sym2
, &global_symbols
);
1685 else if (cs
->c_sclass
== C_HIDEXT
|| cs
->c_sclass
== C_STAT
)
1686 add_symbol_to_list (sym2
, &file_symbols
);
1691 /* in case we can't figure out the type, default is `int'. */
1692 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
1694 switch (cs
->c_sclass
)
1698 if (fcn_cs_saved
.c_sclass
== C_EXT
)
1699 add_stab_to_list (name
, &global_stabs
);
1701 add_stab_to_list (name
, &file_stabs
);
1705 case C_DECL
: /* a type decleration?? */
1707 #if defined(NO_TYPEDEFS) || defined(NO_DEFINE_SYMBOL)
1708 qq
= (char*) strchr (name
, ':');
1709 if (!qq
) /* skip if there is no ':' */
1712 nameless
= (qq
== name
);
1714 struct_and_type_combined
= (qq
[1] == 'T' && qq
[2] == 't');
1715 pp
= qq
+ (struct_and_type_combined
? 3 : 2);
1718 /* To handle GNU C++ typename abbreviation, we need to be able to fill
1719 in a type's name as soon as space for that type is allocated. */
1721 if (struct_and_type_combined
&& name
!= qq
) {
1724 struct type
*tmp_type
;
1727 read_type_number (&tmp_pp
, typenums
);
1728 tmp_type
= dbx_alloc_type (typenums
, objfile
);
1730 if (tmp_type
&& !TYPE_NAME (tmp_type
) && !nameless
)
1731 TYPE_NAME (tmp_type
) = SYMBOL_NAME (sym
) =
1732 obsavestring (name
, qq
-name
,
1733 &objfile
->symbol_obstack
);
1735 ttype
= SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1737 /* if there is no name for this typedef, you don't have to keep its
1738 symbol, since nobody could ask for it. Otherwise, build a symbol
1739 and add it into symbol_list. */
1745 /* Transarc wants to eliminate type definitions from the symbol table.
1746 Limited debugging capabilities, but faster symbol table processing
1747 and less memory usage. Note that tag definitions (starting with
1748 'T') will remain intact. */
1750 if (qq
[1] != 'T' && (!TYPE_NAME (ttype
) || *(TYPE_NAME (ttype
)) == '\0')) {
1752 if (SYMBOL_NAME (sym
))
1753 TYPE_NAME (ttype
) = SYMBOL_NAME (sym
);
1755 TYPE_NAME (ttype
) = obsavestring (name
, qq
-name
);
1760 #endif /* !NO_TYPEDEFS */
1762 /* read_type() will return null if type (or tag) definition was
1763 unnnecessarily duplicated. Also, if the symbol doesn't have a name,
1764 there is no need to keep it in symbol table. */
1765 /* The above argument no longer valid. read_type() never returns NULL. */
1770 /* if there is no name for this typedef, you don't have to keep its
1771 symbol, since nobody could ask for it. Otherwise, build a symbol
1772 and add it into symbol_list. */
1775 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1776 else if (qq
[1] == 't')
1777 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1779 warning ("Unrecognized stab string.\n");
1783 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1784 if (!SYMBOL_NAME (sym
))
1785 SYMBOL_NAME (sym
) = obsavestring (name
, qq
-name
);
1787 SYMBOL_DUP (sym
, sym2
);
1789 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1791 /* For a combination of struct and type, add one more symbol
1794 if (struct_and_type_combined
) {
1795 SYMBOL_DUP (sym
, sym2
);
1796 SYMBOL_NAMESPACE (sym2
) = VAR_NAMESPACE
;
1798 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1801 /* assign a name to the type node. */
1803 if (!TYPE_NAME (ttype
) || *(TYPE_NAME (ttype
)) == '\0') {
1804 if (struct_and_type_combined
)
1805 TYPE_NAME (ttype
) = SYMBOL_NAME (sym
);
1806 else if (qq
[1] == 'T') /* struct namespace */
1807 TYPE_NAME (ttype
) = concat (
1808 TYPE_CODE (ttype
) == TYPE_CODE_UNION
? "union " :
1809 TYPE_CODE (ttype
) == TYPE_CODE_STRUCT
? "struct " : "enum ",
1810 SYMBOL_NAME (sym
), NULL
);
1814 #else /* !NO_DEFINE_SYMBOL */
1815 return define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1819 add_stab_to_list (name
, &global_stabs
);
1825 #ifdef NO_DEFINE_SYMBOL
1826 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1828 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1829 SYMBOL_CLASS (sym
) = (cs
->c_sclass
== C_PSYM
) ? LOC_ARG
: LOC_REGPARM
;
1831 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1832 SYMBOL_DUP (sym
, sym2
);
1833 add_symbol_to_list (sym2
, &local_symbols
);
1836 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1837 SYMBOL_CLASS (sym
) = (cs
->c_sclass
== C_PSYM
) ? LOC_ARG
: LOC_REGPARM
;
1843 #ifdef NO_DEFINE_SYMBOL
1844 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1846 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1847 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1848 SYMBOL_VALUE (sym
) += static_block_base
;
1850 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1851 SYMBOL_DUP (sym
, sym2
);
1853 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1856 /* If we are going to use Sun dbx's define_symbol(), we need to
1857 massage our stab string a little. Change 'V' type to 'S' to be
1858 comparible with Sun. */
1860 if (*name
== ':' || (pp
= (char *) index (name
, ':')) == NULL
)
1864 if (*pp
== 'V') *pp
= 'S';
1865 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1866 SYMBOL_VALUE (sym
) += static_block_base
;
1871 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1873 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1874 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1876 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1877 SYMBOL_DUP (sym
, sym2
);
1878 add_symbol_to_list (sym2
, &local_symbols
);
1882 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1883 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1884 SYMBOL_DUP (sym
, sym2
);
1885 add_symbol_to_list (sym2
, &local_symbols
);
1889 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1890 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1891 SYMBOL_DUP (sym
, sym2
);
1892 add_symbol_to_list (sym2
, &global_symbols
);
1896 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1897 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1898 SYMBOL_DUP (sym
, sym2
);
1900 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1904 printf ("ERROR! C_REG is not fully implemented!\n");
1905 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1906 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1907 SYMBOL_DUP (sym
, sym2
);
1908 add_symbol_to_list (sym2
, &local_symbols
);
1912 pp
= (char*) strchr (name
, ':');
1913 #ifdef NO_DEFINE_SYMBOL
1914 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1915 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (cs
->c_value
);
1917 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1920 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1923 /* else this is not a stab entry, suppose the type is either
1924 `int' or `float', depending on the register class. */
1926 SYMBOL_TYPE (sym
) = (SYMBOL_VALUE (sym
) < 32)
1927 ? lookup_fundamental_type (objfile
, FT_INTEGER
)
1928 : lookup_fundamental_type (objfile
, FT_FLOAT
);
1930 SYMBOL_DUP (sym
, sym2
);
1931 add_symbol_to_list (sym2
, &local_symbols
);
1935 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1939 complain (&rsym_complaint
, name
);
1945 complain (&storclass_complaint
, cs
->c_sclass
);
1952 /* Get value corresponding to symbol number symno in symtbl. */
1955 read_symbol_nvalue (symno
)
1958 struct internal_syment symbol
[1];
1960 if (symno
< 0 || symno
>= symtbl_num_syms
)
1962 struct complaint msg
=
1963 {"Invalid symbol offset", 0, 0};
1967 bfd_coff_swap_sym_in (symfile_bfd
, symtbl
+ (symno
*local_symesz
), symbol
);
1968 return symbol
->n_value
;
1972 /* Find the address of the function corresponding to symno, where
1973 symno is the symbol pointed to by the linetable. */
1976 read_symbol_lineno (symno
)
1979 struct internal_syment symbol
[1];
1980 union internal_auxent main_aux
[1];
1982 /* Note that just searching for a short distance (e.g. 50 symbols)
1983 is not enough, at least in the following case.
1986 [many .stabx entries]
1987 [a few functions, referring to foo]
1991 What happens here is that the assembler moves the .stabx entries
1992 to right before the ".bf" for foo, but the symbol for "foo" is before
1993 all the stabx entries. See PR gdb/2222. */
1994 while (symno
< symtbl_num_syms
) {
1995 bfd_coff_swap_sym_in (symfile_bfd
,
1996 symtbl
+ (symno
*local_symesz
), symbol
);
1997 if (symbol
->n_sclass
== C_FCN
&& STREQ (symbol
->n_name
, ".bf"))
1999 symno
+= symbol
->n_numaux
+1;
2002 complain (&bf_notfound_complaint
);
2006 /* take aux entry and return its lineno */
2008 bfd_coff_swap_aux_in (symfile_bfd
, symtbl
+(symno
*local_symesz
),
2009 symbol
->n_type
, symbol
->n_sclass
, main_aux
);
2011 return main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2014 /* Support for line number handling */
2016 /* This function is called for every section; it finds the outer limits
2017 * of the line table (minimum and maximum file offset) so that the
2018 * mainline code can read the whole thing for efficiency.
2021 find_linenos(abfd
, asect
, vpinfo
)
2026 struct coff_symfile_info
*info
;
2028 file_ptr offset
, maxoff
;
2030 count
= asect
->lineno_count
;
2032 if (!STREQ (asect
->name
, ".text") || count
== 0)
2035 size
= count
* coff_data (symfile_bfd
)->local_linesz
;
2036 info
= (struct coff_symfile_info
*)vpinfo
;
2037 offset
= asect
->line_filepos
;
2038 maxoff
= offset
+ size
;
2040 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
2041 info
->min_lineno_offset
= offset
;
2043 if (maxoff
> info
->max_lineno_offset
)
2044 info
->max_lineno_offset
= maxoff
;
2048 /* Read in all the line numbers for fast lookups later. Leave them in
2049 external (unswapped) format in memory; we'll swap them as we enter
2050 them into GDB's data structures. */
2053 init_lineno (abfd
, offset
, size
)
2060 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
2063 linetab
= (char *) xmalloc(size
);
2065 val
= bfd_read(linetab
, 1, size
, abfd
);
2069 linetab_offset
= offset
;
2070 linetab_size
= size
;
2071 make_cleanup (free
, linetab
); /* Be sure it gets de-allocated. */
2075 /* dbx allows the text of a symbol name to be continued into the
2076 next symbol name! When such a continuation is encountered
2077 (a \ at the end of the text of a name)
2078 call this function to get the continuation. */
2079 /* So far, I haven't seen this happenning xlc output. I doubt we'll need this
2082 #undef next_symbol_text
2083 #define next_symbol_text() \
2084 printf ("Gdb Error: symbol names on multiple lines not implemented.\n")
2088 xcoff_new_init (objfile
)
2089 struct objfile
*objfile
;
2094 /* xcoff_symfile_init()
2095 is the xcoff-specific initialization routine for reading symbols.
2096 It is passed an objfile which contains, among other things,
2097 the BFD for the file whose symbols are being read, and a slot for
2098 a pointer to "private data" which we fill with cookies and other
2099 treats for xcoff_symfile_read().
2101 We will only be called if this is an XCOFF or XCOFF-like file.
2102 BFD handles figuring out the format of the file, and code in symfile.c
2103 uses BFD's determination to vector to us.
2105 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
2108 xcoff_symfile_init (objfile
)
2109 struct objfile
*objfile
;
2111 bfd
*abfd
= objfile
->obfd
;
2113 /* Allocate struct to keep track of the symfile */
2114 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
2115 sizeof (struct coff_symfile_info
));
2116 init_entry_point_info (objfile
);
2119 /* Perform any local cleanups required when we are done with a particular
2120 objfile. I.E, we are in the process of discarding all symbol information
2121 for an objfile, freeing up all memory held for it, and unlinking the
2122 objfile struct from the global list of known objfiles. */
2125 xcoff_symfile_finish (objfile
)
2126 struct objfile
*objfile
;
2128 if (objfile
-> sym_private
!= NULL
)
2130 mfree (objfile
-> md
, objfile
-> sym_private
);
2133 /* Start with a fresh include table for the next objfile. */
2140 inclIndx
= inclLength
= inclDepth
= 0;
2145 init_stringtab(abfd
, offset
, objfile
)
2148 struct objfile
*objfile
;
2152 unsigned char lengthbuf
[4];
2154 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
2157 val
= bfd_read((char *)lengthbuf
, 1, sizeof lengthbuf
, abfd
);
2158 length
= bfd_h_get_32(abfd
, lengthbuf
);
2160 /* If no string table is needed, then the file may end immediately
2161 after the symbols. Just return with `strtbl' set to null. */
2163 if (val
!= sizeof length
|| length
< sizeof length
)
2166 /* Allocate string table from symbol_obstack. We will need this table
2167 as long as we have its symbol table around. */
2169 strtbl
= (char*) obstack_alloc (&objfile
->symbol_obstack
, length
);
2173 bcopy(&length
, strtbl
, sizeof length
);
2174 if (length
== sizeof length
)
2177 val
= bfd_read(strtbl
+ sizeof length
, 1, length
- sizeof length
, abfd
);
2179 if (val
!= length
- sizeof length
|| strtbl
[length
- 1] != '\0')
2186 init_debugsection(abfd
)
2189 register sec_ptr secp
;
2190 bfd_size_type length
;
2197 secp
= bfd_get_section_by_name(abfd
, ".debug");
2201 if (!(length
= bfd_section_size(abfd
, secp
)))
2204 debugsec
= (char *) xmalloc ((unsigned)length
);
2205 if (debugsec
== NULL
)
2208 if (!bfd_get_section_contents(abfd
, secp
, debugsec
, (file_ptr
) 0, length
)) {
2209 printf ("Can't read .debug section from symbol file\n");
2224 /* xcoff version of symbol file read. */
2227 xcoff_symfile_read (objfile
, section_offset
, mainline
)
2228 struct objfile
*objfile
;
2229 struct section_offset
*section_offset
;
2232 int num_symbols
; /* # of symbols */
2233 file_ptr symtab_offset
; /* symbol table and */
2234 file_ptr stringtab_offset
; /* string table file offsets */
2237 struct coff_symfile_info
*info
;
2240 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
2241 symfile_bfd
= abfd
= objfile
->obfd
;
2242 name
= objfile
->name
;
2244 num_symbols
= bfd_get_symcount (abfd
); /* # of symbols */
2245 symtab_offset
= obj_sym_filepos (abfd
); /* symbol table file offset */
2246 stringtab_offset
= symtab_offset
+
2247 num_symbols
* coff_data(abfd
)->local_symesz
;
2249 info
->min_lineno_offset
= 0;
2250 info
->max_lineno_offset
= 0;
2251 bfd_map_over_sections (abfd
, find_linenos
, info
);
2253 /* FIXME! This stuff should move into symfile_init */
2254 if (info
->min_lineno_offset
!= 0
2255 && info
->max_lineno_offset
> info
->min_lineno_offset
) {
2257 /* only read in the line # table if one exists */
2258 val
= init_lineno(abfd
, info
->min_lineno_offset
,
2259 (int) (info
->max_lineno_offset
- info
->min_lineno_offset
));
2262 error("\"%s\": error reading line numbers\n", name
);
2265 if (num_symbols
> 0)
2267 val
= init_stringtab(abfd
, stringtab_offset
, objfile
);
2269 error ("\"%s\": can't get string table", name
);
2272 if (init_debugsection(abfd
) < 0) {
2273 error ("Error reading .debug section of `%s'\n", name
);
2277 /* Position to read the symbol table. Do not read it all at once. */
2278 val
= bfd_seek(abfd
, symtab_offset
, L_SET
);
2280 perror_with_name(name
);
2282 if (bfd_tell(abfd
) != symtab_offset
)
2285 init_minimal_symbol_collection ();
2286 make_cleanup (discard_minimal_symbols
, 0);
2288 #ifndef FAKING_RS6000
2289 /* Initialize load info structure. */
2291 xcoff_init_loadinfo ();
2294 /* Now that the executable file is positioned at symbol table,
2295 process it and define symbols accordingly. */
2297 read_xcoff_symtab(objfile
, num_symbols
);
2299 /* Free debug section. */
2300 free_debugsection ();
2302 /* Sort symbols alphabetically within each block. */
2305 /* Install any minimal symbols that have been collected as the current
2306 minimal symbols for this objfile. */
2308 install_minimal_symbols (objfile
);
2310 /* Make a default for file to list. */
2311 select_source_symtab (0);
2314 /* XCOFF-specific parsing routine for section offsets.
2315 Plain and simple for now. */
2318 struct section_offsets
*
2319 xcoff_symfile_offsets (objfile
, addr
)
2320 struct objfile
*objfile
;
2323 struct section_offsets
*section_offsets
;
2326 section_offsets
= (struct section_offsets
*)
2327 obstack_alloc (&objfile
-> psymbol_obstack
,
2328 sizeof (struct section_offsets
) +
2329 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
2331 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
2332 ANOFFSET (section_offsets
, i
) = addr
;
2334 return section_offsets
;
2336 /* Register our ability to parse symbols for xcoff BFD files. */
2338 static struct sym_fns xcoff_sym_fns
=
2340 "aixcoff-rs6000", /* sym_name: name or name prefix of BFD target type */
2341 15, /* sym_namelen: number of significant sym_name chars */
2342 xcoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2343 xcoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2344 xcoff_symfile_read
, /* sym_read: read a symbol file into symtab */
2345 xcoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2346 xcoff_symfile_offsets
, /* sym_offsets: xlate offsets ext->int form */
2347 NULL
/* next: pointer to next struct sym_fns */
2351 _initialize_xcoffread ()
2353 add_symtab_fns(&xcoff_sym_fns
);
2355 /* Initialize symbol template later used for arguments. */
2356 SYMBOL_NAME (&parmsym
) = "";
2357 SYMBOL_INIT_LANGUAGE_SPECIFIC (&parmsym
, language_c
);
2358 SYMBOL_NAMESPACE (&parmsym
) = VAR_NAMESPACE
;
2359 SYMBOL_CLASS (&parmsym
) = LOC_ARG
;
2360 /* Its other fields are zero, or are filled in later. */