1 /* Read AIXcoff symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1986-1991 Free Software Foundation, Inc.
3 Derived from coffread.c, dbxread.c, and a lot of hacking.
4 Contributed by IBM Corporation.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 /* Native only: Need struct tbtable in <sys/debug.h>. */
28 /* AIX COFF names have a preceeding dot `.' */
29 #define NAMES_HAVE_DOT 1
31 #include <sys/types.h>
36 #include <sys/param.h>
41 #include <sys/debug.h>
49 #include "coff/internal.h" /* FIXME, internal data from BFD */
50 #include "libcoff.h" /* FIXME, internal data from BFD */
51 #include "coff/rs6000.h" /* FIXME, raw file-format guts of xcoff */
54 /* Define this if you want gdb use the old xcoff symbol processing. This
55 way it won't use common `define_symbol()' function and Sun dbx stab
56 string grammar. And likely it won't be able to do G++ debugging. */
58 /* #define NO_DEFINE_SYMBOL 1 */
60 /* Define this if you want gdb to ignore typdef stabs. This was needed for
61 one of Transarc, to reduce the size of the symbol table. Types won't be
62 recognized, but tag names will be. */
64 /* #define NO_TYPES 1 */
66 /* Simplified internal version of coff symbol table information */
70 int c_symnum
; /* symbol number of this entry */
71 int c_nsyms
; /* 0 if syment only, 1 if syment + auxent */
78 /* The COFF line table, in raw form. */
79 static char *linetab
= NULL
; /* Its actual contents */
80 static long linetab_offset
; /* Its offset in the file */
81 static unsigned long linetab_size
; /* Its size */
83 /* last function's saved coff symbol `cs' */
85 static struct coff_symbol fcn_cs_saved
;
87 static bfd
*symfile_bfd
;
89 /* Core address of start and end of text of current source file.
90 This is calculated from the first function seen after a C_FILE
94 static CORE_ADDR cur_src_end_addr
;
96 /* Core address of the end of the first object file. */
98 static CORE_ADDR first_object_file_end
;
100 /* pointer to the string table */
103 /* length of the string table */
104 static int strtbl_len
;
106 /* pointer to debug section */
107 static char *debugsec
;
109 /* pointer to the a.out symbol table */
112 /* initial symbol-table-debug-string vector length */
114 #define INITIAL_STABVECTOR_LENGTH 40
116 struct pending_stabs
*global_stabs
;
119 /* Nonzero if within a function (so symbols should be local,
120 if nothing says specifically). */
124 /* Local variables that hold the shift and mask values for the
125 COFF file that we are currently reading. These come back to us
126 from BFD, and are referenced by their macro names, as well as
127 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
128 macros from ../internalcoff.h . */
130 static unsigned local_n_btshft
;
131 static unsigned local_n_tmask
;
134 #define N_BTSHFT local_n_btshft
136 #define N_TMASK local_n_tmask
138 /* Local variables that hold the sizes in the file of various COFF structures.
139 (We only need to know this to read them from the file -- BFD will then
140 translate the data in them, into `internal_xxx' structs in the right
141 byte order, alignment, etc.) */
143 static unsigned local_symesz
;
146 /* coff_symfile_init()
147 is the coff-specific initialization routine for reading symbols.
148 It is passed a struct sym_fns which contains, among other things,
149 the BFD for the file whose symbols are being read, and a slot for
150 a pointer to "private data" which we fill with cookies and other
151 treats for coff_symfile_read().
153 We will only be called if this is a COFF or COFF-like file.
154 BFD handles figuring out the format of the file, and code in symtab.c
155 uses BFD's determination to vector to us.
157 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
159 struct coff_symfile_info
{
160 file_ptr min_lineno_offset
; /* Where in file lowest line#s are */
161 file_ptr max_lineno_offset
; /* 1+last byte of line#s in file */
166 enter_line_range
PARAMS ((struct subfile
*, unsigned, unsigned,
167 CORE_ADDR
, CORE_ADDR
, unsigned *));
170 free_debugsection
PARAMS ((void));
173 init_debugsection
PARAMS ((bfd
*));
176 init_stringtab
PARAMS ((bfd
*, long, struct objfile
*));
179 aixcoff_symfile_init
PARAMS ((struct objfile
*));
182 aixcoff_new_init
PARAMS ((struct objfile
*));
185 aixcoff_symfile_read
PARAMS ((struct sym_fns
*, CORE_ADDR
, int));
188 aixcoff_symfile_finish
PARAMS ((struct objfile
*));
191 init_lineno
PARAMS ((bfd
*, long, int));
194 find_linenos
PARAMS ((bfd
*, sec_ptr
, PTR
));
197 read_symbol_lineno
PARAMS ((char *, int));
200 read_symbol_nvalue
PARAMS ((char *, int));
202 static struct symbol
*
203 process_xcoff_symbol
PARAMS ((struct coff_symbol
*, struct objfile
*));
206 read_xcoff_symtab
PARAMS ((struct objfile
*, int));
209 add_stab_to_list
PARAMS ((char *, struct pending_stabs
**));
212 sort_syms
PARAMS ((void));
215 compare_symbols
PARAMS ((const void *, const void *));
217 /* Call sort_syms to sort alphabetically
218 the symbols of each block of each symtab. */
221 compare_symbols (s1p
, s2p
)
225 /* Names that are less should come first. */
226 register struct symbol
**s1
= (struct symbol
**) s1p
;
227 register struct symbol
**s2
= (struct symbol
**) s2p
;
228 register int namediff
= strcmp (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
));
232 /* For symbols of the same name, registers should come first. */
233 return ((SYMBOL_CLASS (*s2
) == LOC_REGISTER
)
234 - (SYMBOL_CLASS (*s1
) == LOC_REGISTER
));
238 /* Sort a vector of symbols by their value. */
243 register struct symtab
*s
;
244 register struct objfile
*objfile
;
246 register struct blockvector
*bv
;
247 register struct block
*b
;
249 for (objfile
= object_files
; objfile
!= NULL
; objfile
= objfile
-> next
)
251 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
253 bv
= BLOCKVECTOR (s
);
254 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
255 for (i
= 0; i
< nbl
; i
++)
257 b
= BLOCKVECTOR_BLOCK (bv
, i
);
258 if (BLOCK_SHOULD_SORT (b
))
260 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
261 sizeof (struct symbol
*), compare_symbols
);
269 /* add a given stab string into given stab vector. */
272 add_stab_to_list (stabname
, stabvector
)
274 struct pending_stabs
**stabvector
;
276 if ( *stabvector
== NULL
) {
277 *stabvector
= (struct pending_stabs
*)
278 xmalloc (sizeof (struct pending_stabs
) +
279 INITIAL_STABVECTOR_LENGTH
* sizeof (char*));
280 (*stabvector
)->count
= 0;
281 (*stabvector
)->length
= INITIAL_STABVECTOR_LENGTH
;
283 else if ((*stabvector
)->count
>= (*stabvector
)->length
) {
284 (*stabvector
)->length
+= INITIAL_STABVECTOR_LENGTH
;
285 *stabvector
= (struct pending_stabs
*)
286 xrealloc ((char *) *stabvector
, sizeof (struct pending_stabs
) +
287 (*stabvector
)->length
* sizeof (char*));
289 (*stabvector
)->stab
[(*stabvector
)->count
++] = stabname
;
294 /* for all the stabs in a given stab vector, build appropriate types
295 and fix their symbols in given symbol vector. */
298 patch_block_stabs (symbols
, stabs
)
299 struct pending
*symbols
;
300 struct pending_stabs
*stabs
;
307 /* for all the stab entries, find their corresponding symbols and
308 patch their types! */
310 for (ii
=0; ii
< stabs
->count
; ++ii
) {
311 char *name
= stabs
->stab
[ii
];
312 char *pp
= (char*) index (name
, ':');
313 struct symbol
*sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
316 /* printf ("ERROR! stab symbol not found!\n"); */ /* FIXME */
317 /* The above is a false alarm. There are cases the we can have
318 a stab, without its symbol. xlc generates this for the extern
319 definitions in inner blocks. */
324 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
325 SYMBOL_TYPE (sym
) = lookup_function_type (read_type (&pp
));
327 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
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. */
347 static struct linetable
*
348 arrange_linetable (oldLineTb
)
349 struct linetable
*oldLineTb
; /* old linetable */
352 newline
, /* new line count */
353 function_count
; /* # of functions */
355 struct linetable_entry
*fentry
; /* function entry vector */
356 int fentry_size
; /* # of function entries */
357 struct linetable
*newLineTb
; /* new line table */
359 #define NUM_OF_FUNCTIONS 20
361 fentry_size
= NUM_OF_FUNCTIONS
;
362 fentry
= (struct linetable_entry
*)
363 malloc (fentry_size
* sizeof (struct linetable_entry
));
365 for (function_count
=0, ii
=0; ii
<oldLineTb
->nitems
; ++ii
) {
367 if (oldLineTb
->item
[ii
].line
== 0) { /* function entry found. */
369 if (function_count
>= fentry_size
) { /* make sure you have room. */
371 fentry
= (struct linetable_entry
*)
372 realloc (fentry
, fentry_size
* sizeof (struct linetable_entry
));
374 fentry
[function_count
].line
= ii
;
375 fentry
[function_count
].pc
= oldLineTb
->item
[ii
].pc
;
380 if (function_count
== 0) {
384 else if (function_count
> 1)
385 qsort (fentry
, function_count
, sizeof(struct linetable_entry
), compare_lte
);
387 /* allocate a new line table. */
388 newLineTb
= (struct linetable
*) malloc (sizeof (struct linetable
) +
389 (oldLineTb
->nitems
- function_count
) * sizeof (struct linetable_entry
));
391 /* if line table does not start with a function beginning, copy up until
395 if (oldLineTb
->item
[0].line
!= 0)
397 newline
< oldLineTb
->nitems
&& oldLineTb
->item
[newline
].line
; ++newline
)
398 newLineTb
->item
[newline
] = oldLineTb
->item
[newline
];
400 /* Now copy function lines one by one. */
402 for (ii
=0; ii
< function_count
; ++ii
) {
403 for (jj
= fentry
[ii
].line
+ 1;
404 jj
< oldLineTb
->nitems
&& oldLineTb
->item
[jj
].line
!= 0;
406 newLineTb
->item
[newline
] = oldLineTb
->item
[jj
];
409 newLineTb
->nitems
= oldLineTb
->nitems
- function_count
;
415 /* We try to detect the beginning of a compilation unit. That info will
416 be used as an entry in line number recording routines (enter_line_range) */
418 static unsigned first_fun_line_offset
;
419 static unsigned first_fun_bf
;
421 #define mark_first_line(OFFSET, SYMNUM) \
422 if (!first_fun_line_offset) { \
423 first_fun_line_offset = OFFSET; \
424 first_fun_bf = SYMNUM; \
428 /* include file support: C_BINCL/C_EINCL pairs will be kept in the
429 following `IncludeChain'. At the end of each symtab (end_symtab),
430 we will determine if we should create additional symtab's to
431 represent if (the include files. */
434 typedef struct _inclTable
{
435 char *name
; /* include filename */
436 int begin
, end
; /* offsets to the line table */
437 struct subfile
*subfile
;
438 unsigned funStartLine
; /* start line # of its function */
441 #define INITIAL_INCLUDE_TABLE_LENGTH 20
442 static InclTable
*inclTable
; /* global include table */
443 static int inclIndx
; /* last entry to table */
444 static int inclLength
; /* table length */
445 static int inclDepth
; /* nested include depth */
449 record_include_begin (cs
)
450 struct coff_symbol
*cs
;
452 /* In aixcoff, we assume include files cannot be nested (not in .c files
453 of course, but in corresponding .s files.) */
456 fatal ("aix internal: pending include file exists.");
460 /* allocate an include file, or make room for the new entry */
461 if (inclLength
== 0) {
462 inclTable
= (InclTable
*)
463 xmalloc (sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
464 bzero (inclTable
, sizeof (InclTable
) * INITIAL_INCLUDE_TABLE_LENGTH
);
465 inclLength
= INITIAL_INCLUDE_TABLE_LENGTH
;
468 else if (inclIndx
>= inclLength
) {
469 inclLength
+= INITIAL_INCLUDE_TABLE_LENGTH
;
470 inclTable
= (InclTable
*)
471 xrealloc (inclTable
, sizeof (InclTable
) * inclLength
);
472 bzero (inclTable
+inclLength
-INITIAL_INCLUDE_TABLE_LENGTH
,
473 sizeof (InclTable
)*INITIAL_INCLUDE_TABLE_LENGTH
);
476 inclTable
[inclIndx
].name
= cs
->c_name
;
477 inclTable
[inclIndx
].begin
= cs
->c_value
;
482 record_include_end (cs
)
483 struct coff_symbol
*cs
;
488 fatal ("aix internal: Mismatch C_BINCL/C_EINCL pair found.");
490 pTbl
= &inclTable
[inclIndx
];
491 pTbl
->end
= cs
->c_value
;
502 if (inclTable
&& inclLength
)
503 for (ii
=0; ii
< inclIndx
; ++ii
)
504 printf ("name: %s, begin: 0x%x, end: 0x%x\n",
505 inclTable
[ii
].name
, inclTable
[ii
].begin
, inclTable
[ii
].end
);
509 /* given the start and end addresses of a compilation unit (or a csect, at times)
510 process its lines and create appropriate line vectors. */
513 process_linenos (start
, end
)
514 CORE_ADDR start
, end
;
519 struct subfile main_subfile
; /* subfile structure for the main
522 /* in the main source file, any time we see a function entry, we reset
523 this variable to function's absolute starting line number. All the
524 following line numbers in the function are relative to this, and
525 we record absolute line numbers in record_line(). */
527 int main_source_baseline
= 0;
533 if (!(offset
= first_fun_line_offset
))
534 goto return_after_cleanup
;
536 bzero (&main_subfile
, sizeof (main_subfile
));
537 first_fun_line_offset
= 0;
540 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
541 &main_source_baseline
);
543 /* else, there was source with line numbers in include files */
546 main_source_baseline
= 0;
547 for (ii
=0; ii
< inclIndx
; ++ii
) {
549 struct subfile
*tmpSubfile
;
551 /* if there is main file source before include file, enter it. */
552 if (offset
< inclTable
[ii
].begin
) {
554 (&main_subfile
, offset
, inclTable
[ii
].begin
- LINESZ
, start
, 0,
555 &main_source_baseline
);
558 /* Have a new subfile for the include file */
560 tmpSubfile
= inclTable
[ii
].subfile
= (struct subfile
*)
561 xmalloc (sizeof (struct subfile
));
563 bzero (tmpSubfile
, sizeof (struct subfile
));
564 firstLine
= &(inclTable
[ii
].funStartLine
);
566 /* enter include file's lines now. */
567 enter_line_range (tmpSubfile
, inclTable
[ii
].begin
,
568 inclTable
[ii
].end
, start
, 0, firstLine
);
570 offset
= inclTable
[ii
].end
+ LINESZ
;
573 /* all the include files' line have been processed at this point. Now,
574 enter remaining lines of the main file, if any left. */
575 if (offset
< (linetab_offset
+ linetab_size
+ 1 - LINESZ
)) {
576 enter_line_range (&main_subfile
, offset
, 0, start
, end
,
577 &main_source_baseline
);
581 /* Process main file's line numbers. */
582 if (main_subfile
.line_vector
) {
583 struct linetable
*lineTb
, *lv
;
585 lv
= main_subfile
.line_vector
;
587 /* Line numbers are not necessarily ordered. xlc compilation will
588 put static function to the end. */
590 lineTb
= arrange_linetable (lv
);
592 current_subfile
->line_vector
= (struct linetable
*)
593 xrealloc (lv
, (sizeof (struct linetable
)
594 + lv
->nitems
* sizeof (struct linetable_entry
)));
599 current_subfile
->line_vector
= lineTb
;
602 current_subfile
->line_vector_length
=
603 current_subfile
->line_vector
->nitems
;
606 /* Now, process included files' line numbers. */
608 for (ii
=0; ii
< inclIndx
; ++ii
) {
610 if ( (inclTable
[ii
].subfile
)->line_vector
) { /* Useless if!!! FIXMEmgo */
611 struct linetable
*lineTb
, *lv
;
613 lv
= (inclTable
[ii
].subfile
)->line_vector
;
615 /* Line numbers are not necessarily ordered. xlc compilation will
616 put static function to the end. */
618 lineTb
= arrange_linetable (lv
);
622 /* For the same include file, we might want to have more than one subfile.
623 This happens if we have something like:
631 while foo.h including code in it. (stupid but possible)
632 Since start_subfile() looks at the name and uses an existing one if finds,
633 we need to provide a fake name and fool it. */
635 /* start_subfile (inclTable[ii].name, (char*)0); */
636 start_subfile (" ?", (char*)0);
637 current_subfile
->name
=
638 obsavestring (inclTable
[ii
].name
, strlen (inclTable
[ii
].name
),
639 ¤t_objfile
->symbol_obstack
);
642 current_subfile
->line_vector
= (struct linetable
*)
643 xrealloc (lv
, (sizeof (struct linetable
)
644 + lv
->nitems
* sizeof (struct linetable_entry
)));
649 current_subfile
->line_vector
= lineTb
;
652 current_subfile
->line_vector_length
=
653 current_subfile
->line_vector
->nitems
;
654 start_subfile (pop_subfile (), (char*)0);
659 /* I am not sure this logic is correct. There might be no lines in the
660 main file, whereas there are some in included ones. FIXMEibm */
661 current_subfile
->line_vector
= NULL
;
663 return_after_cleanup
:
665 /* We don't want to keep alloc/free'ing the global include file table. */
668 /* start with a fresh subfile structure for the next file. */
669 bzero (&main_subfile
, sizeof (struct subfile
));
673 aix_process_linenos ()
675 /* process line numbers and enter them into line vector */
676 process_linenos (last_source_start_addr
, cur_src_end_addr
);
680 /* Enter a given range of lines into the line vector.
681 can be called in the following two ways:
682 enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or
683 enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine) */
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 limit
= endoffset
? &linetab
[endoffset
- linetab_offset
]
702 : &linetab
[linetab_size
-1];
704 while (pp
<= limit
) {
706 /* find the address this line represents */
707 addr
= P_LINENO(pp
) ?
708 P_LINEADDR(pp
) : read_symbol_nvalue (symtbl
, P_LINESYM(pp
));
710 if (addr
< startaddr
|| (endaddr
&& addr
> endaddr
))
713 if (P_LINENO(pp
) == 0) {
714 *firstLine
= read_symbol_lineno (symtbl
, P_LINESYM(pp
));
715 record_line (subfile
, 0, addr
);
719 record_line (subfile
, *firstLine
+ P_LINENO(pp
), addr
);
726 int fsize
; /* file size */
727 int fixedparms
; /* number of fixed parms */
728 int floatparms
; /* number of float parms */
729 unsigned int parminfo
; /* parameter info.
730 See /usr/include/sys/debug.h
731 tbtable_ext.parminfo */
732 int framesize
; /* function frame size */
736 /* Given a function symbol, return its traceback information. */
739 retrieve_tracebackinfo (abfd
, textsec
, cs
)
742 struct coff_symbol
*cs
;
744 #define TBTABLE_BUFSIZ 2000
745 #define MIN_TBTABSIZ 50 /* minimum buffer size to hold a
748 static TracebackInfo tbInfo
;
751 static char buffer
[TBTABLE_BUFSIZ
];
754 int bytesread
=0; /* total # of bytes read so far */
755 int bufferbytes
; /* number of bytes in the buffer */
757 int functionstart
= cs
->c_value
- textsec
->vma
;
759 bzero (&tbInfo
, sizeof (tbInfo
));
761 /* keep reading blocks of data from the text section, until finding a zero
762 word and a traceback table. */
764 while (bfd_get_section_contents (abfd
, textsec
, buffer
,
765 (file_ptr
)(functionstart
+ bytesread
),
767 (TBTABLE_BUFSIZ
< (textsec
->_raw_size
- functionstart
- bytesread
)) ?
768 TBTABLE_BUFSIZ
: (textsec
->_raw_size
- functionstart
- bytesread
))))
770 bytesread
+= bufferbytes
;
771 pinsn
= (int*) buffer
;
773 /* if this is the first time we filled the buffer, retrieve function
776 if (bytesread
== bufferbytes
) {
778 /* skip over unrelated instructions */
780 if (*pinsn
== 0x7c0802a6) /* mflr r0 */
782 if ((*pinsn
& 0xfc00003e) == 0x7c000026) /* mfcr Rx */
784 if ((*pinsn
& 0xfc000000) == 0x48000000) /* bl foo, save fprs */
786 if ((*pinsn
& 0xfc1f0000) == 0xbc010000) /* stm Rx, NUM(r1) */
790 int tmp
= (*pinsn
>> 16) & 0xffff;
792 if (tmp
== 0x9421) { /* stu r1, NUM(r1) */
793 tbInfo
.framesize
= 0x10000 - (*pinsn
& 0xffff);
796 else if ((*pinsn
== 0x93e1fffc) || /* st r31,-4(r1) */
797 (tmp
== 0x9001)) /* st r0, NUM(r1) */
799 /* else, could not find a frame size. */
803 } while (++pinsn
&& *pinsn
);
805 if (!tbInfo
.framesize
)
809 /* look for a zero word. */
811 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
814 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
819 /* function size is the amount of bytes we have skipped so far. */
820 tbInfo
.fsize
= bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
);
824 /* if we don't have the whole traceback table in the buffer, re-read
827 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
829 /* In case if we are *very* close to the end of the text section
830 and cannot read properly from that point on, abort by returning
832 Handle this case more graciously -- FIXME */
834 if (!bfd_get_section_contents (
835 abfd
, textsec
, buffer
,
836 (file_ptr
)(functionstart
+
837 bytesread
- (buffer
+ bufferbytes
- (char*)pinsn
)),MIN_TBTABSIZ
))
838 { printf ("Abnormal return!..\n"); return NULL
; }
840 ptb
= (struct tbtable
*)buffer
;
843 ptb
= (struct tbtable
*)pinsn
;
845 tbInfo
.fixedparms
= ptb
->tb
.fixedparms
;
846 tbInfo
.floatparms
= ptb
->tb
.floatparms
;
847 tbInfo
.parminfo
= ptb
->tb_ext
.parminfo
;
855 /* Given a function symbol, return a pointer to its traceback table. */
858 retrieve_traceback (abfd
, textsec
, cs
, size
)
861 struct coff_symbol
*cs
;
862 int *size
; /* return function size */
864 #define TBTABLE_BUFSIZ 2000
865 #define MIN_TBTABSIZ 50 /* minimum buffer size to hold a
868 static char buffer
[TBTABLE_BUFSIZ
];
871 int bytesread
=0; /* total # of bytes read so far */
872 int bufferbytes
; /* number of bytes in the buffer */
874 int functionstart
= cs
->c_value
- textsec
->filepos
+ textsec
->vma
;
877 /* keep reading blocks of data from the text section, until finding a zero
878 word and a traceback table. */
880 while (bfd_get_section_contents (abfd
, textsec
, buffer
,
881 (file_ptr
)(functionstart
+ bytesread
),
883 (TBTABLE_BUFSIZ
< (textsec
->size
- functionstart
- bytesread
)) ?
884 TBTABLE_BUFSIZ
: (textsec
->size
- functionstart
- bytesread
))))
886 bytesread
+= bufferbytes
;
887 pinsn
= (int*) buffer
;
889 /* look for a zero word. */
891 while (*pinsn
&& (pinsn
< (int*)(buffer
+ bufferbytes
- sizeof(int))))
894 if (pinsn
>= (int*)(buffer
+ bufferbytes
))
899 /* function size is the amount of bytes we have skipped so far. */
900 *size
= bytesread
- (buffer
+ bufferbytes
- pinsn
);
904 /* if we don't have the whole traceback table in the buffer, re-read
907 if ((char*)pinsn
> (buffer
+ bufferbytes
- MIN_TBTABSIZ
)) {
909 /* In case if we are *very* close to the end of the text section
910 and cannot read properly from that point on, abort for now.
911 Handle this case more graciously -- FIXME */
913 if (!bfd_get_section_contents (
914 abfd
, textsec
, buffer
,
915 (file_ptr
)(functionstart
+
916 bytesread
- (buffer
+ bufferbytes
- pinsn
)),MIN_TBTABSIZ
))
917 /* abort (); */ { printf ("abort!!!\n"); return NULL
; }
919 return (struct tbtable
*)buffer
;
922 return (struct tbtable
*)pinsn
;
932 /* Save the vital information for use when closing off the current file.
933 NAME is the file name the symbols came from, START_ADDR is the first
934 text address for the file, and SIZE is the number of bytes of text. */
936 #define complete_symtab(name, start_addr) { \
937 last_source_file = savestring (name, strlen (name)); \
938 last_source_start_addr = start_addr; \
942 /* Refill the symbol table input buffer
943 and set the variables that control fetching entries from it.
944 Reports an error if no data available.
945 This function can read past the end of the symbol table
946 (into the string table) but this does no harm. */
948 /* Reading symbol table has to be fast! Keep the followings as macros, rather
951 #define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, ALLOCED) \
955 namestr = (NAME) + 1; \
958 obstack_copy0 (&objfile->symbol_obstack, (NAME) + 1, strlen ((NAME)+1)); \
961 prim_record_minimal_symbol (namestr, (ADDR), (TYPE)); \
962 misc_func_recorded = 1; \
966 /* A parameter template, used by ADD_PARM_TO_PENDING. */
968 static struct symbol parmsym
= { /* default parameter symbol */
970 VAR_NAMESPACE
, /* namespace */
977 /* Add a parameter to a given pending symbol list. */
979 #define ADD_PARM_TO_PENDING(PARM, VALUE, PTYPE, PENDING_SYMBOLS) \
981 PARM = (struct symbol *) \
982 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
984 SYMBOL_TYPE (PARM) = PTYPE; \
985 SYMBOL_VALUE (PARM) = VALUE; \
986 add_symbol_to_list (PARM, &PENDING_SYMBOLS); \
990 /* aixcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
991 nested. At any given time, a symbol can only be in one static block.
992 This is the base address of current static block, zero if non exists. */
994 static int static_block_base
= 0;
996 /* true if space for symbol name has been allocated. */
998 static int symname_alloced
= 0;
1000 /* read the whole symbol table of a given bfd. */
1003 read_xcoff_symtab (objfile
, nsyms
)
1004 struct objfile
*objfile
; /* Object file we're reading from */
1005 int nsyms
; /* # of symbols */
1007 bfd
*abfd
= objfile
->obfd
;
1008 char *raw_symbol
; /* Pointer into raw seething symbol table */
1009 char *raw_auxptr
; /* Pointer to first raw aux entry for sym */
1010 sec_ptr textsec
; /* Pointer to text section */
1011 TracebackInfo
*ptb
; /* Pointer to traceback table */
1013 struct internal_syment symbol
[1];
1014 union internal_auxent main_aux
[1];
1015 struct coff_symbol cs
[1];
1016 CORE_ADDR file_start_addr
= 0;
1017 CORE_ADDR file_end_addr
= 0;
1019 int next_file_symnum
= -1;
1020 int just_started
= 1;
1025 long fcn_line_offset
;
1028 struct coff_symbol fcn_stab_saved
;
1030 /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
1031 union internal_auxent fcn_aux_saved
;
1032 struct type
*fcn_type_saved
= NULL
;
1033 struct context_stack
*new;
1035 char *filestring
= " _start_ "; /* Name of the current file. */
1037 char *last_csect_name
; /* last seen csect's name and value */
1038 CORE_ADDR last_csect_val
;
1039 int misc_func_recorded
; /* true if any misc. function */
1041 current_objfile
= objfile
;
1043 /* Get the appropriate COFF "constants" related to the file we're handling. */
1044 N_TMASK
= coff_data (abfd
)->local_n_tmask
;
1045 N_BTSHFT
= coff_data (abfd
)->local_n_btshft
;
1046 local_symesz
= coff_data (abfd
)->local_symesz
;
1048 last_source_file
= 0;
1049 last_csect_name
= 0;
1051 misc_func_recorded
= 0;
1053 start_symtab (filestring
, (char *)NULL
, file_start_addr
);
1055 first_object_file_end
= 0;
1057 /* Allocate space for the entire symbol table at once, and read it
1058 all in. The bfd is already positioned at the beginning of
1059 the symbol table. */
1061 size
= coff_data (abfd
)->local_symesz
* nsyms
;
1062 symtbl
= xmalloc (size
);
1064 val
= bfd_read (symtbl
, size
, 1, abfd
);
1066 perror_with_name ("reading symbol table");
1068 raw_symbol
= symtbl
;
1070 textsec
= bfd_get_section_by_name (abfd
, ".text");
1072 printf ("Unable to locate text section!\n");
1075 while (symnum
< nsyms
) {
1077 QUIT
; /* make this command interruptable. */
1079 /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
1080 /* read one symbol into `cs' structure. After processing the whole symbol
1081 table, only string table will be kept in memory, symbol table and debug
1082 section of aixcoff will be freed. Thus we can mark symbols with names
1083 in string table as `alloced'. */
1087 /* Swap and align the symbol into a reasonable C structure. */
1088 bfd_coff_swap_sym_in (abfd
, raw_symbol
, symbol
);
1090 cs
->c_symnum
= symnum
;
1091 cs
->c_nsyms
= symbol
->n_numaux
;
1092 if (symbol
->n_zeroes
) {
1093 symname_alloced
= 0;
1094 /* We must use the original, unswapped, name here so the name field
1095 pointed to by cs->c_name will persist throughout xcoffread. If
1096 we use the new field, it gets overwritten for each symbol. */
1097 cs
->c_name
= ((struct external_syment
*)raw_symbol
)->e
.e_name
;
1098 } else if (symbol
->n_sclass
& 0x80) {
1099 cs
->c_name
= debugsec
+ symbol
->n_offset
;
1100 symname_alloced
= 0;
1101 } else { /* in string table */
1102 cs
->c_name
= strtbl
+ (int)symbol
->n_offset
;
1103 symname_alloced
= 1;
1105 cs
->c_value
= symbol
->n_value
;
1106 cs
->c_sclass
= symbol
->n_sclass
& 0xff;
1107 cs
->c_secnum
= symbol
->n_scnum
;
1108 cs
->c_type
= (unsigned)symbol
->n_type
;
1110 raw_symbol
+= coff_data (abfd
)->local_symesz
;
1113 raw_auxptr
= raw_symbol
; /* Save addr of first aux entry */
1115 /* Skip all the auxents associated with this symbol. */
1116 for (ii
= symbol
->n_numaux
; ii
; --ii
) {
1117 raw_symbol
+= coff_data (abfd
)->local_auxesz
;
1122 /* if symbol name starts with ".$" or "$", ignore it. */
1123 if (cs
->c_name
[0] == '$' || (cs
->c_name
[1] == '$' && cs
->c_name
[0] == '.'))
1126 if (cs
->c_symnum
== next_file_symnum
&& cs
->c_sclass
!= C_FILE
) {
1127 if (last_source_file
)
1128 end_symtab (cur_src_end_addr
, 1, 0, objfile
);
1130 start_symtab ("_globals_", (char *)NULL
, (CORE_ADDR
)0);
1131 cur_src_end_addr
= first_object_file_end
;
1132 /* done with all files, everything from here on is globals */
1135 /* if explicitly specified as a function, treat is as one. */
1136 if (ISFCN(cs
->c_type
) && cs
->c_sclass
!= C_TPDEF
) {
1137 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1139 goto function_entry_point
;
1142 if ((cs
->c_sclass
== C_EXT
|| cs
->c_sclass
== C_HIDEXT
) && cs
->c_nsyms
== 1)
1144 /* dealing with a symbol with a csect entry. */
1146 # define CSECT(PP) ((PP)->x_csect)
1147 # define CSECT_LEN(PP) (CSECT(PP).x_scnlen)
1148 # define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1149 # define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1150 # define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1152 /* Convert the auxent to something we can access. */
1153 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1156 switch (CSECT_SMTYP (main_aux
)) {
1159 continue; /* ignore all external references. */
1161 case XTY_SD
: /* a section description. */
1163 switch (CSECT_SCLAS (main_aux
)) {
1165 case XMC_PR
: /* a `.text' csect. */
1168 /* A program csect is seen.
1170 We have to allocate one symbol table for each program csect. Normally
1171 gdb prefers one symtab for each compilation unit (CU). In case of AIX, one
1172 CU might include more than one prog csect, and they don't have to be
1173 adjacent in terms of the space they occupy in memory. Thus, one single
1174 CU might get fragmented in the memory and gdb's file start and end address
1175 approach does not work! */
1177 if (last_csect_name
) {
1179 /* if no misc. function recorded in the last seen csect, enter
1180 it as a function. This will take care of functions like
1181 strcmp() compiled by xlc. */
1183 if (!misc_func_recorded
) {
1185 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1190 complete_symtab (filestring
, file_start_addr
);
1191 cur_src_end_addr
= file_end_addr
;
1192 end_symtab (file_end_addr
, 1, 0, objfile
);
1193 start_symtab ((char *)NULL
, (char *)NULL
, (CORE_ADDR
)0);
1196 /* If this is the very first csect seen, basically `__start'. */
1198 first_object_file_end
= cs
->c_value
+ CSECT_LEN (main_aux
);
1202 file_start_addr
= cs
->c_value
;
1203 file_end_addr
= cs
->c_value
+ CSECT_LEN (main_aux
);
1205 if (cs
->c_name
&& cs
->c_name
[0] == '.') {
1206 last_csect_name
= cs
->c_name
;
1207 last_csect_val
= cs
->c_value
;
1210 misc_func_recorded
= 0;
1216 /* If the section is not a data description, ignore it. Note that
1217 uninitialized data will show up as XTY_CM/XMC_RW pair. */
1220 #ifdef XCOFF_ADD_TOC_TO_LOADINFO
1221 XCOFF_ADD_TOC_TO_LOADINFO (cs
->c_value
);
1223 /* fall down to default case. */
1225 case XMC_TC
: /* ignore toc entries */
1226 default : /* any other XMC_XXX */
1230 break; /* switch CSECT_SCLAS() */
1234 /* a function entry point. */
1235 if (CSECT_SCLAS (main_aux
) == XMC_PR
) {
1237 function_entry_point
:
1238 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
, mst_text
,
1241 fcn_line_offset
= main_aux
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1242 fcn_start_addr
= cs
->c_value
;
1244 /* save the function header info, which will be used
1245 when `.bf' is seen. */
1247 fcn_aux_saved
= *main_aux
;
1252 /* If function has two auxent, then debugging information is
1253 already available for it. Process traceback table for
1254 functions with only one auxent. */
1256 if (cs
->c_nsyms
== 1)
1257 ptb
= retrieve_tracebackinfo (abfd
, textsec
, cs
);
1259 else if (cs
->c_nsyms
!= 2)
1262 /* If there is traceback info, create and add parameters for it. */
1264 if (ptb
&& (ptb
->fixedparms
|| ptb
->floatparms
)) {
1266 int parmcnt
= ptb
->fixedparms
+ ptb
->floatparms
;
1267 char *parmcode
= (char*) &ptb
->parminfo
;
1268 int parmvalue
= ptb
->framesize
+ 0x18; /* sizeof(LINK AREA) == 0x18 */
1269 unsigned int ii
, mask
;
1271 for (ii
=0, mask
= 0x80000000; ii
<parmcnt
; ++ii
) {
1272 struct symbol
*parm
;
1274 if (ptb
->parminfo
& mask
) { /* float or double */
1276 if (ptb
->parminfo
& mask
) { /* double parm */
1278 (parm
, parmvalue
, builtin_type_double
, local_symbols
);
1279 parmvalue
+= sizeof (double);
1281 else { /* float parm */
1283 (parm
, parmvalue
, builtin_type_float
, local_symbols
);
1284 parmvalue
+= sizeof (float);
1287 else { /* fixed parm, use (int*) for hex rep. */
1288 ADD_PARM_TO_PENDING (parm
, parmvalue
,
1289 lookup_pointer_type (builtin_type_int
),
1291 parmvalue
+= sizeof (int);
1296 /* Fake this as a function. Needed in process_xcoff_symbol() */
1299 finish_block(process_xcoff_symbol (cs
, objfile
), &local_symbols
,
1300 pending_blocks
, cs
->c_value
,
1301 cs
->c_value
+ ptb
->fsize
, objfile
);
1305 /* shared library function trampoline code entry point. */
1306 else if (CSECT_SCLAS (main_aux
) == XMC_GL
) {
1308 /* record trampoline code entries as mst_unknown symbol. When we
1309 lookup mst symbols, we will choose mst_text over mst_unknown. */
1312 /* After the implementation of incremental loading of shared
1313 libraries, we don't want to access trampoline entries. This
1314 approach has a consequence of the necessity to bring the whole
1315 shared library at first, in order do anything with it (putting
1316 breakpoints, using malloc, etc). On the other side, this is
1317 consistient with gdb's behaviour on a SUN platform. */
1319 /* Trying to prefer *real* function entry over its trampoline,
1320 by assigning `mst_unknown' type to trampoline entries fails.
1321 Gdb treats those entries as chars. FIXME. */
1323 /* Recording this entry is necessary. Single stepping relies on
1324 this vector to get an idea about function address boundaries. */
1326 prim_record_minimal_symbol (0, cs
->c_value
, mst_unknown
);
1329 /* record trampoline code entries as mst_unknown symbol. When we
1330 lookup mst symbols, we will choose mst_text over mst_unknown. */
1332 RECORD_MINIMAL_SYMBOL (cs
->c_name
, cs
->c_value
, mst_unknown
,
1339 default : /* all other XTY_XXXs */
1341 } /* switch CSECT_SMTYP() */ }
1343 switch (cs
->c_sclass
) {
1347 /* see if the last csect needs to be recorded. */
1349 if (last_csect_name
&& !misc_func_recorded
) {
1351 /* if no misc. function recorded in the last seen csect, enter
1352 it as a function. This will take care of functions like
1353 strcmp() compiled by xlc. */
1356 RECORD_MINIMAL_SYMBOL (last_csect_name
, last_csect_val
,
1360 /* c_value field contains symnum of next .file entry in table
1361 or symnum of first global after last .file. */
1363 next_file_symnum
= cs
->c_value
;
1365 /* complete symbol table for last object file containing
1366 debugging information. */
1368 /* Whether or not there was a csect in the previous file, we have
1369 to call `end_symtab' and `start_symtab' to reset type_vector,
1370 line_vector, etc. structures. */
1372 complete_symtab (filestring
, file_start_addr
);
1373 cur_src_end_addr
= file_end_addr
;
1374 end_symtab (file_end_addr
, 1, 0, objfile
);
1375 start_symtab (cs
->c_name
, (char *)NULL
, (CORE_ADDR
)0);
1376 last_csect_name
= 0;
1378 /* reset file start and end addresses. A compilation unit with no text
1379 (only data) should have zero file boundaries. */
1380 file_start_addr
= file_end_addr
= 0;
1382 filestring
= cs
->c_name
;
1388 #ifdef NO_DEFINE_SYMBOL
1389 /* For a function stab, just save its type in `fcn_type_saved', and leave
1390 it for the `.bf' processing. */
1392 char *pp
= (char*) index (cs
->c_name
, ':');
1394 if (!pp
|| ( *(pp
+1) != 'F' && *(pp
+1) != 'f'))
1395 fatal ("Unrecognized stab");
1399 fatal ("Unprocessed function type");
1401 fcn_type_saved
= lookup_function_type (read_type (&pp
, objfile
));
1404 fcn_stab_saved
= *cs
;
1410 if (strcmp (cs
->c_name
, ".bf") == 0) {
1412 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1415 within_function
= 1;
1417 /* Linenos are now processed on a file-by-file, not fn-by-fn, basis.
1418 Metin did it, I'm not sure why. FIXME. -- gnu@cygnus.com */
1422 1) xlc (IBM's native c compiler) postpones static function code
1423 emission to the end of a compilation unit. This way it can
1424 determine if those functions (statics) are needed or not, and
1425 can do some garbage collection (I think). This makes line
1426 numbers and corresponding addresses unordered, and we end up
1427 with a line table like:
1444 and that breaks gdb's binary search on line numbers, if the
1445 above table is not sorted on line numbers. And that sort
1446 should be on function based, since gcc can emit line numbers
1449 10 0x100 - for the init/test part of a for stmt.
1452 10 0x400 - for the increment part of a for stmt.
1454 arrange_linenos() will do this sorting.
1457 2) aix symbol table might look like:
1459 c_file // beginning of a new file
1460 .bi // beginning of include file
1461 .ei // end of include file
1465 basically, .bi/.ei pairs do not necessarily encapsulate
1466 their scope. They need to be recorded, and processed later
1467 on when we come the end of the compilation unit.
1468 Include table (inclTable) and process_linenos() handle
1471 mark_first_line (fcn_line_offset
, cs
->c_symnum
);
1473 new = push_context (0, fcn_start_addr
);
1475 #ifdef NO_DEFINE_SYMBOL
1476 new->name
= process_xcoff_symbol (&fcn_cs_saved
, objfile
);
1478 /* Between a function symbol and `.bf', there always will be a function
1479 stab. We save function type when processing that stab. */
1481 if (fcn_type_saved
== NULL
) {
1482 printf ("Unknown function type: symbol 0x%x\n", cs
->c_symnum
);
1483 SYMBOL_TYPE (new->name
) = lookup_function_type (builtin_type_int
);
1486 SYMBOL_TYPE (new->name
) = fcn_type_saved
;
1487 fcn_type_saved
= NULL
;
1490 new->name
= define_symbol
1491 (fcn_cs_saved
.c_value
, fcn_stab_saved
.c_name
, 0, 0, objfile
);
1494 else if (strcmp (cs
->c_name
, ".ef") == 0) {
1496 bfd_coff_swap_aux_in (abfd
, raw_auxptr
, cs
->c_type
, cs
->c_sclass
,
1499 /* the value of .ef is the address of epilogue code;
1500 not useful for gdb */
1501 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1502 contains number of lines to '}' */
1504 fcn_last_line
= main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
1505 new = pop_context ();
1506 if (context_stack_depth
!= 0)
1507 error ("invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.",
1510 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1512 fcn_cs_saved
.c_value
+
1513 fcn_aux_saved
.x_sym
.x_misc
.x_fsize
, objfile
);
1514 within_function
= 0;
1518 case C_BSTAT
: /* begin static block */
1519 static_block_base
= read_symbol_nvalue (symtbl
, cs
->c_value
);
1522 case C_ESTAT
: /* end of static block */
1523 static_block_base
= 0;
1526 case C_ARG
: /* These are not implemented. */
1532 printf ("ERROR: Unimplemented storage class: %d.\n", cs
->c_sclass
);
1535 case C_HIDEXT
: /* ignore these.. */
1540 case C_BINCL
: /* beginning of include file */
1542 /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1543 order. Thus, when wee see them, we might not know enough info
1544 to process them. Thus, we'll be saving them into a table
1545 (inclTable) and postpone their processing. */
1547 record_include_begin (cs
);
1550 case C_EINCL
: /* end of include file */
1551 /* see the comment after case C_BINCL. */
1552 record_include_end (cs
);
1556 if (strcmp (cs
->c_name
, ".bb") == 0) {
1558 new = push_context (depth
, cs
->c_value
);
1560 else if (strcmp (cs
->c_name
, ".eb") == 0) {
1561 new = pop_context ();
1562 if (depth
!= new->depth
)
1563 error ("Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
1567 if (local_symbols
&& context_stack_depth
> 0) {
1568 /* Make a block for the local symbols within. */
1569 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1570 new->start_addr
, cs
->c_value
, objfile
);
1572 local_symbols
= new->locals
;
1577 (void) process_xcoff_symbol (cs
, objfile
);
1583 if (last_source_file
)
1584 end_symtab (cur_src_end_addr
, 1, 0, objfile
);
1587 current_objfile
= NULL
;
1590 #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1591 (SYMBOL2) = (struct symbol *) \
1592 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
1593 *(SYMBOL2) = *(SYMBOL1);
1596 #define SYMNAME_ALLOC(NAME, ALLOCED) \
1597 (ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME));
1600 /* process one xcoff symbol. */
1602 static struct symbol
*
1603 process_xcoff_symbol (cs
, objfile
)
1604 register struct coff_symbol
*cs
;
1605 struct objfile
*objfile
;
1607 struct symbol onesymbol
;
1608 register struct symbol
*sym
= &onesymbol
;
1609 struct symbol
*sym2
= NULL
;
1611 char *name
, *pp
, *qq
;
1612 int struct_and_type_combined
;
1619 bzero (sym
, sizeof (struct symbol
));
1621 /* default assumptions */
1622 SYMBOL_VALUE (sym
) = cs
->c_value
;
1623 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1625 if (ISFCN (cs
->c_type
)) {
1627 /* At this point, we don't know the type of the function and assume it
1628 is int. This will be patched with the type from its stab entry later
1629 on in patch_block_stabs () */
1631 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1632 SYMBOL_TYPE (sym
) = lookup_function_type (lookup_fundamental_type (objfile
, FT_INTEGER
));
1634 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1635 SYMBOL_DUP (sym
, sym2
);
1637 if (cs
->c_sclass
== C_EXT
)
1638 add_symbol_to_list (sym2
, &global_symbols
);
1639 else if (cs
->c_sclass
== C_HIDEXT
|| cs
->c_sclass
== C_STAT
)
1640 add_symbol_to_list (sym2
, &file_symbols
);
1645 /* in case we can't figure out the type, default is `int'. */
1646 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
1648 switch (cs
->c_sclass
)
1652 if (fcn_cs_saved
.c_sclass
== C_EXT
)
1653 add_stab_to_list (name
, &global_stabs
);
1655 add_stab_to_list (name
, &file_stabs
);
1659 case C_DECL
: /* a type decleration?? */
1661 #if defined(NO_TYPEDEFS) || defined(NO_DEFINE_SYMBOL)
1662 qq
= (char*) strchr (name
, ':');
1663 if (!qq
) /* skip if there is no ':' */
1666 nameless
= (qq
== name
);
1668 struct_and_type_combined
= (qq
[1] == 'T' && qq
[2] == 't');
1669 pp
= qq
+ (struct_and_type_combined
? 3 : 2);
1672 /* To handle GNU C++ typename abbreviation, we need to be able to fill
1673 in a type's name as soon as space for that type is allocated. */
1675 if (struct_and_type_combined
&& name
!= qq
) {
1678 struct type
*tmp_type
;
1681 read_type_number (&tmp_pp
, typenums
);
1682 tmp_type
= dbx_alloc_type (typenums
, objfile
);
1684 if (tmp_type
&& !TYPE_NAME (tmp_type
) && !nameless
)
1685 TYPE_NAME (tmp_type
) = SYMBOL_NAME (sym
) =
1686 obsavestring (name
, qq
-name
,
1687 &objfile
->symbol_obstack
);
1689 ttype
= SYMBOL_TYPE (sym
) = read_type (&pp
);
1691 /* if there is no name for this typedef, you don't have to keep its
1692 symbol, since nobody could ask for it. Otherwise, build a symbol
1693 and add it into symbol_list. */
1699 /* Transarc wants to eliminate type definitions from the symbol table.
1700 Limited debugging capabilities, but faster symbol table processing
1701 and less memory usage. Note that tag definitions (starting with
1702 'T') will remain intact. */
1704 if (qq
[1] != 'T' && (!TYPE_NAME (ttype
) || *(TYPE_NAME (ttype
)) == '\0')) {
1706 if (SYMBOL_NAME (sym
))
1707 TYPE_NAME (ttype
) = SYMBOL_NAME (sym
);
1709 TYPE_NAME (ttype
) = obsavestring (name
, qq
-name
);
1714 #endif /* !NO_TYPEDEFS */
1716 /* read_type() will return null if type (or tag) definition was
1717 unnnecessarily duplicated. Also, if the symbol doesn't have a name,
1718 there is no need to keep it in symbol table. */
1719 /* The above argument no longer valid. read_type() never returns NULL. */
1724 /* if there is no name for this typedef, you don't have to keep its
1725 symbol, since nobody could ask for it. Otherwise, build a symbol
1726 and add it into symbol_list. */
1729 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1730 else if (qq
[1] == 't')
1731 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1733 warning ("Unrecognized stab string.\n");
1737 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1738 if (!SYMBOL_NAME (sym
))
1739 SYMBOL_NAME (sym
) = obsavestring (name
, qq
-name
);
1741 SYMBOL_DUP (sym
, sym2
);
1743 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1745 /* For a combination of struct and type, add one more symbol
1748 if (struct_and_type_combined
) {
1749 SYMBOL_DUP (sym
, sym2
);
1750 SYMBOL_NAMESPACE (sym2
) = VAR_NAMESPACE
;
1752 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1755 /* assign a name to the type node. */
1757 if (!TYPE_NAME (ttype
) || *(TYPE_NAME (ttype
)) == '\0') {
1758 if (struct_and_type_combined
)
1759 TYPE_NAME (ttype
) = SYMBOL_NAME (sym
);
1760 else if (qq
[1] == 'T') /* struct namespace */
1761 TYPE_NAME (ttype
) = concat (
1762 TYPE_CODE (ttype
) == TYPE_CODE_UNION
? "union " :
1763 TYPE_CODE (ttype
) == TYPE_CODE_STRUCT
? "struct " : "enum ",
1764 SYMBOL_NAME (sym
), NULL
);
1768 #else /* !NO_DEFINE_SYMBOL */
1769 return define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1773 add_stab_to_list (name
, &global_stabs
);
1779 #ifdef NO_DEFINE_SYMBOL
1780 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1782 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1783 SYMBOL_CLASS (sym
) = (cs
->c_sclass
== C_PSYM
) ? LOC_ARG
: LOC_REGPARM
;
1785 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1786 SYMBOL_DUP (sym
, sym2
);
1787 add_symbol_to_list (sym2
, &local_symbols
);
1790 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1791 SYMBOL_CLASS (sym
) = (cs
->c_sclass
== C_PSYM
) ? LOC_ARG
: LOC_REGPARM
;
1797 #ifdef NO_DEFINE_SYMBOL
1798 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1800 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1801 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1802 SYMBOL_VALUE (sym
) += static_block_base
;
1804 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1805 SYMBOL_DUP (sym
, sym2
);
1807 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1810 /* If we are going to use Sun dbx's define_symbol(), we need to
1811 massage our stab string a little. Change 'V' type to 'S' to be
1812 comparible with Sun. */
1814 if (*name
== ':' || (pp
= (char *) index (name
, ':')) == NULL
)
1818 if (*pp
== 'V') *pp
= 'S';
1819 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1820 SYMBOL_VALUE (sym
) += static_block_base
;
1825 if (*name
== ':' || (pp
= (char *) strchr (name
, ':')) == NULL
)
1827 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1828 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1830 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1831 SYMBOL_DUP (sym
, sym2
);
1832 add_symbol_to_list (sym2
, &local_symbols
);
1836 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1837 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1838 SYMBOL_DUP (sym
, sym2
);
1839 add_symbol_to_list (sym2
, &local_symbols
);
1843 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1844 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1845 SYMBOL_DUP (sym
, sym2
);
1846 add_symbol_to_list (sym2
, &global_symbols
);
1850 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1851 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1852 SYMBOL_DUP (sym
, sym2
);
1854 (sym2
, within_function
? &local_symbols
: &file_symbols
);
1858 printf ("ERROR! C_REG is not fully implemented!\n");
1859 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1860 SYMBOL_NAME (sym
) = SYMNAME_ALLOC (name
, symname_alloced
);
1861 SYMBOL_DUP (sym
, sym2
);
1862 add_symbol_to_list (sym2
, &local_symbols
);
1867 #ifdef NO_DEFINE_SYMBOL
1868 pp
= (char*) strchr (name
, ':');
1869 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1870 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (cs
->c_value
);
1872 SYMBOL_NAME (sym
) = obsavestring (name
, pp
-name
, &objfile
-> symbol_obstack
);
1875 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
1878 /* else this is not a stab entry, suppose the type is either
1879 `int' or `float', depending on the register class. */
1881 SYMBOL_TYPE (sym
) = (SYMBOL_VALUE (sym
) < 32)
1882 ? lookup_fundamental_type (objfile
, FT_INTEGER
)
1883 : lookup_fundamental_type (objfile
, FT_FLOAT
);
1885 SYMBOL_DUP (sym
, sym2
);
1886 add_symbol_to_list (sym2
, &local_symbols
);
1890 sym
= define_symbol (cs
->c_value
, cs
->c_name
, 0, 0, objfile
);
1894 warning ("A non-stab C_RSYM needs special handling.");
1900 warning ("Unexpected storage class: %d.", cs
->c_sclass
);
1909 read_symbol_nvalue (symtable
, symno
)
1913 struct internal_syment symbol
[1];
1915 bfd_coff_swap_sym_in (symfile_bfd
, symtable
+ (symno
*local_symesz
), symbol
);
1916 return symbol
->n_value
;
1921 read_symbol_lineno (symtable
, symno
)
1925 struct internal_syment symbol
[1];
1926 union internal_auxent main_aux
[1];
1930 for (ii
= 0; ii
< 50; ii
++) {
1931 bfd_coff_swap_sym_in (symfile_bfd
,
1932 symtable
+ (symno
*local_symesz
), symbol
);
1933 if (symbol
->n_sclass
== C_FCN
&& 0 == strcmp (symbol
->n_name
, ".bf"))
1935 symno
+= symbol
->n_numaux
+1;
1938 printf ("GDB Error: `.bf' not found.\n");
1942 /* take aux entry and return its lineno */
1944 bfd_coff_swap_aux_in (symfile_bfd
, symtable
+(symno
*local_symesz
),
1945 symbol
->n_type
, symbol
->n_sclass
, main_aux
);
1947 return main_aux
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
1950 /* Support for line number handling */
1952 /* This function is called for every section; it finds the outer limits
1953 * of the line table (minimum and maximum file offset) so that the
1954 * mainline code can read the whole thing for efficiency.
1957 find_linenos(abfd
, asect
, vpinfo
)
1962 struct coff_symfile_info
*info
;
1964 file_ptr offset
, maxoff
;
1966 count
= asect
->lineno_count
;
1968 if (strcmp (asect
->name
, ".text") || count
== 0)
1971 size
= count
* coff_data (symfile_bfd
)->local_linesz
;
1972 info
= (struct coff_symfile_info
*)vpinfo
;
1973 offset
= asect
->line_filepos
;
1974 maxoff
= offset
+ size
;
1976 if (offset
< info
->min_lineno_offset
|| info
->min_lineno_offset
== 0)
1977 info
->min_lineno_offset
= offset
;
1979 if (maxoff
> info
->max_lineno_offset
)
1980 info
->max_lineno_offset
= maxoff
;
1984 /* Read in all the line numbers for fast lookups later. Leave them in
1985 external (unswapped) format in memory; we'll swap them as we enter
1986 them into GDB's data structures. */
1989 init_lineno (abfd
, offset
, size
)
1996 if (bfd_seek(abfd
, offset
, 0) < 0)
1999 linetab
= (char *) xmalloc(size
);
2001 val
= bfd_read(linetab
, 1, size
, abfd
);
2005 linetab_offset
= offset
;
2006 linetab_size
= size
;
2007 make_cleanup (free
, linetab
); /* Be sure it gets de-allocated. */
2011 /* dbx allows the text of a symbol name to be continued into the
2012 next symbol name! When such a continuation is encountered
2013 (a \ at the end of the text of a name)
2014 call this function to get the continuation. */
2015 /* So far, I haven't seen this happenning xlc output. I doubt we'll need this
2018 #undef next_symbol_text
2019 #define next_symbol_text() \
2020 printf ("Gdb Error: symbol names on multiple lines not implemented.\n")
2023 /* xlc/dbx combination uses a set of builtin types, starting from -1. return
2024 the proper type node fora given builtin type #. */
2033 printf ("ERROR!, unknown built-in type!\n");
2037 read_type_number (pp
, typenums
);
2039 /* default types are defined in dbxstclass.h. */
2040 switch ( typenums
[1] ) {
2042 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
2044 return lookup_fundamental_type (current_objfile
, FT_CHAR
);
2046 return lookup_fundamental_type (current_objfile
, FT_SHORT
);
2048 return lookup_fundamental_type (current_objfile
, FT_LONG
);
2050 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_CHAR
);
2052 return lookup_fundamental_type (current_objfile
, FT_SIGNED_CHAR
);
2054 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_SHORT
);
2056 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
2058 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_INTEGER
);
2060 return lookup_fundamental_type (current_objfile
, FT_UNSIGNED_LONG
);
2062 return lookup_fundamental_type (current_objfile
, FT_VOID
);
2064 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
2066 return lookup_fundamental_type (current_objfile
, FT_DBL_PREC_FLOAT
);
2068 return lookup_fundamental_type (current_objfile
, FT_EXT_PREC_FLOAT
);
2070 /* requires a builtin `integer' */
2071 return lookup_fundamental_type (current_objfile
, FT_INTEGER
);
2073 return lookup_fundamental_type (current_objfile
, FT_BOOLEAN
);
2075 /* requires builtin `short real' */
2076 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
2078 /* requires builtin `real' */
2079 return lookup_fundamental_type (current_objfile
, FT_FLOAT
);
2081 printf ("ERROR! Unknown builtin type -%d\n", typenums
[1]);
2086 #if 0 /* Seems to be unused, don't bother converting from old misc function
2087 vector usage to new minimal symbol tables. FIXME: Delete this? */
2089 /* if we now nothing about a function but its address, make a function symbol
2090 out of it with the limited knowladge you have. This will be used when
2091 somebody refers to a function, which doesn't exist in the symbol table,
2092 but is in the minimal symbol table. */
2095 build_function_symbol (ind
, objfile
)
2097 struct objfile
*objfile
;
2099 struct symbol
*sym
=
2100 (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct symbol
));
2101 SYMBOL_NAME (sym
) = misc_function_vector
[ind
].name
;
2102 /* SYMBOL_VALUE (sym) = misc_function_vector[ind].address; */
2103 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2104 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
2105 SYMBOL_TYPE (sym
) = lookup_function_type (lookup_fundamental_type (current_objfile
, FT_INTEGER
));
2106 SYMBOL_BLOCK_VALUE (sym
) = (struct block
*)
2107 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct block
));
2108 BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) = misc_function_vector
[ind
].address
;
2115 aixcoff_new_init (objfile
)
2116 struct objfile
*objfile
;
2121 aixcoff_symfile_init (objfile
)
2122 struct objfile
*objfile
;
2124 bfd
*abfd
= objfile
->obfd
;
2126 /* Allocate struct to keep track of the symfile */
2127 objfile
-> sym_private
= xmmalloc (objfile
-> md
,
2128 sizeof (struct coff_symfile_info
));
2129 init_entry_point_info (objfile
);
2132 /* Perform any local cleanups required when we are done with a particular
2133 objfile. I.E, we are in the process of discarding all symbol information
2134 for an objfile, freeing up all memory held for it, and unlinking the
2135 objfile struct from the global list of known objfiles. */
2138 aixcoff_symfile_finish (objfile
)
2139 struct objfile
*objfile
;
2141 if (objfile
-> sym_private
!= NULL
)
2143 mfree (objfile
-> md
, objfile
-> sym_private
);
2146 /* Start with a fresh include table for the next objfile. */
2153 inclIndx
= inclLength
= inclDepth
= 0;
2158 init_stringtab(abfd
, offset
, objfile
)
2161 struct objfile
*objfile
;
2165 unsigned char lengthbuf
[4];
2167 if (bfd_seek(abfd
, offset
, 0) < 0)
2170 val
= bfd_read((char *)lengthbuf
, 1, sizeof lengthbuf
, abfd
);
2171 length
= bfd_h_get_32(abfd
, lengthbuf
);
2173 /* If no string table is needed, then the file may end immediately
2174 after the symbols. Just return with `strtbl' set to null. */
2176 if (val
!= sizeof length
|| length
< sizeof length
)
2179 /* Allocate string table from symbol_obstack. We will need this table
2180 as long as we have its symbol table around. */
2182 strtbl
= (char*) obstack_alloc (&objfile
->symbol_obstack
, length
);
2186 bcopy(&length
, strtbl
, sizeof length
);
2187 if (length
== sizeof length
)
2190 val
= bfd_read(strtbl
+ sizeof length
, 1, length
- sizeof length
, abfd
);
2192 if (val
!= length
- sizeof length
|| strtbl
[length
- 1] != '\0')
2199 init_debugsection(abfd
)
2202 register sec_ptr secp
;
2203 bfd_size_type length
;
2210 secp
= bfd_get_section_by_name(abfd
, ".debug");
2214 if (!(length
= bfd_section_size(abfd
, secp
)))
2217 debugsec
= (char *) xmalloc ((unsigned)length
);
2218 if (debugsec
== NULL
)
2221 if (!bfd_get_section_contents(abfd
, secp
, debugsec
, (file_ptr
) 0, length
)) {
2222 printf ("Can't read .debug section from symbol file\n");
2237 /* aixcoff version of symbol file read. */
2240 aixcoff_symfile_read (objfile
, addr
, mainline
)
2241 struct objfile
*objfile
;
2245 int num_symbols
; /* # of symbols */
2246 int symtab_offset
; /* symbol table and */
2247 int stringtab_offset
; /* string table file offsets */
2250 struct coff_symfile_info
*info
;
2253 info
= (struct coff_symfile_info
*) objfile
-> sym_private
;
2254 symfile_bfd
= abfd
= objfile
->obfd
;
2255 name
= objfile
->name
;
2257 num_symbols
= bfd_get_symcount (abfd
); /* # of symbols */
2258 symtab_offset
= obj_sym_filepos (abfd
); /* symbol table file offset */
2259 stringtab_offset
= symtab_offset
+
2260 num_symbols
* coff_data(abfd
)->local_symesz
;
2262 info
->min_lineno_offset
= 0;
2263 info
->max_lineno_offset
= 0;
2264 bfd_map_over_sections (abfd
, find_linenos
, info
);
2266 /* FIXME! This stuff should move into symfile_init */
2267 if (info
->min_lineno_offset
!= 0
2268 && info
->max_lineno_offset
> info
->min_lineno_offset
) {
2270 /* only read in the line # table if one exists */
2271 val
= init_lineno(abfd
, info
->min_lineno_offset
,
2272 info
->max_lineno_offset
- info
->min_lineno_offset
);
2275 error("\"%s\": error reading line numbers\n", name
);
2278 val
= init_stringtab(abfd
, stringtab_offset
, objfile
);
2280 error ("\"%s\": can't get string table", name
);
2283 if (init_debugsection(abfd
) < 0) {
2284 error ("Error reading .debug section of `%s'\n", name
);
2287 /* Position to read the symbol table. Do not read it all at once. */
2288 val
= bfd_seek(abfd
, (long)symtab_offset
, 0);
2290 perror_with_name(name
);
2292 if (bfd_tell(abfd
) != symtab_offset
)
2295 init_minimal_symbol_collection ();
2296 make_cleanup (discard_minimal_symbols
, 0);
2298 #ifdef XCOFF_INIT_LOADINFO
2300 XCOFF_INIT_LOADINFO ();
2303 /* Now that the executable file is positioned at symbol table,
2304 process it and define symbols accordingly. */
2306 read_xcoff_symtab(objfile
, num_symbols
);
2308 /* Free debug section. */
2309 free_debugsection ();
2311 /* Sort symbols alphabetically within each block. */
2314 /* Install any minimal symbols that have been collected as the current
2315 minimal symbols for this objfile. */
2317 install_minimal_symbols (objfile
);
2319 /* Make a default for file to list. */
2320 select_source_symtab (0);
2323 /* Register our ability to parse symbols for aixcoff BFD files. */
2325 static struct sym_fns aixcoff_sym_fns
=
2327 "aixcoff-rs6000", /* sym_name: name or name prefix of BFD target type */
2328 15, /* sym_namelen: number of significant sym_name chars */
2329 aixcoff_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2330 aixcoff_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2331 aixcoff_symfile_read
, /* sym_read: read a symbol file into symtab */
2332 aixcoff_symfile_finish
, /* sym_finish: finished with file, cleanup */
2333 NULL
/* next: pointer to next struct sym_fns */
2337 _initialize_xcoffread ()
2339 add_symtab_fns(&aixcoff_sym_fns
);
2343 /* In order to handle forward type references, we needed to have this old
2344 routine. Try printing the type of member `p' in the following structure
2345 in a dbx environment.
2354 /* Smash TYPE to be a type of pointers to TO_TYPE.
2355 If TO_TYPE is not permanent and has no pointer-type yet,
2356 record TYPE as its pointer-type. */
2359 smash_to_pointer_type (type
, to_type
)
2360 struct type
*type
, *to_type
;
2362 /* int type_permanent = (TYPE_FLAGS (type) & TYPE_FLAG_PERM); */
2364 bzero (type
, sizeof (struct type
));
2365 TYPE_TARGET_TYPE (type
) = to_type
;
2366 /* We assume the machine has only one representation for pointers! */
2367 TYPE_LENGTH (type
) = sizeof (char *);
2368 TYPE_CODE (type
) = TYPE_CODE_PTR
;
2370 /* ??? TYPE_TARGET_TYPE and TYPE_MAIN_VARIANT are the same. You can't do
2371 this. It will break the target type!!!
2372 TYPE_MAIN_VARIANT (type) = type;
2375 TYPE_FLAGS (type) |= TYPE_FLAG_PERM;
2378 if (TYPE_POINTER_TYPE (to_type
) == 0)
2380 && (!(TYPE_FLAGS (to_type
) & TYPE_FLAG_PERM
)
2384 TYPE_POINTER_TYPE (to_type
) = type
;
2388 #else /* IBM6000_HOST */
2390 builtin_type (ignore
)
2393 fatal ("GDB internal eror: builtin_type called on non-RS/6000!");
2395 #endif /* IBM6000_HOST */