1 /* Read AIX xcoff symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995
3 Free Software Foundation, Inc.
4 Derived from coffread.c, dbxread.c, and a lot of hacking.
5 Contributed by IBM Corporation.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
23 /* Native only: Need struct tbtable in <sys/debug.h> from host, and
24 need xcoff_add_toc_to_loadinfo in rs6000-tdep.c from target.
25 need xcoff_init_loadinfo ditto.
26 However, if you grab <sys/debug.h> and make it available on your
27 host, and define FAKING_RS6000, then this code will compile. */
32 #include <sys/types.h>
38 #include <sys/param.h>
43 #include <sys/debug.h>
45 #include "coff/internal.h" /* FIXME, internal data from BFD */
46 #include "libcoff.h" /* FIXME, internal data from BFD */
47 #include "coff/rs6000.h" /* FIXME, raw file-format guts of xcoff */
54 #include "stabsread.h"
55 #include "complaints.h"
57 #include "gdb-stabs.h"
59 /* For interface with stabsread.c. */
60 #include "aout/stab_gnu.h"
62 /* Simplified internal version of coff symbol table information */
66 int c_symnum
; /* symbol number of this entry */
67 int c_naux
; /* 0 if syment only, 1 if syment + auxent */
69 unsigned char c_sclass
;
74 /* The COFF line table, in raw form. */
75 static char *linetab
= NULL
; /* Its actual contents */
76 static long linetab_offset
; /* Its offset in the file */
77 static unsigned long linetab_size
; /* Its size */
79 /* last function's saved coff symbol `cs' */
81 static struct coff_symbol fcn_cs_saved
;
83 static bfd
*symfile_bfd
;
85 /* Core address of start and end of text of current source file.
86 This is calculated from the first function seen after a C_FILE
90 static CORE_ADDR cur_src_end_addr
;
92 /* Core address of the end of the first object file. */
94 static CORE_ADDR first_object_file_end
;
96 /* pointer to the string table */
99 /* length of the string table */
100 static int strtbl_len
;
102 /* pointer to debug section */
103 static char *debugsec
;
105 /* pointer to the a.out symbol table */
108 /* Number of symbols in symtbl. */
109 static int symtbl_num_syms
;
111 /* initial symbol-table-debug-string vector length */
113 #define INITIAL_STABVECTOR_LENGTH 40
115 /* Nonzero if within a function (so symbols should be local,
116 if nothing says specifically). */
120 /* Local variables that hold the shift and mask values for the
121 COFF file that we are currently reading. These come back to us
122 from BFD, and are referenced by their macro names, as well as
123 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
124 macros from ../internalcoff.h . */
126 static unsigned local_n_btshft
;
127 static unsigned local_n_tmask
;
130 #define N_BTSHFT local_n_btshft
132 #define N_TMASK local_n_tmask
134 /* Local variables that hold the sizes in the file of various COFF structures.
135 (We only need to know this to read them from the file -- BFD will then
136 translate the data in them, into `internal_xxx' structs in the right
137 byte order, alignment, etc.) */
139 static unsigned local_symesz
;
141 struct coff_symfile_info
{
142 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
143 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
146 static struct complaint rsym_complaint
=
147 {"Non-stab C_RSYM `%s' needs special handling", 0, 0};
149 static struct complaint storclass_complaint
=
150 {"Unexpected storage class: %d", 0, 0};
152 static struct complaint bf_notfound_complaint
=
153 {"line numbers off, `.bf' symbol not found", 0, 0};
155 extern struct complaint ef_complaint
;
156 extern struct complaint eb_complaint
;
159 enter_line_range
PARAMS ((struct subfile
*, unsigned, unsigned,
160 CORE_ADDR
, CORE_ADDR
, unsigned *));
163 free_debugsection
PARAMS ((void));
166 init_debugsection
PARAMS ((bfd
*));
169 init_stringtab
PARAMS ((bfd
*, file_ptr
, struct objfile
*));
172 xcoff_symfile_init
PARAMS ((struct objfile
*));
175 xcoff_new_init
PARAMS ((struct objfile
*));
178 xcoff_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
181 xcoff_symfile_finish
PARAMS ((struct objfile
*));
183 static struct section_offsets
*
184 xcoff_symfile_offsets
PARAMS ((struct objfile
*, CORE_ADDR
));
187 init_lineno
PARAMS ((bfd
*, file_ptr
, int));
190 free_linetab
PARAMS ((void));
193 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
196 coff_getfilename
PARAMS ((union internal_auxent
*));
199 read_symbol
PARAMS ((struct internal_syment
*, int));
202 read_symbol_lineno
PARAMS ((int));
205 read_symbol_nvalue
PARAMS ((int));
207 static struct symbol
*
208 process_xcoff_symbol
PARAMS ((struct coff_symbol
*, struct objfile
*));
211 read_xcoff_symtab
PARAMS ((struct objfile
*, int));
214 add_stab_to_list
PARAMS ((char *, struct pending_stabs
**));
217 /* Return the section_offsets* that CS points to. */
218 static int cs_to_section
PARAMS ((struct coff_symbol
*, struct objfile
*));
220 struct find_targ_sec_arg
{
225 static void find_targ_sec
PARAMS ((bfd
*, asection
*, void *));
227 static void find_targ_sec (abfd
, sect
, obj
)
232 struct find_targ_sec_arg
*args
= (struct find_targ_sec_arg
*)obj
;
233 if (sect
->target_index
== args
->targ_index
)
235 /* This is the section. Figure out what SECT_OFF_* code it is. */
236 if (bfd_get_section_flags (abfd
, sect
) & SEC_CODE
)
237 *args
->resultp
= SECT_OFF_TEXT
;
238 else if (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
)
239 *args
->resultp
= SECT_OFF_DATA
;
241 *args
->resultp
= SECT_OFF_BSS
;
245 /* Return the section number (SECT_OFF_*) that CS points to. */
247 cs_to_section (cs
, objfile
)
248 struct coff_symbol
*cs
;
249 struct objfile
*objfile
;
251 int off
= SECT_OFF_TEXT
;
252 struct find_targ_sec_arg args
;
253 args
.targ_index
= cs
->c_secnum
;
255 bfd_map_over_sections (objfile
->obfd
, find_targ_sec
, &args
);
259 /* add a given stab string into given stab vector. */
262 add_stab_to_list (stabname
, stabvector
)
264 struct pending_stabs
**stabvector
;
266 if ( *stabvector
== NULL
) {
267 *stabvector
= (struct pending_stabs
*)
268 xmalloc (sizeof (struct pending_stabs
) +
269 INITIAL_STABVECTOR_LENGTH
* sizeof (char*));
270 (*stabvector
)->count
= 0;
271 (*stabvector
)->length
= INITIAL_STABVECTOR_LENGTH
;
273 else if ((*stabvector
)->count
>= (*stabvector
)->length
) {
274 (*stabvector
)->length
+= INITIAL_STABVECTOR_LENGTH
;
275 *stabvector
= (struct pending_stabs
*)
276 xrealloc ((char *) *stabvector
, sizeof (struct pending_stabs
) +
277 (*stabvector
)->length
* sizeof (char*));
279 (*stabvector
)->stab
[(*stabvector
)->count
++] = stabname
;
282 /* Linenos are processed on a file-by-file basis.
286 1) xlc (IBM's native c compiler) postpones static function code
287 emission to the end of a compilation unit. This way it can
288 determine if those functions (statics) are needed or not, and
289 can do some garbage collection (I think). This makes line
290 numbers and corresponding addresses unordered, and we end up
291 with a line table like:
308 and that breaks gdb's binary search on line numbers, if the
309 above table is not sorted on line numbers. And that sort
310 should be on function based, since gcc can emit line numbers
313 10 0x100 - for the init/test part of a for stmt.
316 10 0x400 - for the increment part of a for stmt.
318 arrange_linetable() will do this sorting.
320 2) aix symbol table might look like:
322 c_file // beginning of a new file
323 .bi // beginning of include file
324 .ei // end of include file
328 basically, .bi/.ei pairs do not necessarily encapsulate
329 their scope. They need to be recorded, and processed later
330 on when we come the end of the compilation unit.
331 Include table (inclTable) and process_linenos() handle
334 /* compare line table entry addresses. */
337 compare_lte (lte1
, lte2
)
338 struct linetable_entry
*lte1
, *lte2
;
340 return lte1
->pc
- lte2
->pc
;
343 /* Give a line table with function entries are marked, arrange its functions
344 in assending order and strip off function entry markers and return it in
345 a newly created table. If the old one is good enough, return the old one. */
346 /* FIXME: I think all this stuff can be replaced by just passing
347 sort_linevec = 1 to end_symtab. */
349 static struct linetable
*
350 arrange_linetable (oldLineTb
)
351 struct linetable
*oldLineTb
; /* old linetable */
354 newline
, /* new line count */
355 function_count
; /* # of functions */
357 struct linetable_entry
*fentry
; /* function entry vector */
358 int fentry_size
; /* # of function entries */
359 struct linetable
*newLineTb
; /* new line table */
361 #define NUM_OF_FUNCTIONS 20
363 fentry_size
= NUM_OF_FUNCTIONS
;
364 fentry
= (struct linetable_entry
*)
365 xmalloc (fentry_size
* sizeof (struct linetable_entry
));
367 for (function_count
=0, ii
=0; ii
<oldLineTb
->nitems
; ++ii
) {
369 if (oldLineTb
->item
[ii
].line
== 0) { /* function entry found. */
371 if (function_count
>= fentry_size
) { /* make sure you have room. */
373 fentry
= (struct linetable_entry
*)
374 xrealloc (fentry
, fentry_size
* sizeof (struct linetable_entry
));
376 fentry
[function_count
].line
= ii
;
377 fentry
[function_count
].pc
= oldLineTb
->item
[ii
].pc
;
382 if (function_count
== 0) {
386 else if (function_count
> 1)
387 qsort (fentry
, function_count
, sizeof(struct linetable_entry
), compare_lte
);
389 /* allocate a new line table. */
390 newLineTb
= (struct linetable
*)
392 (sizeof (struct linetable
) +
393 (oldLineTb
->nitems
- function_count
) * sizeof (struct linetable_entry
));
395 /* if line table does not start with a function beginning, copy up until
399 if (oldLineTb
->item
[0].line
!= 0)
401 newline
< oldLineTb
->nitems
&& oldLineTb
->item
[newline
].line
; ++newline
)
402 newLineTb
->item
[newline
] = oldLineTb
->item
[newline
];
404 /* Now copy function lines one by one. */
406 for (ii
=0; ii
< function_count
; ++ii
) {
407 for (jj
= fentry
[ii
].line
+ 1;
408 jj
< oldLineTb
->nitems
&& oldLineTb
->item
[jj
].line
!= 0;
410 newLineTb
->item
[newline
] = oldLineTb
->item
[jj
];
413 newLineTb
->nitems
= oldLineTb
->nitems
- function_count
;
419 /* We try to detect the beginning of a compilation unit. That info will
420 be used as an entry in line number recording routines (enter_line_range) */
422 static unsigned first_fun_line_offset
;
423 static unsigned first_fun_bf
;
425 #define mark_first_line(OFFSET, SYMNUM) \
426 if (!first_fun_line_offset) { \
427 first_fun_line_offset = OFFSET; \
428 first_fun_bf = SYMNUM; \
432 /* include file support: C_BINCL/C_EINCL pairs will be kept in the
433 following `IncludeChain'. At the end of each symtab (end_symtab),
434 we will determine if we should create additional symtab's to
435 represent if (the include files. */
438 typedef struct _inclTable
{
439 char *name
; /* include filename */
441 /* Offsets to the line table. end points to the last entry which is
442 part of this include file. */
445 struct subfile
*subfile
;
446 unsigned funStartLine
; /* start line # of its function */
449 #define INITIAL_INCLUDE_TABLE_LENGTH 20
450 static InclTable
*inclTable
; /* global include table */
451 static int inclIndx
; /* last entry to table */
452 static int inclLength
; /* table length */
453 static int inclDepth
; /* nested include depth */
455 static void allocate_include_entry
PARAMS ((void));
458 record_include_begin (cs
)
459 struct coff_symbol
*cs
;
463 /* In xcoff, we assume include files cannot be nested (not in .c files
464 of course, but in corresponding .s files.). */
466 /* This can happen with old versions of GCC.
467 GCC 2.3.3-930426 does not exhibit this on a test case which
468 a user said produced the message for him. */
469 static struct complaint msg
= {"Nested C_BINCL symbols", 0, 0};
474 allocate_include_entry ();
476 inclTable
[inclIndx
].name
= cs
->c_name
;
477 inclTable
[inclIndx
].begin
= cs
->c_value
;
481 record_include_end (cs
)
482 struct coff_symbol
*cs
;
488 static struct complaint msg
= {"Mismatched C_BINCL/C_EINCL pair", 0, 0};
492 allocate_include_entry ();
494 pTbl
= &inclTable
[inclIndx
];
495 pTbl
->end
= cs
->c_value
;
502 allocate_include_entry ()
504 if (inclTable
== NULL
)
506 inclTable
= (InclTable
*)
507 xmalloc (sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
509 '\0', sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
510 inclLength
= INITIAL_INCLUDE_TABLE_LENGTH
;
513 else if (inclIndx
>= inclLength
)
515 inclLength
+= INITIAL_INCLUDE_TABLE_LENGTH
;
516 inclTable
= (InclTable
*)
517 xrealloc (inclTable
, sizeof (InclTable
) * inclLength
);
518 memset (inclTable
+ inclLength
- INITIAL_INCLUDE_TABLE_LENGTH
,
519 '\0', sizeof (InclTable
)*INITIAL_INCLUDE_TABLE_LENGTH
);
523 /* given the start and end addresses of a compilation unit (or a csect,
524 at times) process its lines and create appropriate line vectors. */
527 process_linenos (start
, end
)
528 CORE_ADDR start
, end
;
533 /* subfile structure for the main compilation unit. */
534 struct subfile main_subfile
;
536 /* In the main source file, any time we see a function entry, we
537 reset this variable to function's absolute starting line number.
538 All the following line numbers in the function are relative to
539 this, and we record absolute line numbers in record_line(). */
541 int main_source_baseline
= 0;
546 if (!(offset
= first_fun_line_offset
))
547 goto return_after_cleanup
;
549 memset (&main_subfile
, '\0', sizeof (main_subfile
));
550 first_fun_line_offset
= 0;
553 /* All source lines were in the main source file. None in include files. */
555 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
556 &main_source_baseline
);
560 /* There was source with line numbers in include files. */
561 main_source_baseline
= 0;
562 for (ii
=0; ii
< inclIndx
; ++ii
)
564 struct subfile
*tmpSubfile
;
566 /* If there is main file source before include file, enter it. */
567 if (offset
< inclTable
[ii
].begin
)
570 (&main_subfile
, offset
, inclTable
[ii
].begin
- LINESZ
,
571 start
, 0, &main_source_baseline
);
574 /* Have a new subfile for the include file. */
576 tmpSubfile
= inclTable
[ii
].subfile
=
577 (struct subfile
*) xmalloc (sizeof (struct subfile
));
579 memset (tmpSubfile
, '\0', sizeof (struct subfile
));
580 firstLine
= &(inclTable
[ii
].funStartLine
);
582 /* Enter include file's lines now. */
583 enter_line_range (tmpSubfile
, inclTable
[ii
].begin
,
584 inclTable
[ii
].end
, start
, 0, firstLine
);
586 offset
= inclTable
[ii
].end
+ LINESZ
;
589 /* All the include files' line have been processed at this point. Now,
590 enter remaining lines of the main file, if any left. */
591 if (offset
< (linetab_offset
+ linetab_size
+ 1 - LINESZ
))
593 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
594 &main_source_baseline
);
598 /* Process main file's line numbers. */
599 if (main_subfile
.line_vector
)
601 struct linetable
*lineTb
, *lv
;
603 lv
= main_subfile
.line_vector
;
605 /* Line numbers are not necessarily ordered. xlc compilation will
606 put static function to the end. */
608 lineTb
= arrange_linetable (lv
);
611 current_subfile
->line_vector
= (struct linetable
*)
612 xrealloc (lv
, (sizeof (struct linetable
)
613 + lv
->nitems
* sizeof (struct linetable_entry
)));
618 current_subfile
->line_vector
= lineTb
;
621 current_subfile
->line_vector_length
=
622 current_subfile
->line_vector
->nitems
;
625 /* Now, process included files' line numbers. */
627 for (ii
=0; ii
< inclIndx
; ++ii
)
629 if ((inclTable
[ii
].subfile
)->line_vector
) /* Useless if!!! FIXMEmgo */
631 struct linetable
*lineTb
, *lv
;
633 lv
= (inclTable
[ii
].subfile
)->line_vector
;
635 /* Line numbers are not necessarily ordered. xlc compilation will
636 put static function to the end. */
638 lineTb
= arrange_linetable (lv
);
642 /* For the same include file, we might want to have more than one
643 subfile. This happens if we have something like:
651 while foo.h including code in it. (stupid but possible)
652 Since start_subfile() looks at the name and uses an
653 existing one if finds, we need to provide a fake name and
657 start_subfile (inclTable
[ii
].name
, (char*)0);
660 /* Pick a fake name that will produce the same results as this
661 one when passed to deduce_language_from_filename. Kludge on
663 char *fakename
= strrchr (inclTable
[ii
].name
, '.');
664 if (fakename
== NULL
)
666 start_subfile (fakename
, (char*)0);
667 free (current_subfile
->name
);
669 current_subfile
->name
= strdup (inclTable
[ii
].name
);
674 current_subfile
->line_vector
=
675 (struct linetable
*) xrealloc
676 (lv
, (sizeof (struct linetable
)
677 + lv
->nitems
* sizeof (struct linetable_entry
)));
683 current_subfile
->line_vector
= lineTb
;
686 current_subfile
->line_vector_length
=
687 current_subfile
->line_vector
->nitems
;
688 start_subfile (pop_subfile (), (char*)0);
692 return_after_cleanup
:
694 /* We don't want to keep alloc/free'ing the global include file table. */
697 /* Start with a fresh subfile structure for the next file. */
698 memset (&main_subfile
, '\0', sizeof (struct subfile
));
702 aix_process_linenos ()
704 /* process line numbers and enter them into line vector */
705 process_linenos (last_source_start_addr
, cur_src_end_addr
);
709 /* Enter a given range of lines into the line vector.
710 can be called in the following two ways:
711 enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or
712 enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine)
714 endoffset points to the last line table entry that we should pay
718 enter_line_range (subfile
, beginoffset
, endoffset
, startaddr
, endaddr
, firstLine
)
719 struct subfile
*subfile
;
720 unsigned beginoffset
, endoffset
; /* offsets to line table */
721 CORE_ADDR startaddr
, endaddr
;
727 /* Do Byte swapping, if needed. FIXME! */
728 #define P_LINENO(PP) (*(unsigned short*)((struct external_lineno*)(PP))->l_lnno)
729 #define P_LINEADDR(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_paddr)
730 #define P_LINESYM(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_symndx)
732 pp
= &linetab
[beginoffset
- linetab_offset
];
733 if (endoffset
!= 0 && endoffset
- linetab_offset
>= linetab_size
)
735 static struct complaint msg
=
736 {"Bad line table offset in C_EINCL directive", 0, 0};
740 limit
= endoffset
? &linetab
[endoffset
- linetab_offset
]
741 : &linetab
[linetab_size
-1];
743 while (pp
<= limit
) {
745 /* find the address this line represents */
746 addr
= P_LINENO(pp
) ?
747 P_LINEADDR(pp
) : read_symbol_nvalue (P_LINESYM(pp
));
749 if (addr
< startaddr
|| (endaddr
&& addr
>= endaddr
))
752 if (P_LINENO(pp
) == 0) {
753 *firstLine
= read_symbol_lineno (P_LINESYM(pp
));
754 record_line (subfile
, 0, addr
);
758 record_line (subfile
, *firstLine
+ P_LINENO(pp
), addr
);
765 int fsize
; /* file size */
766 int fixedparms
; /* number of fixed parms */
767 int floatparms
; /* number of float parms */
768 unsigned int parminfo
; /* parameter info.
769 See /usr/include/sys/debug.h
770 tbtable_ext.parminfo */
771 int framesize
; /* function frame size */
775 /* Given a function symbol, return its traceback information. */
778 retrieve_tracebackinfo (abfd
, textsec
, cs
)
781 struct coff_symbol
*cs
;
783 #define TBTABLE_BUFSIZ 2000
785 static TracebackInfo tbInfo
;
788 static char buffer
[TBTABLE_BUFSIZ
];
791 int bytesread
=0; /* total # of bytes read so far */
792 int bufferbytes
; /* number of bytes in the buffer */
794 int functionstart
= cs
->c_value
- textsec
->vma
;
796 memset (&tbInfo
, '\0', sizeof (tbInfo
));
798 /* keep reading blocks of data from the text section, until finding a zero
799 word and a traceback table. */
801 /* Note: The logical thing way to write this code would be to assign
802 to bufferbytes within the while condition. But that triggers a
803 compiler (xlc in AIX 3.2) bug, so simplify it... */
805 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
806 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
808 && (bfd_get_section_contents
809 (abfd
, textsec
, buffer
,
810 (file_ptr
)(functionstart
+ bytesread
), bufferbytes
)))
812 bytesread
+= bufferbytes
;
813 pinsn
= (int*) buffer
;
815 /* if this is the first time we filled the buffer, retrieve function
818 if (bytesread
== bufferbytes
) {
820 /* skip over unrelated instructions */
822 if (*pinsn
== 0x7c0802a6) /* mflr r0 */
824 if ((*pinsn
& 0xfc00003e) == 0x7c000026) /* mfcr Rx */
826 if ((*pinsn
& 0xfc000000) == 0x48000000) /* bl foo, save fprs */
828 if ((*pinsn
& 0xfc1f0000) == 0xbc010000) /* stm Rx, NUM(r1) */
832 int tmp
= (*pinsn
>> 16) & 0xffff;
834 if (tmp
== 0x9421) { /* stu r1, NUM(r1) */
835 tbInfo
.framesize
= 0x10000 - (*pinsn
& 0xffff);
838 else if ((*pinsn
== 0x93e1fffc) || /* st r31,-4(r1) */
839 (tmp
== 0x9001)) /* st r0, NUM(r1) */
841 /* else, could not find a frame size. */
845 } while (++pinsn
&& *pinsn
);
847 if (!tbInfo
.framesize
)
852 /* look for a zero word. */
854 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
857 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
862 /* function size is the amount of bytes we have skipped so far. */
863 tbInfo
.fsize
= bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
);
867 /* if we don't have the whole traceback table in the buffer, re-read
870 /* This is how much to read to get the traceback table.
871 8 bytes of the traceback table are always present, plus we
873 #define MIN_TBTABSIZ 12
875 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
877 /* In case if we are *very* close to the end of the text section
878 and cannot read properly from that point on, abort by returning
881 This could happen if the traceback table is only 8 bytes,
882 but we try to read 12 bytes of it.
883 Handle this case more graciously -- FIXME */
885 if (!bfd_get_section_contents (
886 abfd
, textsec
, buffer
,
887 (file_ptr
)(functionstart
+
888 bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
)),MIN_TBTABSIZ
))
889 { printf_unfiltered ("Abnormal return!..\n"); return NULL
; }
891 ptb
= (struct tbtable
*)buffer
;
894 ptb
= (struct tbtable
*)pinsn
;
896 tbInfo
.fixedparms
= ptb
->tb
.fixedparms
;
897 tbInfo
.floatparms
= ptb
->tb
.floatparms
;
898 tbInfo
.parminfo
= ptb
->tb_ext
.parminfo
;
902 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
) ?
903 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
));
909 /* Given a function symbol, return a pointer to its traceback table. */
912 retrieve_traceback (abfd
, textsec
, cs
, size
)
915 struct coff_symbol
*cs
;
916 int *size
; /* return function size */
918 #define TBTABLE_BUFSIZ 2000
919 #define MIN_TBTABSIZ 50 /* minimum buffer size to hold a
922 static char buffer
[TBTABLE_BUFSIZ
];
925 int bytesread
=0; /* total # of bytes read so far */
926 int bufferbytes
; /* number of bytes in the buffer */
928 int functionstart
= cs
->c_value
- textsec
->filepos
+ textsec
->vma
;
931 /* keep reading blocks of data from the text section, until finding a zero
932 word and a traceback table. */
934 while (bfd_get_section_contents (abfd
, textsec
, buffer
,
935 (file_ptr
)(functionstart
+ bytesread
),
937 (TBTABLE_BUFSIZ
< (textsec
->size
- functionstart
- bytesread
)) ?
938 TBTABLE_BUFSIZ
: (textsec
->size
- functionstart
- bytesread
))))
940 bytesread
+= bufferbytes
;
941 pinsn
= (int*) buffer
;
943 /* look for a zero word. */
945 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
948 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
953 /* function size is the amount of bytes we have skipped so far. */
954 *size
= bytesread
- (buffer
+ bufferbytes
- pinsn
);
958 /* if we don't have the whole traceback table in the buffer, re-read
961 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
963 /* In case if we are *very* close to the end of the text section
964 and cannot read properly from that point on, abort for now.
965 Handle this case more graciously -- FIXME */
967 if (!bfd_get_section_contents (
968 abfd
, textsec
, buffer
,
969 (file_ptr
)(functionstart
+
970 bytesread
- (buffer
+ bufferbytes
- pinsn
)),MIN_TBTABSIZ
))
971 /* abort (); */ { printf_unfiltered ("abort!!!\n"); return NULL
; }
973 return (struct tbtable
*)buffer
;
976 return (struct tbtable
*)pinsn
;
986 /* Save the vital information for use when closing off the current file.
987 NAME is the file name the symbols came from, START_ADDR is the first
988 text address for the file, and SIZE is the number of bytes of text. */
990 #define complete_symtab(name, start_addr) { \
991 last_source_file = savestring (name, strlen (name)); \
992 last_source_start_addr = start_addr; \
996 /* Refill the symbol table input buffer
997 and set the variables that control fetching entries from it.
998 Reports an error if no data available.
999 This function can read past the end of the symbol table
1000 (into the string table) but this does no harm. */
1002 /* Reading symbol table has to be fast! Keep the followings as macros, rather
1005 #define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, ALLOCED, SECTION, OBJFILE) \
1009 if (namestr[0] == '.') ++namestr; \
1011 (NAME) = namestr = \
1012 obstack_copy0 (&objfile->symbol_obstack, namestr, strlen (namestr)); \
1015 prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \
1016 (char *)NULL, (SECTION), (OBJFILE)); \
1017 misc_func_recorded = 1; \
1021 /* A parameter template, used by ADD_PARM_TO_PENDING. It is initialized
1022 in our initializer function at the bottom of the file, to avoid
1023 dependencies on the exact "struct symbol" format. */
1025 static struct symbol parmsym
;
1027 /* Add a parameter to a given pending symbol list. */
1029 #define ADD_PARM_TO_PENDING(PARM, VALUE, PTYPE, PENDING_SYMBOLS) \
1031 PARM = (struct symbol *) \
1032 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1033 *(PARM) = parmsym; \
1034 SYMBOL_TYPE (PARM) = PTYPE; \
1035 SYMBOL_VALUE (PARM) = VALUE; \
1036 add_symbol_to_list (PARM, &PENDING_SYMBOLS); \
1040 /* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
1041 nested. At any given time, a symbol can only be in one static block.
1042 This is the base address of current static block, zero if non exists. */
1044 static int static_block_base
= 0;
1046 /* Section number for the current static block. */
1048 static int static_block_section
= -1;
1050 /* true if space for symbol name has been allocated. */
1052 static int symname_alloced
= 0;
1054 /* Next symbol to read. Pointer into raw seething symbol table. */
1056 static char *raw_symbol
;
1058 /* This is the function which stabsread.c calls to get symbol
1061 xcoff_next_symbol_text ()
1063 struct internal_syment symbol
;
1064 static struct complaint msg
=
1065 {"Unexpected symbol continuation", 0, 0};
1068 bfd_coff_swap_sym_in (current_objfile
->obfd
, raw_symbol
, &symbol
);
1069 if (symbol
.n_zeroes
)
1073 /* Return something which points to '\0' and hope the symbol reading
1074 code does something reasonable. */
1077 else if (symbol
.n_sclass
& 0x80)
1079 retval
= debugsec
+ symbol
.n_offset
;
1080 raw_symbol
+= coff_data (current_objfile
->obfd
)->local_symesz
;
1087 /* Return something which points to '\0' and hope the symbol reading
1088 code does something reasonable. */
1094 /* read the whole symbol table of a given bfd. */
1097 read_xcoff_symtab (objfile
, nsyms
)
1098 struct objfile
*objfile
; /* Object file we're reading from */
1099 int nsyms
; /* # of symbols */
1101 bfd
*abfd
= objfile
->obfd
;
1102 char *raw_auxptr
; /* Pointer to first raw aux entry for sym */
1103 sec_ptr textsec
; /* Pointer to text section */
1104 TracebackInfo
*ptb
; /* Pointer to traceback table */
1106 struct internal_syment symbol
[1];
1107 union internal_auxent main_aux
;
1108 struct coff_symbol cs
[1];
1109 CORE_ADDR file_start_addr
= 0;
1110 CORE_ADDR file_end_addr
= 0;
1112 int next_file_symnum
= -1;
1113 int just_started
= 1;
1115 int toc_offset
= 0; /* toc offset value in data section. */
1119 long fcn_line_offset
;
1122 struct coff_symbol fcn_stab_saved
;
1124 /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
1125 union internal_auxent fcn_aux_saved
;
1126 struct type
*fcn_type_saved
= NULL
;
1127 struct context_stack
*new;
1129 char *filestring
= " _start_ "; /* Name of the current file. */
1131 char *last_csect_name
; /* last seen csect's name and value */
1132 CORE_ADDR last_csect_val
;
1134 int misc_func_recorded
; /* true if any misc. function */
1136 current_objfile
= objfile
;
1138 /* Get the appropriate COFF "constants" related to the file we're
1140 N_TMASK
= coff_data (abfd
)->local_n_tmask
;
1141 N_BTSHFT
= coff_data (abfd
)->local_n_btshft
;
1142 local_symesz
= coff_data (abfd
)->local_symesz
;
1144 last_source_file
= NULL
;
1145 last_csect_name
= 0;
1147 misc_func_recorded
= 0;
1150 start_symtab (filestring
, (char *)NULL
, file_start_addr
);
1152 first_object_file_end
= 0;
1154 /* Allocate space for the entire symbol table at once, and read it
1155 all in. The bfd is already positioned at the beginning of
1156 the symbol table. */
1158 size
= coff_data (abfd
)->local_symesz
* nsyms
;
1159 symtbl
= xmalloc (size
);
1160 symtbl_num_syms
= nsyms
;
1162 val
= bfd_read (symtbl
, size
, 1, abfd
);
1164 perror_with_name ("reading symbol table");
1166 raw_symbol
= symtbl
;
1168 textsec
= bfd_get_section_by_name (abfd
, ".text");
1171 printf_unfiltered ("Unable to locate text section!\n");
1174 next_symbol_text_func
= xcoff_next_symbol_text
;
1176 while (symnum
< nsyms
)
1179 QUIT
; /* make this command interruptable. */
1181 /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
1182 /* read one symbol into `cs' structure. After processing the
1183 whole symbol table, only string table will be kept in memory,
1184 symbol table and debug section of xcoff will be freed. Thus
1185 we can mark symbols with names in string table as
1190 /* Swap and align the symbol into a reasonable C structure. */
1191 bfd_coff_swap_sym_in (abfd
, raw_symbol
, symbol
);
1193 cs
->c_symnum
= symnum
;
1194 cs
->c_naux
= symbol
->n_numaux
;
1195 if (symbol
->n_zeroes
)
1197 symname_alloced
= 0;
1198 /* We must use the original, unswapped, name here so the name field
1199 pointed to by cs->c_name will persist throughout xcoffread. If
1200 we use the new field, it gets overwritten for each symbol. */
1201 cs
->c_name
= ((struct external_syment
*)raw_symbol
)->e
.e_name
;
1202 /* If it's exactly E_SYMNMLEN characters long it isn't
1204 if (cs
->c_name
[E_SYMNMLEN
- 1] != '\0')
1207 p
= obstack_alloc (&objfile
->symbol_obstack
, E_SYMNMLEN
+ 1);
1208 strncpy (p
, cs
->c_name
, E_SYMNMLEN
);
1209 p
[E_SYMNMLEN
] = '\0';
1211 symname_alloced
= 1;
1214 else if (symbol
->n_sclass
& 0x80)
1216 cs
->c_name
= debugsec
+ symbol
->n_offset
;
1217 symname_alloced
= 0;
1221 /* in string table */
1222 cs
->c_name
= strtbl
+ (int)symbol
->n_offset
;
1223 symname_alloced
= 1;
1225 cs
->c_value
= symbol
->n_value
;
1226 cs
->c_sclass
= symbol
->n_sclass
;
1227 cs
->c_secnum
= symbol
->n_scnum
;
1228 cs
->c_type
= (unsigned)symbol
->n_type
;
1230 raw_symbol
+= coff_data (abfd
)->local_symesz
;
1233 /* Save addr of first aux entry. */
1234 raw_auxptr
= raw_symbol
;
1236 /* Skip all the auxents associated with this symbol. */
1237 for (ii
= symbol
->n_numaux
; ii
; --ii
)
1239 raw_symbol
+= coff_data (abfd
)->local_auxesz
;
1244 /* if symbol name starts with ".$" or "$", ignore it. */
1245 if (cs
->c_name
[0] == '$'
1246 || (cs
->c_name
[1] == '$' && cs
->c_name
[0] == '.'))
1249 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
)
1251 if (last_source_file
)
1253 end_symtab (cur_src_end_addr
, 1, 0, objfile
, SECT_OFF_TEXT
);
1258 start_symtab ("_globals_", (char *)NULL
, (CORE_ADDR
)0);
1259 cur_src_end_addr
= first_object_file_end
;
1260 /* done with all files, everything from here on is globals */
1263 /* if explicitly specified as a function, treat is as one. */
1264 if (ISFCN(cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
)
1266 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1267 0, cs
->c_naux
, &main_aux
);
1268 goto function_entry_point
;
1271 if ((cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_HIDEXT
)
1274 /* Dealing with a symbol with a csect entry. */
1276 #define CSECT(PP) ((PP)->x_csect)
1277 #define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
1278 #define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1279 #define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1280 #define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1282 /* Convert the auxent to something we can access. */
1283 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1284 0, cs
->c_naux
, &main_aux
);
1286 switch (CSECT_SMTYP (&main_aux
))
1290 /* Ignore all external references. */
1294 /* A section description. */
1296 switch (CSECT_SCLAS (&main_aux
))
1302 /* A program csect is seen. We have to allocate one
1303 symbol table for each program csect. Normally gdb
1304 prefers one symtab for each source file. In case
1305 of AIX, one source file might include more than one
1306 [PR] csect, and they don't have to be adjacent in
1307 terms of the space they occupy in memory. Thus, one
1308 single source file might get fragmented in the
1309 memory and gdb's file start and end address
1310 approach does not work! GCC (and I think xlc) seem
1311 to put all the code in the unnamed program csect. */
1313 if (last_csect_name
)
1316 /* If no misc. function recorded in the last
1317 seen csect, enter it as a function. This
1318 will take care of functions like strcmp()
1321 if (!misc_func_recorded
)
1324 RECORD_MINIMAL_SYMBOL
1325 (last_csect_name
, last_csect_val
,
1326 mst_text
, alloced
, last_csect_sec
,
1330 complete_symtab (filestring
, file_start_addr
);
1331 cur_src_end_addr
= file_end_addr
;
1332 end_symtab (file_end_addr
, 1, 0, objfile
,
1336 /* Give all csects for this source file the same
1338 start_symtab (filestring
, NULL
, (CORE_ADDR
)0);
1341 /* If this is the very first csect seen,
1342 basically `__start'. */
1345 first_object_file_end
1346 = cs
->c_value
+ CSECT_LEN (&main_aux
);
1350 file_start_addr
= cs
->c_value
;
1351 file_end_addr
= cs
->c_value
+ CSECT_LEN (&main_aux
);
1353 if (cs
->c_name
&& cs
->c_name
[0] == '.')
1355 last_csect_name
= cs
->c_name
;
1356 last_csect_val
= cs
->c_value
;
1357 last_csect_sec
= cs_to_section (cs
, objfile
);
1360 misc_func_recorded
= 0;
1366 /* If the section is not a data description,
1367 ignore it. Note that uninitialized data will
1368 show up as XTY_CM/XMC_RW pair. */
1372 warning ("More than one xmc_tc0 symbol found.");
1373 toc_offset
= cs
->c_value
;
1377 #ifdef STATIC_NODEBUG_VARS
1378 /* We need to process these symbols if they are C_HIDEXT,
1379 for static variables in files compiled without -g. */
1380 if (cs
->c_sclass
== C_HIDEXT
)
1387 /* Ignore the symbol. */
1395 switch (CSECT_SCLAS (&main_aux
))
1398 /* a function entry point. */
1399 function_entry_point
:
1400 RECORD_MINIMAL_SYMBOL
1401 (cs
->c_name
, cs
->c_value
, mst_text
,
1402 symname_alloced
, cs_to_section (cs
, objfile
),
1405 fcn_line_offset
= main_aux
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1406 fcn_start_addr
= cs
->c_value
;
1408 /* save the function header info, which will be used
1409 when `.bf' is seen. */
1411 fcn_aux_saved
= main_aux
;
1415 /* If function has two auxent, then debugging information is
1416 already available for it. Process traceback table for
1417 functions with only one auxent. */
1419 if (cs
->c_naux
== 1)
1420 ptb
= retrieve_tracebackinfo (abfd
, textsec
, cs
);
1422 else if (cs
->c_naux
!= 2)
1424 static struct complaint msg
=
1425 {"Expected one or two auxents for function", 0, 0};
1429 /* If there is traceback info, create and add parameters
1432 if (ptb
&& (ptb
->fixedparms
|| ptb
->floatparms
))
1435 int parmcnt
= ptb
->fixedparms
+ ptb
->floatparms
;
1436 char *parmcode
= (char*) &ptb
->parminfo
;
1438 /* The link area is 0x18 bytes. */
1439 int parmvalue
= ptb
->framesize
+ 0x18;
1440 unsigned int ii
, mask
;
1442 for (ii
=0, mask
= 0x80000000; ii
<parmcnt
; ++ii
)
1444 struct symbol
*parm
;
1446 if (ptb
->parminfo
& mask
)
1448 /* float or double */
1450 if (ptb
->parminfo
& mask
)
1454 (parm
, parmvalue
, builtin_type_double
,
1456 parmvalue
+= sizeof (double);
1462 (parm
, parmvalue
, builtin_type_float
,
1464 parmvalue
+= sizeof (float);
1469 static struct type
*intparm_type
;
1470 if (intparm_type
== NULL
)
1473 /* Create a type, which is a pointer
1474 type (a kludge to make it print
1475 in hex), but which has a name
1476 indicating we don't know the real
1482 TARGET_PTR_BIT
/ HOST_CHAR_BIT
,
1484 "<non-float parameter>",
1486 TYPE_TARGET_TYPE (intparm_type
) =
1493 parmvalue
+= sizeof (int);
1498 /* Fake this as a function. Needed in
1499 process_xcoff_symbol(). */
1503 (process_xcoff_symbol (cs
, objfile
), &local_symbols
,
1504 pending_blocks
, cs
->c_value
,
1505 cs
->c_value
+ ptb
->fsize
, objfile
);
1510 /* shared library function trampoline code entry point. */
1512 /* record trampoline code entries as
1513 mst_solib_trampoline symbol. When we lookup mst
1514 symbols, we will choose mst_text over
1515 mst_solib_trampoline. */
1516 RECORD_MINIMAL_SYMBOL
1517 (cs
->c_name
, cs
->c_value
,
1518 mst_solib_trampoline
,
1519 symname_alloced
, cs_to_section (cs
, objfile
), objfile
);
1523 /* The symbols often have the same names as debug symbols for
1524 functions, and confuse lookup_symbol. */
1528 /* xlc puts each variable in a separate csect, so we get
1529 an XTY_SD for each variable. But gcc puts several
1530 variables in a csect, so that each variable only gets
1531 an XTY_LD. We still need to record them. This will
1532 typically be XMC_RW; I suspect XMC_RO and XMC_BS might
1542 switch (cs
->c_sclass
)
1547 /* see if the last csect needs to be recorded. */
1549 if (last_csect_name
&& !misc_func_recorded
)
1552 /* If no misc. function recorded in the last seen csect, enter
1553 it as a function. This will take care of functions like
1554 strcmp() compiled by xlc. */
1557 RECORD_MINIMAL_SYMBOL
1558 (last_csect_name
, last_csect_val
,
1559 mst_text
, alloced
, last_csect_sec
, objfile
);
1562 /* c_value field contains symnum of next .file entry in table
1563 or symnum of first global after last .file. */
1565 next_file_symnum
= cs
->c_value
;
1567 /* Complete symbol table for last object file containing
1568 debugging information. */
1570 /* Whether or not there was a csect in the previous file, we
1571 have to call `end_stabs' and `start_stabs' to reset
1572 type_vector, line_vector, etc. structures. */
1574 complete_symtab (filestring
, file_start_addr
);
1575 cur_src_end_addr
= file_end_addr
;
1576 end_symtab (file_end_addr
, 1, 0, objfile
, SECT_OFF_TEXT
);
1579 /* XCOFF, according to the AIX 3.2 documentation, puts the filename
1580 in cs->c_name. But xlc 1.3.0.2 has decided to do things the
1581 standard COFF way and put it in the auxent. We use the auxent if
1582 the symbol is ".file" and an auxent exists, otherwise use the symbol
1583 itself. Simple enough. */
1584 if (!strcmp (cs
->c_name
, ".file") && cs
->c_naux
> 0)
1586 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1587 0, cs
->c_naux
, &main_aux
);
1588 filestring
= coff_getfilename (&main_aux
);
1591 filestring
= cs
->c_name
;
1594 start_symtab (filestring
, (char *)NULL
, (CORE_ADDR
)0);
1595 last_csect_name
= 0;
1597 /* reset file start and end addresses. A compilation unit with no text
1598 (only data) should have zero file boundaries. */
1599 file_start_addr
= file_end_addr
= 0;
1603 fcn_stab_saved
= *cs
;
1607 if (STREQ (cs
->c_name
, ".bf"))
1610 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1611 0, cs
->c_naux
, &main_aux
);
1613 within_function
= 1;
1615 mark_first_line (fcn_line_offset
, cs
->c_symnum
);
1617 new = push_context (0, fcn_start_addr
);
1619 new->name
= define_symbol
1620 (fcn_cs_saved
.c_value
, fcn_stab_saved
.c_name
, 0, 0, objfile
);
1621 if (new->name
!= NULL
)
1622 SYMBOL_SECTION (new->name
) = cs_to_section (cs
, objfile
);
1624 else if (STREQ (cs
->c_name
, ".ef"))
1627 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1628 0, cs
->c_naux
, &main_aux
);
1630 /* The value of .ef is the address of epilogue code;
1631 not useful for gdb. */
1632 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1633 contains number of lines to '}' */
1635 fcn_last_line
= main_aux
.x_sym
.x_misc
.x_lnsz
.x_lnno
;
1636 new = pop_context ();
1637 /* Stack must be empty now. */
1638 if (context_stack_depth
> 0 || new == NULL
)
1640 complain (&ef_complaint
, cs
->c_symnum
);
1641 within_function
= 0;
1645 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1647 fcn_cs_saved
.c_value
+
1648 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
, objfile
);
1649 within_function
= 0;
1654 /* Begin static block. */
1656 struct internal_syment symbol
;
1657 struct coff_symbol csymbol
;
1659 read_symbol (&symbol
, cs
->c_value
);
1660 static_block_base
= symbol
.n_value
;
1661 csymbol
.c_secnum
= symbol
.n_scnum
;
1662 static_block_section
= cs_to_section (&csymbol
, objfile
);
1667 /* End of static block. */
1668 static_block_base
= 0;
1669 static_block_section
= -1;
1680 static struct complaint msg
=
1681 {"Unrecognized storage class %d.", 0, 0};
1682 complain (&msg
, cs
->c_sclass
);
1691 /* This is wrong. These symbols are XMC_TC, which means that
1692 the value of the symbol is the address of the TOC entry, not
1693 the address of the variable itself. */
1695 #ifdef STATIC_NODEBUG_VARS
1697 /* This is the only place that static variables show up in files
1698 compiled without -g. External variables also have a C_EXT,
1699 so that is why we record everything as mst_file_* here. */
1700 enum minimal_symbol_type ms_type
;
1704 sec
= cs_to_section (cs
, objfile
);
1705 tmpaddr
= cs
->c_value
;
1710 case SECT_OFF_RODATA
:
1711 ms_type
= mst_file_text
;
1714 ms_type
= mst_file_data
;
1717 ms_type
= mst_file_bss
;
1720 ms_type
= mst_unknown
;
1723 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
, ms_type
,
1724 symname_alloced
, sec
, objfile
);
1726 #endif /* STATIC_NODEBUG_VARS */
1730 /* beginning of include file */
1731 /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1732 order. Thus, when wee see them, we might not know enough info
1733 to process them. Thus, we'll be saving them into a table
1734 (inclTable) and postpone their processing. */
1736 record_include_begin (cs
);
1740 /* End of include file. */
1741 /* See the comment after case C_BINCL. */
1742 record_include_end (cs
);
1746 if (STREQ (cs
->c_name
, ".bb"))
1749 new = push_context (depth
, cs
->c_value
);
1751 else if (STREQ (cs
->c_name
, ".eb"))
1753 new = pop_context ();
1754 if (depth
-- != new->depth
)
1756 complain (&eb_complaint
, symnum
);
1759 if (local_symbols
&& context_stack_depth
> 0)
1761 /* Make a block for the local symbols within. */
1762 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1763 new->start_addr
, cs
->c_value
, objfile
);
1765 local_symbols
= new->locals
;
1770 process_xcoff_symbol (cs
, objfile
);
1775 if (last_source_file
)
1777 end_symtab (cur_src_end_addr
, 1, 0, objfile
, SECT_OFF_TEXT
);
1782 current_objfile
= NULL
;
1784 /* Record the toc offset value of this symbol table into ldinfo structure.
1785 If no XMC_TC0 is found, toc_offset should be zero. Another place to obtain
1786 this information would be file auxiliary header. */
1788 #ifndef FAKING_RS6000
1789 xcoff_add_toc_to_loadinfo (toc_offset
);
1793 #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1794 (SYMBOL2) = (struct symbol *) \
1795 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1796 *(SYMBOL2) = *(SYMBOL1);
1799 #define SYMNAME_ALLOC(NAME, ALLOCED) \
1800 (ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME));
1803 static struct type
*func_symbol_type
;
1804 static struct type
*var_symbol_type
;
1806 /* process one xcoff symbol. */
1808 static struct symbol
*
1809 process_xcoff_symbol (cs
, objfile
)
1810 register struct coff_symbol
*cs
;
1811 struct objfile
*objfile
;
1813 struct symbol onesymbol
;
1814 register struct symbol
*sym
= &onesymbol
;
1815 struct symbol
*sym2
= NULL
;
1817 char *name
, *pp
, *qq
;
1818 int struct_and_type_combined
;
1825 memset (sym
, '\0', sizeof (struct symbol
));
1827 /* default assumptions */
1828 SYMBOL_VALUE (sym
) = cs
->c_value
;
1829 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1830 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1832 if (ISFCN (cs
->c_type
))
1834 /* At this point, we don't know the type of the function. This
1835 will be patched with the type from its stab entry later on in
1836 patch_block_stabs (), unless the file was compiled without -g. */
1838 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1839 SYMBOL_TYPE (sym
) = func_symbol_type
;
1841 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1842 SYMBOL_DUP (sym
, sym2
);
1844 if (cs
->c_sclass
== C_EXT
)
1845 add_symbol_to_list (sym2
, &global_symbols
);
1846 else if (cs
->c_sclass
== C_HIDEXT
|| cs
->c_sclass
== C_STAT
)
1847 add_symbol_to_list (sym2
, &file_symbols
);
1851 /* In case we can't figure out the type, provide default. */
1852 SYMBOL_TYPE (sym
) = var_symbol_type
;
1854 switch (cs
->c_sclass
)
1858 if (fcn_cs_saved
.c_sclass
== C_EXT
)
1859 add_stab_to_list (name
, &global_stabs
);
1861 add_stab_to_list (name
, &file_stabs
);
1866 add_stab_to_list (name
, &global_stabs
);
1870 common_block_start (cs
->c_name
, objfile
);
1874 common_block_end (objfile
);
1878 complain (&storclass_complaint
, cs
->c_sclass
);
1886 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1889 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1895 /* For xlc (not GCC), the 'V' symbol descriptor is used for
1896 all statics and we need to distinguish file-scope versus
1897 function-scope using within_function. We do this by
1898 changing the string we pass to define_symbol to use 'S'
1899 where we need to, which is not necessarily super-clean,
1900 but seems workable enough. */
1902 if (*name
== ':' || (pp
= (char *) strchr(name
, ':')) == NULL
)
1906 if (*pp
== 'V' && !within_function
)
1908 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1911 SYMBOL_VALUE (sym
) += static_block_base
;
1912 SYMBOL_SECTION (sym
) = static_block_section
;
1917 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, N_LSYM
, objfile
);
1920 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1925 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1926 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1927 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1928 SYMBOL_DUP (sym
, sym2
);
1929 add_symbol_to_list (sym2
, &local_symbols
);
1933 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1934 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1935 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1936 SYMBOL_DUP (sym
, sym2
);
1937 add_symbol_to_list (sym2
, &global_symbols
);
1941 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1942 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1943 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1944 SYMBOL_DUP (sym
, sym2
);
1946 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1950 pp
= (char*) strchr (name
, ':');
1953 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1955 SYMBOL_SECTION (sym
) = cs_to_section (cs
, objfile
);
1960 complain (&rsym_complaint
, name
);
1968 /* Extract the file name from the aux entry of a C_FILE symbol. Return
1969 only the last component of the name. Result is in static storage and
1970 is only good for temporary use. */
1973 coff_getfilename (aux_entry
)
1974 union internal_auxent
*aux_entry
;
1976 static char buffer
[BUFSIZ
];
1977 register char *temp
;
1980 if (aux_entry
->x_file
.x_n
.x_zeroes
== 0)
1981 strcpy (buffer
, strtbl
+ aux_entry
->x_file
.x_n
.x_offset
);
1984 strncpy (buffer
, aux_entry
->x_file
.x_fname
, FILNMLEN
);
1985 buffer
[FILNMLEN
] = '\0';
1989 /* FIXME: We should not be throwing away the information about what
1990 directory. It should go into dirname of the symtab, or some such
1992 if ((temp
= strrchr (result
, '/')) != NULL
)
1997 /* Set *SYMBOL to symbol number symno in symtbl. */
1999 read_symbol (symbol
, symno
)
2000 struct internal_syment
*symbol
;
2003 if (symno
< 0 || symno
>= symtbl_num_syms
)
2005 static struct complaint msg
=
2006 {"Invalid symbol offset", 0, 0};
2008 symbol
->n_value
= 0;
2009 symbol
->n_scnum
= -1;
2012 bfd_coff_swap_sym_in (symfile_bfd
, symtbl
+ (symno
*local_symesz
), symbol
);
2015 /* Get value corresponding to symbol number symno in symtbl. */
2018 read_symbol_nvalue (symno
)
2021 struct internal_syment symbol
[1];
2023 read_symbol (symbol
, symno
);
2024 return symbol
->n_value
;
2028 /* Find the address of the function corresponding to symno, where
2029 symno is the symbol pointed to by the linetable. */
2032 read_symbol_lineno (symno
)
2035 struct internal_syment symbol
[1];
2036 union internal_auxent main_aux
[1];
2038 /* Note that just searching for a short distance (e.g. 50 symbols)
2039 is not enough, at least in the following case.
2042 [many .stabx entries]
2043 [a few functions, referring to foo]
2047 What happens here is that the assembler moves the .stabx entries
2048 to right before the ".bf" for foo, but the symbol for "foo" is before
2049 all the stabx entries. See PR gdb/2222. */
2050 while (symno
< symtbl_num_syms
) {
2051 bfd_coff_swap_sym_in (symfile_bfd
,
2052 symtbl
+ (symno
*local_symesz
), symbol
);
2053 if (symbol
->n_sclass
== C_FCN
&& STREQ (symbol
->n_name
, ".bf"))
2055 symno
+= symbol
->n_numaux
+1;
2058 complain (&bf_notfound_complaint
);
2062 /* take aux entry and return its lineno */
2064 bfd_coff_swap_aux_in (symfile_bfd
, symtbl
+(symno
*local_symesz
),
2065 symbol
->n_type
, symbol
->n_sclass
,
2066 0, symbol
->n_numaux
, main_aux
);
2068 return main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2071 /* Support for line number handling */
2073 /* This function is called for every section; it finds the outer limits
2074 * of the line table (minimum and maximum file offset) so that the
2075 * mainline code can read the whole thing for efficiency.
2078 find_linenos(abfd
, asect
, vpinfo
)
2083 struct coff_symfile_info
*info
;
2085 file_ptr offset
, maxoff
;
2087 count
= asect
->lineno_count
;
2089 if (!STREQ (asect
->name
, ".text") || count
== 0)
2092 size
= count
* coff_data (symfile_bfd
)->local_linesz
;
2093 info
= (struct coff_symfile_info
*)vpinfo
;
2094 offset
= asect
->line_filepos
;
2095 maxoff
= offset
+ size
;
2097 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
2098 info
->min_lineno_offset
= offset
;
2100 if (maxoff
> info
->max_lineno_offset
)
2101 info
->max_lineno_offset
= maxoff
;
2105 /* Read in all the line numbers for fast lookups later. Leave them in
2106 external (unswapped) format in memory; we'll swap them as we enter
2107 them into GDB's data structures. */
2110 init_lineno (abfd
, offset
, size
)
2119 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
2122 linetab
= (char *) xmalloc(size
);
2124 val
= bfd_read(linetab
, 1, size
, abfd
);
2128 linetab_offset
= offset
;
2129 linetab_size
= size
;
2142 xcoff_new_init (objfile
)
2143 struct objfile
*objfile
;
2148 /* xcoff_symfile_init()
2149 is the xcoff-specific initialization routine for reading symbols.
2150 It is passed an objfile which contains, among other things,
2151 the BFD for the file whose symbols are being read, and a slot for
2152 a pointer to "private data" which we fill with cookies and other
2153 treats for xcoff_symfile_read().
2155 We will only be called if this is an XCOFF or XCOFF-like file.
2156 BFD handles figuring out the format of the file, and code in symfile.c
2157 uses BFD's determination to vector to us.
2159 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
2162 xcoff_symfile_init (objfile
)
2163 struct objfile
*objfile
;
2165 bfd
*abfd
= objfile
->obfd
;
2167 /* Allocate struct to keep track of the symfile */
2168 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
2169 sizeof (struct coff_symfile_info
));
2170 init_entry_point_info (objfile
);
2173 /* Perform any local cleanups required when we are done with a particular
2174 objfile. I.E, we are in the process of discarding all symbol information
2175 for an objfile, freeing up all memory held for it, and unlinking the
2176 objfile struct from the global list of known objfiles. */
2179 xcoff_symfile_finish (objfile
)
2180 struct objfile
*objfile
;
2182 if (objfile
-> sym_private
!= NULL
)
2184 mfree (objfile
-> md
, objfile
-> sym_private
);
2187 /* Start with a fresh include table for the next objfile. */
2194 inclIndx
= inclLength
= inclDepth
= 0;
2199 init_stringtab(abfd
, offset
, objfile
)
2202 struct objfile
*objfile
;
2206 unsigned char lengthbuf
[4];
2208 if (bfd_seek(abfd
, offset
, L_SET
) < 0)
2211 val
= bfd_read((char *)lengthbuf
, 1, sizeof lengthbuf
, abfd
);
2212 length
= bfd_h_get_32(abfd
, lengthbuf
);
2214 /* If no string table is needed, then the file may end immediately
2215 after the symbols. Just return with `strtbl' set to null. */
2217 if (val
!= sizeof length
|| length
< sizeof length
)
2220 /* Allocate string table from symbol_obstack. We will need this table
2221 as long as we have its symbol table around. */
2223 strtbl
= (char*) obstack_alloc (&objfile
->symbol_obstack
, length
);
2227 memcpy(strtbl
, &length
, sizeof length
);
2228 if (length
== sizeof length
)
2231 val
= bfd_read(strtbl
+ sizeof length
, 1, length
- sizeof length
, abfd
);
2233 if (val
!= length
- sizeof length
|| strtbl
[length
- 1] != '\0')
2240 init_debugsection(abfd
)
2243 register sec_ptr secp
;
2244 bfd_size_type length
;
2251 secp
= bfd_get_section_by_name(abfd
, ".debug");
2255 if (!(length
= bfd_section_size(abfd
, secp
)))
2258 debugsec
= (char *) xmalloc ((unsigned)length
);
2259 if (debugsec
== NULL
)
2262 if (!bfd_get_section_contents(abfd
, secp
, debugsec
, (file_ptr
) 0, length
)) {
2263 printf_unfiltered ("Can't read .debug section from symbol file\n");
2278 /* xcoff version of symbol file read. */
2281 xcoff_symfile_read (objfile
, section_offset
, mainline
)
2282 struct objfile
*objfile
;
2283 struct section_offsets
*section_offset
;
2286 int num_symbols
; /* # of symbols */
2287 file_ptr symtab_offset
; /* symbol table and */
2288 file_ptr stringtab_offset
; /* string table file offsets */
2291 struct coff_symfile_info
*info
;
2293 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2295 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
2296 symfile_bfd
= abfd
= objfile
->obfd
;
2297 name
= objfile
->name
;
2299 num_symbols
= bfd_get_symcount (abfd
); /* # of symbols */
2300 symtab_offset
= obj_sym_filepos (abfd
); /* symbol table file offset */
2301 stringtab_offset
= symtab_offset
+
2302 num_symbols
* coff_data(abfd
)->local_symesz
;
2304 info
->min_lineno_offset
= 0;
2305 info
->max_lineno_offset
= 0;
2306 bfd_map_over_sections (abfd
, find_linenos
, info
);
2308 /* FIXME! This stuff should move into symfile_init */
2309 if (info
->min_lineno_offset
!= 0
2310 && info
->max_lineno_offset
> info
->min_lineno_offset
) {
2312 /* only read in the line # table if one exists */
2313 make_cleanup (free_linetab
, 0);
2314 val
= init_lineno(abfd
, info
->min_lineno_offset
,
2315 (int) (info
->max_lineno_offset
- info
->min_lineno_offset
));
2318 error("\"%s\": error reading line numbers\n", name
);
2321 if (num_symbols
> 0)
2323 val
= init_stringtab(abfd
, stringtab_offset
, objfile
);
2325 error ("\"%s\": can't get string table", name
);
2328 if (init_debugsection(abfd
) < 0) {
2329 error ("Error reading .debug section of `%s'\n", name
);
2333 /* Position to read the symbol table. Do not read it all at once. */
2334 val
= bfd_seek(abfd
, symtab_offset
, L_SET
);
2336 perror_with_name(name
);
2338 if (bfd_tell(abfd
) != symtab_offset
)
2341 init_minimal_symbol_collection ();
2342 make_cleanup (discard_minimal_symbols
, 0);
2344 #ifndef FAKING_RS6000
2345 /* Initialize load info structure. */
2347 xcoff_init_loadinfo ();
2350 /* Now that the executable file is positioned at symbol table,
2351 process it and define symbols accordingly. */
2353 read_xcoff_symtab(objfile
, num_symbols
);
2355 /* Free debug section. */
2356 free_debugsection ();
2358 /* Sort symbols alphabetically within each block. */
2361 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
2363 sort_symtab_syms (s
);
2367 /* Install any minimal symbols that have been collected as the current
2368 minimal symbols for this objfile. */
2370 install_minimal_symbols (objfile
);
2372 do_cleanups (back_to
);
2375 static struct section_offsets
*
2376 xcoff_symfile_offsets (objfile
, addr
)
2377 struct objfile
*objfile
;
2380 struct section_offsets
*section_offsets
;
2383 objfile
->num_sections
= SECT_OFF_MAX
;
2384 section_offsets
= (struct section_offsets
*)
2386 (&objfile
-> psymbol_obstack
,
2387 sizeof (struct section_offsets
)
2388 + sizeof (section_offsets
->offsets
) * objfile
->num_sections
);
2390 /* syms_from_objfile kindly subtracts from addr the bfd_section_vma
2391 of the .text section. This strikes me as wrong--whether the
2392 offset to be applied to symbol reading is relative to the start
2393 address of the section depends on the symbol format. In any
2394 event, this whole "addr" concept is pretty broken (it doesn't
2395 handle any section but .text sensibly), so just ignore the addr
2396 parameter and use 0. That matches the fact that xcoff_symfile_read
2397 ignores the section_offsets). */
2398 for (i
= 0; i
< objfile
->num_sections
; ++i
)
2399 ANOFFSET (section_offsets
, i
) = 0;
2401 return section_offsets
;
2404 /* Register our ability to parse symbols for xcoff BFD files. */
2406 static struct sym_fns xcoff_sym_fns
=
2409 /* Because the bfd uses coff_flavour, we need to specially kludge
2410 the flavour. It is possible that coff and xcoff should be merged as
2411 they do have fundamental similarities (for example, the extra storage
2412 classes used for stabs could presumably be recognized in any COFF file).
2413 However, in addition to obvious things like all the csect hair, there are
2414 some subtler differences between xcoffread.c and coffread.c, notably
2415 the fact that coffread.c has no need to read in all the symbols, but
2416 xcoffread.c reads all the symbols and does in fact randomly access them
2417 (in C_BSTAT and B_BINCL processing). */
2419 (enum bfd_flavour
)-1,
2421 xcoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2422 xcoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2423 xcoff_symfile_read
, /* sym_read: read a symbol file into symtab */
2424 xcoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2425 xcoff_symfile_offsets
, /* sym_offsets: xlate offsets ext->int form */
2426 NULL
/* next: pointer to next struct sym_fns */
2430 _initialize_xcoffread ()
2432 add_symtab_fns(&xcoff_sym_fns
);
2434 /* Initialize symbol template later used for arguments. Its other
2435 fields are zero, or are filled in later. */
2436 SYMBOL_NAME (&parmsym
) = "";
2437 SYMBOL_INIT_LANGUAGE_SPECIFIC (&parmsym
, language_c
);
2438 SYMBOL_NAMESPACE (&parmsym
) = VAR_NAMESPACE
;
2439 SYMBOL_CLASS (&parmsym
) = LOC_ARG
;
2441 func_symbol_type
= init_type (TYPE_CODE_FUNC
, 1, 0,
2442 "<function, no debug info>", NULL
);
2443 TYPE_TARGET_TYPE (func_symbol_type
) = builtin_type_int
;
2445 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
2446 "<variable, no debug info>", NULL
);