1 /* Target-dependent code for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 #include "xcoffsolib.h"
31 extern struct obstack frame_cache_obstack
;
35 /* Nonzero if we just simulated a single step break. */
38 /* Breakpoint shadows for the single step instructions will be kept here. */
40 static struct sstep_breaks
{
41 /* Address, or 0 if this is not in use. */
43 /* Shadow contents. */
47 /* Static function prototypes */
49 static CORE_ADDR find_toc_address
PARAMS ((CORE_ADDR pc
));
51 static CORE_ADDR branch_dest
PARAMS ((int opcode
, int instr
, CORE_ADDR pc
,
54 static void frame_get_cache_fsr
PARAMS ((struct frame_info
*fi
,
55 struct rs6000_framedata
*fdatap
));
57 /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
60 branch_dest (opcode
, instr
, pc
, safety
)
72 absolute
= (int) ((instr
>> 1) & 1);
76 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
80 dest
= pc
+ immediate
;
84 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
88 dest
= pc
+ immediate
;
92 ext_op
= (instr
>>1) & 0x3ff;
94 if (ext_op
== 16) /* br conditional register */
95 dest
= read_register (LR_REGNUM
) & ~3;
97 else if (ext_op
== 528) /* br cond to count reg */
99 dest
= read_register (CTR_REGNUM
) & ~3;
101 /* If we are about to execute a system call, dest is something
102 like 0x22fc or 0x3b00. Upon completion the system call
103 will return to the address in the link register. */
104 if (dest
< TEXT_SEGMENT_BASE
)
105 dest
= read_register (LR_REGNUM
) & ~3;
112 return (dest
< TEXT_SEGMENT_BASE
) ? safety
: dest
;
117 /* AIX does not support PT_STEP. Simulate it. */
123 #define INSNLEN(OPCODE) 4
125 static char le_breakp
[] = LITTLE_BREAKPOINT
;
126 static char be_breakp
[] = BIG_BREAKPOINT
;
127 char *breakp
= TARGET_BYTE_ORDER
== BIG_ENDIAN
? be_breakp
: le_breakp
;
136 insn
= read_memory_integer (loc
, 4);
138 breaks
[0] = loc
+ INSNLEN(insn
);
140 breaks
[1] = branch_dest (opcode
, insn
, loc
, breaks
[0]);
142 /* Don't put two breakpoints on the same address. */
143 if (breaks
[1] == breaks
[0])
146 stepBreaks
[1].address
= 0;
148 for (ii
=0; ii
< 2; ++ii
) {
150 /* ignore invalid breakpoint. */
151 if ( breaks
[ii
] == -1)
154 read_memory (breaks
[ii
], stepBreaks
[ii
].data
, 4);
156 write_memory (breaks
[ii
], breakp
, 4);
157 stepBreaks
[ii
].address
= breaks
[ii
];
163 /* remove step breakpoints. */
164 for (ii
=0; ii
< 2; ++ii
)
165 if (stepBreaks
[ii
].address
!= 0)
167 (stepBreaks
[ii
].address
, stepBreaks
[ii
].data
, 4);
171 errno
= 0; /* FIXME, don't ignore errors! */
172 /* What errors? {read,write}_memory call error(). */
176 /* return pc value after skipping a function prologue and also return
177 information about a function frame.
179 in struct rs6000_frameinfo fdata:
180 - frameless is TRUE, if function does not have a frame.
181 - nosavedpc is TRUE, if function does not save %pc value in its frame.
182 - offset is the number of bytes used in the frame to save registers.
183 - saved_gpr is the number of the first saved gpr.
184 - saved_fpr is the number of the first saved fpr.
185 - alloca_reg is the number of the register used for alloca() handling.
187 - gpr_offset is the offset of the saved gprs
188 - fpr_offset is the offset of the saved fprs
189 - lr_offset is the offset of the saved lr
190 - cr_offset is the offset of the saved cr
193 #define SIGNED_SHORT(x) \
194 ((sizeof (short) == 2) \
195 ? ((int)(short)(x)) \
196 : ((int)((((x) & 0xffff) ^ 0x8000) - 0x8000)))
198 #define GET_SRC_REG(x) (((x) >> 21) & 0x1f)
201 skip_prologue (pc
, fdata
)
203 struct rs6000_framedata
*fdata
;
205 CORE_ADDR orig_pc
= pc
;
213 int minimal_toc_loaded
= 0;
214 static struct rs6000_framedata zero_frame
;
217 fdata
->saved_gpr
= -1;
218 fdata
->saved_fpr
= -1;
219 fdata
->alloca_reg
= -1;
220 fdata
->frameless
= 1;
221 fdata
->nosavedpc
= 1;
223 if (target_read_memory (pc
, buf
, 4))
224 return pc
; /* Can't access it -- assume no prologue. */
226 /* Assume that subsequent fetches can fail with low probability. */
231 op
= read_memory_integer (pc
, 4);
233 if ((op
& 0xfc1fffff) == 0x7c0802a6) { /* mflr Rx */
234 lr_reg
= (op
& 0x03e00000) | 0x90010000;
237 } else if ((op
& 0xfc1fffff) == 0x7c000026) { /* mfcr Rx */
238 cr_reg
= (op
& 0x03e00000) | 0x90010000;
241 } else if ((op
& 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
242 reg
= GET_SRC_REG (op
);
243 if (fdata
->saved_fpr
== -1 || fdata
->saved_fpr
> reg
) {
244 fdata
->saved_fpr
= reg
;
245 fdata
->fpr_offset
= SIGNED_SHORT (op
) + offset
;
249 } else if (((op
& 0xfc1f0000) == 0xbc010000) || /* stm Rx, NUM(r1) */
250 ((op
& 0xfc1f0000) == 0x90010000 && /* st rx,NUM(r1), rx >= r13 */
251 (op
& 0x03e00000) >= 0x01a00000)) {
253 reg
= GET_SRC_REG (op
);
254 if (fdata
->saved_gpr
== -1 || fdata
->saved_gpr
> reg
) {
255 fdata
->saved_gpr
= reg
;
256 fdata
->gpr_offset
= SIGNED_SHORT (op
) + offset
;
260 } else if ((op
& 0xffff0000) == 0x3c000000) { /* addis 0,0,NUM, used for >= 32k frames */
261 fdata
->offset
= (op
& 0x0000ffff) << 16;
262 fdata
->frameless
= 0;
265 } else if ((op
& 0xffff0000) == 0x60000000) { /* ori 0,0,NUM, 2nd half of >= 32k frames */
266 fdata
->offset
|= (op
& 0x0000ffff);
267 fdata
->frameless
= 0;
270 } else if ((op
& 0xffff0000) == lr_reg
) { /* st Rx,NUM(r1) where Rx == lr */
271 fdata
->lr_offset
= SIGNED_SHORT (op
) + offset
;
272 fdata
->nosavedpc
= 0;
276 } else if ((op
& 0xffff0000) == cr_reg
) { /* st Rx,NUM(r1) where Rx == cr */
277 fdata
->cr_offset
= SIGNED_SHORT (op
) + offset
;
281 } else if (op
== 0x48000005) { /* bl .+4 used in -mrelocatable */
284 } else if (op
== 0x48000004) { /* b .+4 (xlc) */
287 } else if (((op
& 0xffff0000) == 0x801e0000 || /* lwz 0,NUM(r30), used in V.4 -mrelocatable */
288 op
== 0x7fc0f214) && /* add r30,r0,r30, used in V.4 -mrelocatable */
289 lr_reg
== 0x901e0000) {
292 } else if ((op
& 0xffff0000) == 0x3fc00000 || /* addis 30,0,foo@ha, used in V.4 -mminimal-toc */
293 (op
& 0xffff0000) == 0x3bde0000) { /* addi 30,30,foo@l */
296 } else if ((op
& 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
298 fdata
->frameless
= 0;
299 /* Don't skip over the subroutine call if it is not within the first
300 three instructions of the prologue. */
301 if ((pc
- orig_pc
) > 8)
304 op
= read_memory_integer (pc
+4, 4);
306 /* At this point, make sure this is not a trampoline function
307 (a function that simply calls another functions, and nothing else).
308 If the next is not a nop, this branch was part of the function
311 if (op
== 0x4def7b82 || op
== 0) /* crorc 15, 15, 15 */
312 break; /* don't skip over this branch */
316 /* update stack pointer */
317 } else if ((op
& 0xffff0000) == 0x94210000) { /* stu r1,NUM(r1) */
318 fdata
->frameless
= 0;
319 fdata
->offset
= SIGNED_SHORT (op
);
320 offset
= fdata
->offset
;
323 } else if (op
== 0x7c21016e) { /* stwux 1,1,0 */
324 fdata
->frameless
= 0;
325 offset
= fdata
->offset
;
328 /* Load up minimal toc pointer */
329 } else if ((op
>> 22) == 0x20f
330 && ! minimal_toc_loaded
) { /* l r31,... or l r30,... */
331 minimal_toc_loaded
= 1;
334 /* store parameters in stack */
335 } else if ((op
& 0xfc1f0000) == 0x90010000 || /* st rx,NUM(r1) */
336 (op
& 0xfc1f0000) == 0xd8010000 || /* stfd Rx,NUM(r1) */
337 (op
& 0xfc1f0000) == 0xfc010000) { /* frsp, fp?,NUM(r1) */
340 /* store parameters in stack via frame pointer */
342 (op
& 0xfc1f0000) == 0x901f0000 || /* st rx,NUM(r1) */
343 (op
& 0xfc1f0000) == 0xd81f0000 || /* stfd Rx,NUM(r1) */
344 (op
& 0xfc1f0000) == 0xfc1f0000) { /* frsp, fp?,NUM(r1) */
347 /* Set up frame pointer */
348 } else if (op
== 0x603f0000 /* oril r31, r1, 0x0 */
349 || op
== 0x7c3f0b78) { /* mr r31, r1 */
350 fdata
->frameless
= 0;
352 fdata
->alloca_reg
= 31;
355 /* Another way to set up the frame pointer. */
356 } else if ((op
& 0xfc1fffff) == 0x38010000) { /* addi rX, r1, 0x0 */
357 fdata
->frameless
= 0;
359 fdata
->alloca_reg
= (op
& ~0x38010000) >> 21;
368 /* I have problems with skipping over __main() that I need to address
369 * sometime. Previously, I used to use misc_function_vector which
370 * didn't work as well as I wanted to be. -MGO */
372 /* If the first thing after skipping a prolog is a branch to a function,
373 this might be a call to an initializer in main(), introduced by gcc2.
374 We'd like to skip over it as well. Fortunately, xlc does some extra
375 work before calling a function right after a prologue, thus we can
376 single out such gcc2 behaviour. */
379 if ((op
& 0xfc000001) == 0x48000001) { /* bl foo, an initializer function? */
380 op
= read_memory_integer (pc
+4, 4);
382 if (op
== 0x4def7b82) { /* cror 0xf, 0xf, 0xf (nop) */
384 /* check and see if we are in main. If so, skip over this initializer
387 tmp
= find_pc_misc_function (pc
);
388 if (tmp
>= 0 && STREQ (misc_function_vector
[tmp
].name
, "main"))
394 fdata
->offset
= - fdata
->offset
;
399 /*************************************************************************
400 Support for creating pushind a dummy frame into the stack, and popping
402 *************************************************************************/
404 /* The total size of dummy frame is 436, which is;
409 and 24 extra bytes for the callee's link area. The last 24 bytes
410 for the link area might not be necessary, since it will be taken
411 care of by push_arguments(). */
413 #define DUMMY_FRAME_SIZE 436
415 #define DUMMY_FRAME_ADDR_SIZE 10
417 /* Make sure you initialize these in somewhere, in case gdb gives up what it
418 was debugging and starts debugging something else. FIXMEibm */
420 static int dummy_frame_count
= 0;
421 static int dummy_frame_size
= 0;
422 static CORE_ADDR
*dummy_frame_addr
= 0;
424 extern int stop_stack_dummy
;
426 /* push a dummy frame into stack, save all register. Currently we are saving
427 only gpr's and fpr's, which is not good enough! FIXMEmgo */
434 /* Same thing, target byte order. */
439 /* Same thing, target byte order. */
442 /* Needed to figure out where to save the dummy link area.
443 FIXME: There should be an easier way to do this, no? tiemann 9/9/95. */
444 struct rs6000_framedata fdata
;
448 target_fetch_registers (-1);
450 if (dummy_frame_count
>= dummy_frame_size
) {
451 dummy_frame_size
+= DUMMY_FRAME_ADDR_SIZE
;
452 if (dummy_frame_addr
)
453 dummy_frame_addr
= (CORE_ADDR
*) xrealloc
454 (dummy_frame_addr
, sizeof(CORE_ADDR
) * (dummy_frame_size
));
456 dummy_frame_addr
= (CORE_ADDR
*)
457 xmalloc (sizeof(CORE_ADDR
) * (dummy_frame_size
));
460 sp
= read_register(SP_REGNUM
);
461 pc
= read_register(PC_REGNUM
);
462 store_address (pc_targ
, 4, pc
);
464 (void) skip_prologue (get_pc_function_start (pc
) + FUNCTION_START_OFFSET
, &fdata
);
466 dummy_frame_addr
[dummy_frame_count
++] = sp
;
468 /* Be careful! If the stack pointer is not decremented first, then kernel
469 thinks he is free to use the space underneath it. And kernel actually
470 uses that area for IPC purposes when executing ptrace(2) calls. So
471 before writing register values into the new frame, decrement and update
472 %sp first in order to secure your frame. */
474 /* FIXME: We don't check if the stack really has this much space.
475 This is a problem on the ppc simulator (which only grants one page
476 (4096 bytes) by default. */
478 write_register (SP_REGNUM
, sp
-DUMMY_FRAME_SIZE
);
480 /* gdb relies on the state of current_frame. We'd better update it,
481 otherwise things like do_registers_info() wouldn't work properly! */
483 flush_cached_frames ();
485 /* save program counter in link register's space. */
486 write_memory (sp
+ (fdata
.lr_offset
? fdata
.lr_offset
: DEFAULT_LR_SAVE
),
489 /* save all floating point and general purpose registers here. */
492 for (ii
= 0; ii
< 32; ++ii
)
493 write_memory (sp
-8-(ii
*8), ®isters
[REGISTER_BYTE (31-ii
+FP0_REGNUM
)], 8);
496 for (ii
=1; ii
<=32; ++ii
)
497 write_memory (sp
-256-(ii
*4), ®isters
[REGISTER_BYTE (32-ii
)], 4);
499 /* so far, 32*2 + 32 words = 384 bytes have been written.
500 7 extra registers in our register set: pc, ps, cnd, lr, cnt, xer, mq */
502 for (ii
=1; ii
<= (LAST_SP_REGNUM
-FIRST_SP_REGNUM
+1); ++ii
) {
503 write_memory (sp
-384-(ii
*4),
504 ®isters
[REGISTER_BYTE (FPLAST_REGNUM
+ ii
)], 4);
507 /* Save sp or so called back chain right here. */
508 store_address (sp_targ
, 4, sp
);
509 write_memory (sp
-DUMMY_FRAME_SIZE
, sp_targ
, 4);
510 sp
-= DUMMY_FRAME_SIZE
;
512 /* And finally, this is the back chain. */
513 write_memory (sp
+8, pc_targ
, 4);
517 /* Pop a dummy frame.
519 In rs6000 when we push a dummy frame, we save all of the registers. This
520 is usually done before user calls a function explicitly.
522 After a dummy frame is pushed, some instructions are copied into stack,
523 and stack pointer is decremented even more. Since we don't have a frame
524 pointer to get back to the parent frame of the dummy, we start having
525 trouble poping it. Therefore, we keep a dummy frame stack, keeping
526 addresses of dummy frames as such. When poping happens and when we
527 detect that was a dummy frame, we pop it back to its parent by using
528 dummy frame stack (`dummy_frame_addr' array).
530 FIXME: This whole concept is broken. You should be able to detect
531 a dummy stack frame *on the user's stack itself*. When you do,
532 then you know the format of that stack frame -- including its
533 saved SP register! There should *not* be a separate stack in the
534 GDB process that keeps track of these dummy frames! -- gnu@cygnus.com Aug92
541 sp
= dummy_frame_addr
[--dummy_frame_count
];
543 /* restore all fpr's. */
544 for (ii
= 1; ii
<= 32; ++ii
)
545 read_memory (sp
-(ii
*8), ®isters
[REGISTER_BYTE (32-ii
+FP0_REGNUM
)], 8);
547 /* restore all gpr's */
548 for (ii
=1; ii
<= 32; ++ii
) {
549 read_memory (sp
-256-(ii
*4), ®isters
[REGISTER_BYTE (32-ii
)], 4);
552 /* restore the rest of the registers. */
553 for (ii
=1; ii
<=(LAST_SP_REGNUM
-FIRST_SP_REGNUM
+1); ++ii
)
554 read_memory (sp
-384-(ii
*4),
555 ®isters
[REGISTER_BYTE (FPLAST_REGNUM
+ ii
)], 4);
557 read_memory (sp
-(DUMMY_FRAME_SIZE
-8),
558 ®isters
[REGISTER_BYTE(PC_REGNUM
)], 4);
560 /* when a dummy frame was being pushed, we had to decrement %sp first, in
561 order to secure astack space. Thus, saved %sp (or %r1) value, is not the
562 one we should restore. Change it with the one we need. */
564 *(int*)®isters
[REGISTER_BYTE(FP_REGNUM
)] = sp
;
566 /* Now we can restore all registers. */
568 target_store_registers (-1);
570 flush_cached_frames ();
574 /* pop the innermost frame, go back to the caller. */
579 CORE_ADDR pc
, lr
, sp
, prev_sp
; /* %pc, %lr, %sp */
580 struct rs6000_framedata fdata
;
581 struct frame_info
*frame
= get_current_frame ();
585 sp
= FRAME_FP (frame
);
587 if (stop_stack_dummy
&& dummy_frame_count
) {
592 /* Make sure that all registers are valid. */
593 read_register_bytes (0, NULL
, REGISTER_BYTES
);
595 /* figure out previous %pc value. If the function is frameless, it is
596 still in the link register, otherwise walk the frames and retrieve the
597 saved %pc value in the previous frame. */
599 addr
= get_pc_function_start (frame
->pc
) + FUNCTION_START_OFFSET
;
600 (void) skip_prologue (addr
, &fdata
);
605 prev_sp
= read_memory_integer (sp
, 4);
606 if (fdata
.lr_offset
== 0)
607 lr
= read_register (LR_REGNUM
);
609 lr
= read_memory_integer (prev_sp
+ fdata
.lr_offset
, 4);
611 /* reset %pc value. */
612 write_register (PC_REGNUM
, lr
);
614 /* reset register values if any was saved earlier. */
615 addr
= prev_sp
- fdata
.offset
;
617 if (fdata
.saved_gpr
!= -1)
618 for (ii
= fdata
.saved_gpr
; ii
<= 31; ++ii
) {
619 read_memory (addr
, ®isters
[REGISTER_BYTE (ii
)], 4);
623 if (fdata
.saved_fpr
!= -1)
624 for (ii
= fdata
.saved_fpr
; ii
<= 31; ++ii
) {
625 read_memory (addr
, ®isters
[REGISTER_BYTE (ii
+FP0_REGNUM
)], 8);
629 write_register (SP_REGNUM
, prev_sp
);
630 target_store_registers (-1);
631 flush_cached_frames ();
634 /* fixup the call sequence of a dummy function, with the real function address.
635 its argumets will be passed by gdb. */
638 fix_call_dummy (dummyname
, pc
, fun
, nargs
, type
)
642 int nargs
; /* not used */
643 int type
; /* not used */
645 #define TOC_ADDR_OFFSET 20
646 #define TARGET_ADDR_OFFSET 28
649 CORE_ADDR target_addr
;
653 tocvalue
= find_toc_address (target_addr
);
655 ii
= *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
);
656 ii
= (ii
& 0xffff0000) | (tocvalue
>> 16);
657 *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
) = ii
;
659 ii
= *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
+4);
660 ii
= (ii
& 0xffff0000) | (tocvalue
& 0x0000ffff);
661 *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
+4) = ii
;
663 ii
= *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
);
664 ii
= (ii
& 0xffff0000) | (target_addr
>> 16);
665 *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
) = ii
;
667 ii
= *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
+4);
668 ii
= (ii
& 0xffff0000) | (target_addr
& 0x0000ffff);
669 *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
+4) = ii
;
672 /* Pass the arguments in either registers, or in the stack. In RS6000,
673 the first eight words of the argument list (that might be less than
674 eight parameters if some parameters occupy more than one word) are
675 passed in r3..r11 registers. float and double parameters are
676 passed in fpr's, in addition to that. Rest of the parameters if any
677 are passed in user stack. There might be cases in which half of the
678 parameter is copied into registers, the other half is pushed into
681 If the function is returning a structure, then the return address is passed
682 in r3, then the first 7 words of the parametes can be passed in registers,
686 push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
691 CORE_ADDR struct_addr
;
694 int argno
; /* current argument number */
695 int argbytes
; /* current argument byte */
696 char tmp_buffer
[50];
698 int f_argno
= 0; /* current floating point argno */
700 CORE_ADDR saved_sp
, pc
;
702 if ( dummy_frame_count
<= 0)
703 printf_unfiltered ("FATAL ERROR -push_arguments()! frame not found!!\n");
705 /* The first eight words of ther arguments are passed in registers. Copy
708 If the function is returning a `struct', then the first word (which
709 will be passed in r3) is used for struct return address. In that
710 case we should advance one word and start from r4 register to copy
713 ii
= struct_return
? 1 : 0;
715 for (argno
=0, argbytes
=0; argno
< nargs
&& ii
<8; ++ii
) {
718 len
= TYPE_LENGTH (VALUE_TYPE (arg
));
720 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FLT
) {
722 /* floating point arguments are passed in fpr's, as well as gpr's.
723 There are 13 fpr's reserved for passing parameters. At this point
724 there is no way we would run out of them. */
728 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
730 memcpy (®isters
[REGISTER_BYTE(FP0_REGNUM
+ 1 + f_argno
)], VALUE_CONTENTS (arg
),
737 /* Argument takes more than one register. */
738 while (argbytes
< len
) {
740 *(int*)®isters
[REGISTER_BYTE(ii
+3)] = 0;
741 memcpy (®isters
[REGISTER_BYTE(ii
+3)],
742 ((char*)VALUE_CONTENTS (arg
))+argbytes
,
743 (len
- argbytes
) > 4 ? 4 : len
- argbytes
);
747 goto ran_out_of_registers_for_arguments
;
752 else { /* Argument can fit in one register. No problem. */
753 *(int*)®isters
[REGISTER_BYTE(ii
+3)] = 0;
754 memcpy (®isters
[REGISTER_BYTE(ii
+3)], VALUE_CONTENTS (arg
), len
);
759 ran_out_of_registers_for_arguments
:
761 /* location for 8 parameters are always reserved. */
764 /* another six words for back chain, TOC register, link register, etc. */
767 /* if there are more arguments, allocate space for them in
768 the stack, then push them starting from the ninth one. */
770 if ((argno
< nargs
) || argbytes
) {
775 space
+= ((len
- argbytes
+ 3) & -4);
781 for (; jj
< nargs
; ++jj
) {
783 space
+= ((TYPE_LENGTH (VALUE_TYPE (val
))) + 3) & -4;
786 /* add location required for the rest of the parameters */
787 space
= (space
+ 7) & -8;
790 /* This is another instance we need to be concerned about securing our
791 stack space. If we write anything underneath %sp (r1), we might conflict
792 with the kernel who thinks he is free to use this area. So, update %sp
793 first before doing anything else. */
795 write_register (SP_REGNUM
, sp
);
797 /* if the last argument copied into the registers didn't fit there
798 completely, push the rest of it into stack. */
802 sp
+24+(ii
*4), ((char*)VALUE_CONTENTS (arg
))+argbytes
, len
- argbytes
);
804 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
807 /* push the rest of the arguments into stack. */
808 for (; argno
< nargs
; ++argno
) {
811 len
= TYPE_LENGTH (VALUE_TYPE (arg
));
814 /* float types should be passed in fpr's, as well as in the stack. */
815 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FLT
&& f_argno
< 13) {
819 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
821 memcpy (®isters
[REGISTER_BYTE(FP0_REGNUM
+ 1 + f_argno
)], VALUE_CONTENTS (arg
),
826 write_memory (sp
+24+(ii
*4), (char *) VALUE_CONTENTS (arg
), len
);
827 ii
+= ((len
+ 3) & -4) / 4;
831 /* Secure stack areas first, before doing anything else. */
832 write_register (SP_REGNUM
, sp
);
834 saved_sp
= dummy_frame_addr
[dummy_frame_count
- 1];
835 read_memory (saved_sp
, tmp_buffer
, 24);
836 write_memory (sp
, tmp_buffer
, 24);
838 /* set back chain properly */
839 store_address (tmp_buffer
, 4, saved_sp
);
840 write_memory (sp
, tmp_buffer
, 4);
842 target_store_registers (-1);
846 /* a given return value in `regbuf' with a type `valtype', extract and copy its
847 value into `valbuf' */
850 extract_return_value (valtype
, regbuf
, valbuf
)
851 struct type
*valtype
;
852 char regbuf
[REGISTER_BYTES
];
857 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
) {
860 /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes.
861 We need to truncate the return value into float size (4 byte) if
864 if (TYPE_LENGTH (valtype
) > 4) /* this is a double */
865 memcpy (valbuf
, ®buf
[REGISTER_BYTE (FP0_REGNUM
+ 1)],
866 TYPE_LENGTH (valtype
));
868 memcpy (&dd
, ®buf
[REGISTER_BYTE (FP0_REGNUM
+ 1)], 8);
870 memcpy (valbuf
, &ff
, sizeof(float));
874 /* return value is copied starting from r3. */
875 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
876 && TYPE_LENGTH (valtype
) < REGISTER_RAW_SIZE (3))
877 offset
= REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype
);
879 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (3) + offset
,
880 TYPE_LENGTH (valtype
));
885 /* keep structure return address in this variable.
886 FIXME: This is a horrid kludge which should not be allowed to continue
887 living. This only allows a single nested call to a structure-returning
888 function. Come on, guys! -- gnu@cygnus.com, Aug 92 */
890 CORE_ADDR rs6000_struct_return_address
;
893 /* Indirect function calls use a piece of trampoline code to do context
894 switching, i.e. to set the new TOC table. Skip such code if we are on
895 its first instruction (as when we have single-stepped to here).
896 Also skip shared library trampoline code (which is different from
897 indirect function call trampolines).
898 Result is desired PC to step until, or NULL if we are not in
902 skip_trampoline_code (pc
)
905 register unsigned int ii
, op
;
906 CORE_ADDR solib_target_pc
;
908 static unsigned trampoline_code
[] = {
909 0x800b0000, /* l r0,0x0(r11) */
910 0x90410014, /* st r2,0x14(r1) */
911 0x7c0903a6, /* mtctr r0 */
912 0x804b0004, /* l r2,0x4(r11) */
913 0x816b0008, /* l r11,0x8(r11) */
914 0x4e800420, /* bctr */
919 /* If pc is in a shared library trampoline, return its target. */
920 solib_target_pc
= find_solib_trampoline_target (pc
);
922 return solib_target_pc
;
924 for (ii
=0; trampoline_code
[ii
]; ++ii
) {
925 op
= read_memory_integer (pc
+ (ii
*4), 4);
926 if (op
!= trampoline_code
[ii
])
929 ii
= read_register (11); /* r11 holds destination addr */
930 pc
= read_memory_integer (ii
, 4); /* (r11) value */
934 /* Determines whether the function FI has a frame on the stack or not. */
937 frameless_function_invocation (fi
)
938 struct frame_info
*fi
;
940 CORE_ADDR func_start
;
941 struct rs6000_framedata fdata
;
943 if (fi
->next
!= NULL
)
944 /* Don't even think about framelessness except on the innermost frame. */
945 /* FIXME: Can also be frameless if fi->next->signal_handler_caller (if
946 a signal happens while executing in a frameless function). */
949 func_start
= get_pc_function_start (fi
->pc
) + FUNCTION_START_OFFSET
;
951 /* If we failed to find the start of the function, it is a mistake
952 to inspect the instructions. */
957 (void) skip_prologue (func_start
, &fdata
);
958 return fdata
.frameless
;
961 /* Return the PC saved in a frame */
965 struct frame_info
*fi
;
967 CORE_ADDR func_start
;
968 struct rs6000_framedata fdata
;
971 if (fi
->signal_handler_caller
)
972 return read_memory_integer (fi
->frame
+ SIG_FRAME_PC_OFFSET
, 4);
974 func_start
= get_pc_function_start (fi
->pc
) + FUNCTION_START_OFFSET
;
976 /* If we failed to find the start of the function, it is a mistake
977 to inspect the instructions. */
981 (void) skip_prologue (func_start
, &fdata
);
983 if (fdata
.lr_offset
== 0 && fi
->next
!= NULL
)
984 return read_memory_integer (rs6000_frame_chain (fi
) + DEFAULT_LR_SAVE
, 4);
986 if (fdata
.lr_offset
== 0)
987 return read_register (LR_REGNUM
);
989 return read_memory_integer (rs6000_frame_chain (fi
) + fdata
.lr_offset
, 4);
992 /* If saved registers of frame FI are not known yet, read and cache them.
993 &FDATAP contains rs6000_framedata; TDATAP can be NULL,
994 in which case the framedata are read. */
997 frame_get_cache_fsr (fi
, fdatap
)
998 struct frame_info
*fi
;
999 struct rs6000_framedata
*fdatap
;
1002 CORE_ADDR frame_addr
;
1003 struct rs6000_framedata work_fdata
;
1008 if (fdatap
== NULL
) {
1009 fdatap
= &work_fdata
;
1010 (void) skip_prologue (get_pc_function_start (fi
->pc
), fdatap
);
1013 fi
->cache_fsr
= (struct frame_saved_regs
*)
1014 obstack_alloc (&frame_cache_obstack
, sizeof (struct frame_saved_regs
));
1015 memset (fi
->cache_fsr
, '\0', sizeof (struct frame_saved_regs
));
1017 if (fi
->prev
&& fi
->prev
->frame
)
1018 frame_addr
= fi
->prev
->frame
;
1020 frame_addr
= read_memory_integer (fi
->frame
, 4);
1022 /* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr.
1023 All fpr's from saved_fpr to fp31 are saved. */
1025 if (fdatap
->saved_fpr
>= 0) {
1026 int fpr_offset
= frame_addr
+ fdatap
->fpr_offset
;
1027 for (ii
= fdatap
->saved_fpr
; ii
< 32; ii
++) {
1028 fi
->cache_fsr
->regs
[FP0_REGNUM
+ ii
] = fpr_offset
;
1033 /* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr.
1034 All gpr's from saved_gpr to gpr31 are saved. */
1036 if (fdatap
->saved_gpr
>= 0) {
1037 int gpr_offset
= frame_addr
+ fdatap
->gpr_offset
;
1038 for (ii
= fdatap
->saved_gpr
; ii
< 32; ii
++) {
1039 fi
->cache_fsr
->regs
[ii
] = gpr_offset
;
1044 /* If != 0, fdatap->cr_offset is the offset from the frame that holds
1046 if (fdatap
->cr_offset
!= 0)
1047 fi
->cache_fsr
->regs
[CR_REGNUM
] = frame_addr
+ fdatap
->cr_offset
;
1049 /* If != 0, fdatap->lr_offset is the offset from the frame that holds
1051 if (fdatap
->lr_offset
!= 0)
1052 fi
->cache_fsr
->regs
[LR_REGNUM
] = frame_addr
+ fdatap
->lr_offset
;
1055 /* Return the address of a frame. This is the inital %sp value when the frame
1056 was first allocated. For functions calling alloca(), it might be saved in
1057 an alloca register. */
1060 frame_initial_stack_address (fi
)
1061 struct frame_info
*fi
;
1064 struct rs6000_framedata fdata
;
1065 struct frame_info
*callee_fi
;
1067 /* if the initial stack pointer (frame address) of this frame is known,
1071 return fi
->initial_sp
;
1073 /* find out if this function is using an alloca register.. */
1075 (void) skip_prologue (get_pc_function_start (fi
->pc
), &fdata
);
1077 /* if saved registers of this frame are not known yet, read and cache them. */
1080 frame_get_cache_fsr (fi
, &fdata
);
1082 /* If no alloca register used, then fi->frame is the value of the %sp for
1083 this frame, and it is good enough. */
1085 if (fdata
.alloca_reg
< 0) {
1086 fi
->initial_sp
= fi
->frame
;
1087 return fi
->initial_sp
;
1090 /* This function has an alloca register. If this is the top-most frame
1091 (with the lowest address), the value in alloca register is good. */
1094 return fi
->initial_sp
= read_register (fdata
.alloca_reg
);
1096 /* Otherwise, this is a caller frame. Callee has usually already saved
1097 registers, but there are exceptions (such as when the callee
1098 has no parameters). Find the address in which caller's alloca
1099 register is saved. */
1101 for (callee_fi
= fi
->next
; callee_fi
; callee_fi
= callee_fi
->next
) {
1103 if (!callee_fi
->cache_fsr
)
1104 frame_get_cache_fsr (callee_fi
, NULL
);
1106 /* this is the address in which alloca register is saved. */
1108 tmpaddr
= callee_fi
->cache_fsr
->regs
[fdata
.alloca_reg
];
1110 fi
->initial_sp
= read_memory_integer (tmpaddr
, 4);
1111 return fi
->initial_sp
;
1114 /* Go look into deeper levels of the frame chain to see if any one of
1115 the callees has saved alloca register. */
1118 /* If alloca register was not saved, by the callee (or any of its callees)
1119 then the value in the register is still good. */
1121 return fi
->initial_sp
= read_register (fdata
.alloca_reg
);
1125 rs6000_frame_chain (thisframe
)
1126 struct frame_info
*thisframe
;
1129 if (inside_entry_file ((thisframe
)->pc
))
1131 if (thisframe
->signal_handler_caller
)
1132 fp
= read_memory_integer (thisframe
->frame
+ SIG_FRAME_FP_OFFSET
, 4);
1134 fp
= read_memory_integer ((thisframe
)->frame
, 4);
1139 /* Keep an array of load segment information and their TOC table addresses.
1140 This info will be useful when calling a shared library function by hand. */
1143 CORE_ADDR textorg
, dataorg
;
1144 unsigned long toc_offset
;
1147 #define LOADINFOLEN 10
1149 static struct loadinfo
*loadinfo
= NULL
;
1150 static int loadinfolen
= 0;
1151 static int loadinfotocindex
= 0;
1152 static int loadinfotextindex
= 0;
1156 xcoff_init_loadinfo ()
1158 loadinfotocindex
= 0;
1159 loadinfotextindex
= 0;
1161 if (loadinfolen
== 0) {
1162 loadinfo
= (struct loadinfo
*)
1163 xmalloc (sizeof (struct loadinfo
) * LOADINFOLEN
);
1164 loadinfolen
= LOADINFOLEN
;
1169 /* FIXME -- this is never called! */
1177 loadinfotocindex
= 0;
1178 loadinfotextindex
= 0;
1181 /* this is called from xcoffread.c */
1184 xcoff_add_toc_to_loadinfo (tocoff
)
1185 unsigned long tocoff
;
1187 while (loadinfotocindex
>= loadinfolen
) {
1188 loadinfolen
+= LOADINFOLEN
;
1189 loadinfo
= (struct loadinfo
*)
1190 xrealloc (loadinfo
, sizeof(struct loadinfo
) * loadinfolen
);
1192 loadinfo
[loadinfotocindex
++].toc_offset
= tocoff
;
1196 add_text_to_loadinfo (textaddr
, dataaddr
)
1200 while (loadinfotextindex
>= loadinfolen
) {
1201 loadinfolen
+= LOADINFOLEN
;
1202 loadinfo
= (struct loadinfo
*)
1203 xrealloc (loadinfo
, sizeof(struct loadinfo
) * loadinfolen
);
1205 loadinfo
[loadinfotextindex
].textorg
= textaddr
;
1206 loadinfo
[loadinfotextindex
].dataorg
= dataaddr
;
1207 ++loadinfotextindex
;
1211 /* Note that this assumes that the "textorg" and "dataorg" elements of
1212 a member of this array are correlated with the "toc_offset" element
1213 of the same member. This is taken care of because the loops which
1214 assign the former (in xcoff_relocate_symtab or xcoff_relocate_core)
1215 and the latter (in scan_xcoff_symtab, via vmap_symtab, in
1216 vmap_ldinfo or xcoff_relocate_core) traverse the same objfiles in
1220 find_toc_address (pc
)
1223 int ii
, toc_entry
, tocbase
= 0;
1226 for (ii
=0; ii
< loadinfotextindex
; ++ii
)
1227 if (pc
> loadinfo
[ii
].textorg
&& loadinfo
[ii
].textorg
> tocbase
) {
1229 tocbase
= loadinfo
[ii
].textorg
;
1232 if (toc_entry
== -1)
1233 error ("Unable to find TOC entry for pc 0x%x\n", pc
);
1234 return loadinfo
[toc_entry
].dataorg
+ loadinfo
[toc_entry
].toc_offset
;
1237 /* Return nonzero if ADDR (a function pointer) is in the data space and
1238 is therefore a special function pointer. */
1241 is_magic_function_pointer (addr
)
1244 struct obj_section
*s
;
1246 s
= find_pc_section (addr
);
1247 if (s
&& s
->the_bfd_section
->flags
& SEC_CODE
)
1253 #ifdef GDB_TARGET_POWERPC
1255 gdb_print_insn_powerpc (memaddr
, info
)
1257 disassemble_info
*info
;
1259 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1260 return print_insn_big_powerpc (memaddr
, info
);
1262 return print_insn_little_powerpc (memaddr
, info
);
1267 _initialize_rs6000_tdep ()
1269 /* FIXME, this should not be decided via ifdef. */
1270 #ifdef GDB_TARGET_POWERPC
1271 tm_print_insn
= gdb_print_insn_powerpc
;
1273 tm_print_insn
= print_insn_rs6000
;