1 /* Target-dependent code for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
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 /* Hook for determining the TOC address when calling functions in the
48 inferior under AIX. The initialization code in rs6000-nat.c sets
49 this hook to point to find_toc_address. */
51 CORE_ADDR (*find_toc_address_hook
) PARAMS ((CORE_ADDR
)) = NULL
;
53 /* Static function prototypes */
55 static CORE_ADDR branch_dest
PARAMS ((int opcode
, int instr
, CORE_ADDR pc
,
58 static void frame_get_cache_fsr
PARAMS ((struct frame_info
*fi
,
59 struct rs6000_framedata
*fdatap
));
61 static void pop_dummy_frame
PARAMS ((void));
63 /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
66 branch_dest (opcode
, instr
, pc
, safety
)
77 absolute
= (int) ((instr
>> 1) & 1);
81 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
85 dest
= pc
+ immediate
;
89 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
93 dest
= pc
+ immediate
;
97 ext_op
= (instr
>>1) & 0x3ff;
99 if (ext_op
== 16) /* br conditional register */
100 dest
= read_register (LR_REGNUM
) & ~3;
102 else if (ext_op
== 528) /* br cond to count reg */
104 dest
= read_register (CTR_REGNUM
) & ~3;
106 /* If we are about to execute a system call, dest is something
107 like 0x22fc or 0x3b00. Upon completion the system call
108 will return to the address in the link register. */
109 if (dest
< TEXT_SEGMENT_BASE
)
110 dest
= read_register (LR_REGNUM
) & ~3;
117 return (dest
< TEXT_SEGMENT_BASE
) ? safety
: dest
;
122 /* AIX does not support PT_STEP. Simulate it. */
126 enum target_signal signal
;
128 #define INSNLEN(OPCODE) 4
130 static char le_breakp
[] = LITTLE_BREAKPOINT
;
131 static char be_breakp
[] = BIG_BREAKPOINT
;
132 char *breakp
= TARGET_BYTE_ORDER
== BIG_ENDIAN
? be_breakp
: le_breakp
;
141 insn
= read_memory_integer (loc
, 4);
143 breaks
[0] = loc
+ INSNLEN(insn
);
145 breaks
[1] = branch_dest (opcode
, insn
, loc
, breaks
[0]);
147 /* Don't put two breakpoints on the same address. */
148 if (breaks
[1] == breaks
[0])
151 stepBreaks
[1].address
= 0;
153 for (ii
=0; ii
< 2; ++ii
) {
155 /* ignore invalid breakpoint. */
156 if ( breaks
[ii
] == -1)
159 read_memory (breaks
[ii
], stepBreaks
[ii
].data
, 4);
161 write_memory (breaks
[ii
], breakp
, 4);
162 stepBreaks
[ii
].address
= breaks
[ii
];
168 /* remove step breakpoints. */
169 for (ii
=0; ii
< 2; ++ii
)
170 if (stepBreaks
[ii
].address
!= 0)
172 (stepBreaks
[ii
].address
, stepBreaks
[ii
].data
, 4);
176 errno
= 0; /* FIXME, don't ignore errors! */
177 /* What errors? {read,write}_memory call error(). */
181 /* return pc value after skipping a function prologue and also return
182 information about a function frame.
184 in struct rs6000_frameinfo fdata:
185 - frameless is TRUE, if function does not have a frame.
186 - nosavedpc is TRUE, if function does not save %pc value in its frame.
187 - offset is the number of bytes used in the frame to save registers.
188 - saved_gpr is the number of the first saved gpr.
189 - saved_fpr is the number of the first saved fpr.
190 - alloca_reg is the number of the register used for alloca() handling.
192 - gpr_offset is the offset of the saved gprs
193 - fpr_offset is the offset of the saved fprs
194 - lr_offset is the offset of the saved lr
195 - cr_offset is the offset of the saved cr
198 #define SIGNED_SHORT(x) \
199 ((sizeof (short) == 2) \
200 ? ((int)(short)(x)) \
201 : ((int)((((x) & 0xffff) ^ 0x8000) - 0x8000)))
203 #define GET_SRC_REG(x) (((x) >> 21) & 0x1f)
206 skip_prologue (pc
, fdata
)
208 struct rs6000_framedata
*fdata
;
210 CORE_ADDR orig_pc
= pc
;
218 int minimal_toc_loaded
= 0;
219 static struct rs6000_framedata zero_frame
;
222 fdata
->saved_gpr
= -1;
223 fdata
->saved_fpr
= -1;
224 fdata
->alloca_reg
= -1;
225 fdata
->frameless
= 1;
226 fdata
->nosavedpc
= 1;
228 if (target_read_memory (pc
, buf
, 4))
229 return pc
; /* Can't access it -- assume no prologue. */
231 /* Assume that subsequent fetches can fail with low probability. */
236 op
= read_memory_integer (pc
, 4);
238 if ((op
& 0xfc1fffff) == 0x7c0802a6) { /* mflr Rx */
239 lr_reg
= (op
& 0x03e00000) | 0x90010000;
242 } else if ((op
& 0xfc1fffff) == 0x7c000026) { /* mfcr Rx */
243 cr_reg
= (op
& 0x03e00000) | 0x90010000;
246 } else if ((op
& 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
247 reg
= GET_SRC_REG (op
);
248 if (fdata
->saved_fpr
== -1 || fdata
->saved_fpr
> reg
) {
249 fdata
->saved_fpr
= reg
;
250 fdata
->fpr_offset
= SIGNED_SHORT (op
) + offset
;
254 } else if (((op
& 0xfc1f0000) == 0xbc010000) || /* stm Rx, NUM(r1) */
255 ((op
& 0xfc1f0000) == 0x90010000 && /* st rx,NUM(r1), rx >= r13 */
256 (op
& 0x03e00000) >= 0x01a00000)) {
258 reg
= GET_SRC_REG (op
);
259 if (fdata
->saved_gpr
== -1 || fdata
->saved_gpr
> reg
) {
260 fdata
->saved_gpr
= reg
;
261 fdata
->gpr_offset
= SIGNED_SHORT (op
) + offset
;
265 } else if ((op
& 0xffff0000) == 0x3c000000) { /* addis 0,0,NUM, used for >= 32k frames */
266 fdata
->offset
= (op
& 0x0000ffff) << 16;
267 fdata
->frameless
= 0;
270 } else if ((op
& 0xffff0000) == 0x60000000) { /* ori 0,0,NUM, 2nd half of >= 32k frames */
271 fdata
->offset
|= (op
& 0x0000ffff);
272 fdata
->frameless
= 0;
275 } else if ((op
& 0xffff0000) == lr_reg
) { /* st Rx,NUM(r1) where Rx == lr */
276 fdata
->lr_offset
= SIGNED_SHORT (op
) + offset
;
277 fdata
->nosavedpc
= 0;
281 } else if ((op
& 0xffff0000) == cr_reg
) { /* st Rx,NUM(r1) where Rx == cr */
282 fdata
->cr_offset
= SIGNED_SHORT (op
) + offset
;
286 } else if (op
== 0x48000005) { /* bl .+4 used in -mrelocatable */
289 } else if (op
== 0x48000004) { /* b .+4 (xlc) */
292 } else if (((op
& 0xffff0000) == 0x801e0000 || /* lwz 0,NUM(r30), used in V.4 -mrelocatable */
293 op
== 0x7fc0f214) && /* add r30,r0,r30, used in V.4 -mrelocatable */
294 lr_reg
== 0x901e0000) {
297 } else if ((op
& 0xffff0000) == 0x3fc00000 || /* addis 30,0,foo@ha, used in V.4 -mminimal-toc */
298 (op
& 0xffff0000) == 0x3bde0000) { /* addi 30,30,foo@l */
301 } else if ((op
& 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
303 fdata
->frameless
= 0;
304 /* Don't skip over the subroutine call if it is not within the first
305 three instructions of the prologue. */
306 if ((pc
- orig_pc
) > 8)
309 op
= read_memory_integer (pc
+4, 4);
311 /* At this point, make sure this is not a trampoline function
312 (a function that simply calls another functions, and nothing else).
313 If the next is not a nop, this branch was part of the function
316 if (op
== 0x4def7b82 || op
== 0) /* crorc 15, 15, 15 */
317 break; /* don't skip over this branch */
321 /* update stack pointer */
322 } else if ((op
& 0xffff0000) == 0x94210000) { /* stu r1,NUM(r1) */
323 fdata
->frameless
= 0;
324 fdata
->offset
= SIGNED_SHORT (op
);
325 offset
= fdata
->offset
;
328 } else if (op
== 0x7c21016e) { /* stwux 1,1,0 */
329 fdata
->frameless
= 0;
330 offset
= fdata
->offset
;
333 /* Load up minimal toc pointer */
334 } else if ((op
>> 22) == 0x20f
335 && ! minimal_toc_loaded
) { /* l r31,... or l r30,... */
336 minimal_toc_loaded
= 1;
339 /* store parameters in stack */
340 } else if ((op
& 0xfc1f0000) == 0x90010000 || /* st rx,NUM(r1) */
341 (op
& 0xfc1f0000) == 0xd8010000 || /* stfd Rx,NUM(r1) */
342 (op
& 0xfc1f0000) == 0xfc010000) { /* frsp, fp?,NUM(r1) */
345 /* store parameters in stack via frame pointer */
347 ((op
& 0xfc1f0000) == 0x901f0000 || /* st rx,NUM(r1) */
348 (op
& 0xfc1f0000) == 0xd81f0000 || /* stfd Rx,NUM(r1) */
349 (op
& 0xfc1f0000) == 0xfc1f0000)) { /* frsp, fp?,NUM(r1) */
352 /* Set up frame pointer */
353 } else if (op
== 0x603f0000 /* oril r31, r1, 0x0 */
354 || op
== 0x7c3f0b78) { /* mr r31, r1 */
355 fdata
->frameless
= 0;
357 fdata
->alloca_reg
= 31;
360 /* Another way to set up the frame pointer. */
361 } else if ((op
& 0xfc1fffff) == 0x38010000) { /* addi rX, r1, 0x0 */
362 fdata
->frameless
= 0;
364 fdata
->alloca_reg
= (op
& ~0x38010000) >> 21;
373 /* I have problems with skipping over __main() that I need to address
374 * sometime. Previously, I used to use misc_function_vector which
375 * didn't work as well as I wanted to be. -MGO */
377 /* If the first thing after skipping a prolog is a branch to a function,
378 this might be a call to an initializer in main(), introduced by gcc2.
379 We'd like to skip over it as well. Fortunately, xlc does some extra
380 work before calling a function right after a prologue, thus we can
381 single out such gcc2 behaviour. */
384 if ((op
& 0xfc000001) == 0x48000001) { /* bl foo, an initializer function? */
385 op
= read_memory_integer (pc
+4, 4);
387 if (op
== 0x4def7b82) { /* cror 0xf, 0xf, 0xf (nop) */
389 /* check and see if we are in main. If so, skip over this initializer
392 tmp
= find_pc_misc_function (pc
);
393 if (tmp
>= 0 && STREQ (misc_function_vector
[tmp
].name
, "main"))
399 fdata
->offset
= - fdata
->offset
;
404 /*************************************************************************
405 Support for creating pushind a dummy frame into the stack, and popping
407 *************************************************************************/
409 /* The total size of dummy frame is 436, which is;
414 and 24 extra bytes for the callee's link area. The last 24 bytes
415 for the link area might not be necessary, since it will be taken
416 care of by push_arguments(). */
418 #define DUMMY_FRAME_SIZE 436
420 #define DUMMY_FRAME_ADDR_SIZE 10
422 /* Make sure you initialize these in somewhere, in case gdb gives up what it
423 was debugging and starts debugging something else. FIXMEibm */
425 static int dummy_frame_count
= 0;
426 static int dummy_frame_size
= 0;
427 static CORE_ADDR
*dummy_frame_addr
= 0;
429 extern int stop_stack_dummy
;
431 /* push a dummy frame into stack, save all register. Currently we are saving
432 only gpr's and fpr's, which is not good enough! FIXMEmgo */
439 /* Same thing, target byte order. */
444 /* Same thing, target byte order. */
447 /* Needed to figure out where to save the dummy link area.
448 FIXME: There should be an easier way to do this, no? tiemann 9/9/95. */
449 struct rs6000_framedata fdata
;
453 target_fetch_registers (-1);
455 if (dummy_frame_count
>= dummy_frame_size
) {
456 dummy_frame_size
+= DUMMY_FRAME_ADDR_SIZE
;
457 if (dummy_frame_addr
)
458 dummy_frame_addr
= (CORE_ADDR
*) xrealloc
459 (dummy_frame_addr
, sizeof(CORE_ADDR
) * (dummy_frame_size
));
461 dummy_frame_addr
= (CORE_ADDR
*)
462 xmalloc (sizeof(CORE_ADDR
) * (dummy_frame_size
));
465 sp
= read_register(SP_REGNUM
);
466 pc
= read_register(PC_REGNUM
);
467 store_address (pc_targ
, 4, pc
);
469 (void) skip_prologue (get_pc_function_start (pc
) + FUNCTION_START_OFFSET
, &fdata
);
471 dummy_frame_addr
[dummy_frame_count
++] = sp
;
473 /* Be careful! If the stack pointer is not decremented first, then kernel
474 thinks he is free to use the space underneath it. And kernel actually
475 uses that area for IPC purposes when executing ptrace(2) calls. So
476 before writing register values into the new frame, decrement and update
477 %sp first in order to secure your frame. */
479 /* FIXME: We don't check if the stack really has this much space.
480 This is a problem on the ppc simulator (which only grants one page
481 (4096 bytes) by default. */
483 write_register (SP_REGNUM
, sp
-DUMMY_FRAME_SIZE
);
485 /* gdb relies on the state of current_frame. We'd better update it,
486 otherwise things like do_registers_info() wouldn't work properly! */
488 flush_cached_frames ();
490 /* save program counter in link register's space. */
491 write_memory (sp
+ (fdata
.lr_offset
? fdata
.lr_offset
: DEFAULT_LR_SAVE
),
494 /* save all floating point and general purpose registers here. */
497 for (ii
= 0; ii
< 32; ++ii
)
498 write_memory (sp
-8-(ii
*8), ®isters
[REGISTER_BYTE (31-ii
+FP0_REGNUM
)], 8);
501 for (ii
=1; ii
<=32; ++ii
)
502 write_memory (sp
-256-(ii
*4), ®isters
[REGISTER_BYTE (32-ii
)], 4);
504 /* so far, 32*2 + 32 words = 384 bytes have been written.
505 7 extra registers in our register set: pc, ps, cnd, lr, cnt, xer, mq */
507 for (ii
=1; ii
<= (LAST_SP_REGNUM
-FIRST_SP_REGNUM
+1); ++ii
) {
508 write_memory (sp
-384-(ii
*4),
509 ®isters
[REGISTER_BYTE (FPLAST_REGNUM
+ ii
)], 4);
512 /* Save sp or so called back chain right here. */
513 store_address (sp_targ
, 4, sp
);
514 write_memory (sp
-DUMMY_FRAME_SIZE
, sp_targ
, 4);
515 sp
-= DUMMY_FRAME_SIZE
;
517 /* And finally, this is the back chain. */
518 write_memory (sp
+8, pc_targ
, 4);
522 /* Pop a dummy frame.
524 In rs6000 when we push a dummy frame, we save all of the registers. This
525 is usually done before user calls a function explicitly.
527 After a dummy frame is pushed, some instructions are copied into stack,
528 and stack pointer is decremented even more. Since we don't have a frame
529 pointer to get back to the parent frame of the dummy, we start having
530 trouble poping it. Therefore, we keep a dummy frame stack, keeping
531 addresses of dummy frames as such. When poping happens and when we
532 detect that was a dummy frame, we pop it back to its parent by using
533 dummy frame stack (`dummy_frame_addr' array).
535 FIXME: This whole concept is broken. You should be able to detect
536 a dummy stack frame *on the user's stack itself*. When you do,
537 then you know the format of that stack frame -- including its
538 saved SP register! There should *not* be a separate stack in the
539 GDB process that keeps track of these dummy frames! -- gnu@cygnus.com Aug92
547 sp
= dummy_frame_addr
[--dummy_frame_count
];
549 /* restore all fpr's. */
550 for (ii
= 1; ii
<= 32; ++ii
)
551 read_memory (sp
-(ii
*8), ®isters
[REGISTER_BYTE (32-ii
+FP0_REGNUM
)], 8);
553 /* restore all gpr's */
554 for (ii
=1; ii
<= 32; ++ii
) {
555 read_memory (sp
-256-(ii
*4), ®isters
[REGISTER_BYTE (32-ii
)], 4);
558 /* restore the rest of the registers. */
559 for (ii
=1; ii
<=(LAST_SP_REGNUM
-FIRST_SP_REGNUM
+1); ++ii
)
560 read_memory (sp
-384-(ii
*4),
561 ®isters
[REGISTER_BYTE (FPLAST_REGNUM
+ ii
)], 4);
563 read_memory (sp
-(DUMMY_FRAME_SIZE
-8),
564 ®isters
[REGISTER_BYTE(PC_REGNUM
)], 4);
566 /* when a dummy frame was being pushed, we had to decrement %sp first, in
567 order to secure astack space. Thus, saved %sp (or %r1) value, is not the
568 one we should restore. Change it with the one we need. */
570 *(int*)®isters
[REGISTER_BYTE(FP_REGNUM
)] = sp
;
572 /* Now we can restore all registers. */
574 target_store_registers (-1);
576 flush_cached_frames ();
580 /* pop the innermost frame, go back to the caller. */
585 CORE_ADDR pc
, lr
, sp
, prev_sp
; /* %pc, %lr, %sp */
586 struct rs6000_framedata fdata
;
587 struct frame_info
*frame
= get_current_frame ();
591 sp
= FRAME_FP (frame
);
593 if (stop_stack_dummy
&& dummy_frame_count
) {
598 /* Make sure that all registers are valid. */
599 read_register_bytes (0, NULL
, REGISTER_BYTES
);
601 /* figure out previous %pc value. If the function is frameless, it is
602 still in the link register, otherwise walk the frames and retrieve the
603 saved %pc value in the previous frame. */
605 addr
= get_pc_function_start (frame
->pc
) + FUNCTION_START_OFFSET
;
606 (void) skip_prologue (addr
, &fdata
);
611 prev_sp
= read_memory_integer (sp
, 4);
612 if (fdata
.lr_offset
== 0)
613 lr
= read_register (LR_REGNUM
);
615 lr
= read_memory_integer (prev_sp
+ fdata
.lr_offset
, 4);
617 /* reset %pc value. */
618 write_register (PC_REGNUM
, lr
);
620 /* reset register values if any was saved earlier. */
621 addr
= prev_sp
- fdata
.offset
;
623 if (fdata
.saved_gpr
!= -1)
624 for (ii
= fdata
.saved_gpr
; ii
<= 31; ++ii
) {
625 read_memory (addr
, ®isters
[REGISTER_BYTE (ii
)], 4);
629 if (fdata
.saved_fpr
!= -1)
630 for (ii
= fdata
.saved_fpr
; ii
<= 31; ++ii
) {
631 read_memory (addr
, ®isters
[REGISTER_BYTE (ii
+FP0_REGNUM
)], 8);
635 write_register (SP_REGNUM
, prev_sp
);
636 target_store_registers (-1);
637 flush_cached_frames ();
640 /* fixup the call sequence of a dummy function, with the real function address.
641 its argumets will be passed by gdb. */
644 rs6000_fix_call_dummy (dummyname
, pc
, fun
, nargs
, args
, type
, gcc_p
)
653 #define TOC_ADDR_OFFSET 20
654 #define TARGET_ADDR_OFFSET 28
657 CORE_ADDR target_addr
;
659 if (find_toc_address_hook
!= NULL
)
663 tocvalue
= (*find_toc_address_hook
) (fun
);
664 ii
= *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
);
665 ii
= (ii
& 0xffff0000) | (tocvalue
>> 16);
666 *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
) = ii
;
668 ii
= *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
+4);
669 ii
= (ii
& 0xffff0000) | (tocvalue
& 0x0000ffff);
670 *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
+4) = ii
;
674 ii
= *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
);
675 ii
= (ii
& 0xffff0000) | (target_addr
>> 16);
676 *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
) = ii
;
678 ii
= *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
+4);
679 ii
= (ii
& 0xffff0000) | (target_addr
& 0x0000ffff);
680 *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
+4) = ii
;
683 /* Pass the arguments in either registers, or in the stack. In RS6000,
684 the first eight words of the argument list (that might be less than
685 eight parameters if some parameters occupy more than one word) are
686 passed in r3..r11 registers. float and double parameters are
687 passed in fpr's, in addition to that. Rest of the parameters if any
688 are passed in user stack. There might be cases in which half of the
689 parameter is copied into registers, the other half is pushed into
692 If the function is returning a structure, then the return address is passed
693 in r3, then the first 7 words of the parameters can be passed in registers,
697 push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
702 CORE_ADDR struct_addr
;
706 int argno
; /* current argument number */
707 int argbytes
; /* current argument byte */
708 char tmp_buffer
[50];
709 int f_argno
= 0; /* current floating point argno */
715 if ( dummy_frame_count
<= 0)
716 printf_unfiltered ("FATAL ERROR -push_arguments()! frame not found!!\n");
718 /* The first eight words of ther arguments are passed in registers. Copy
721 If the function is returning a `struct', then the first word (which
722 will be passed in r3) is used for struct return address. In that
723 case we should advance one word and start from r4 register to copy
726 ii
= struct_return
? 1 : 0;
728 for (argno
=0, argbytes
=0; argno
< nargs
&& ii
<8; ++ii
) {
731 type
= check_typedef (VALUE_TYPE (arg
));
732 len
= TYPE_LENGTH (type
);
734 if (TYPE_CODE (type
) == TYPE_CODE_FLT
) {
736 /* floating point arguments are passed in fpr's, as well as gpr's.
737 There are 13 fpr's reserved for passing parameters. At this point
738 there is no way we would run out of them. */
742 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
744 memcpy (®isters
[REGISTER_BYTE(FP0_REGNUM
+ 1 + f_argno
)], VALUE_CONTENTS (arg
),
751 /* Argument takes more than one register. */
752 while (argbytes
< len
) {
754 *(int*)®isters
[REGISTER_BYTE(ii
+3)] = 0;
755 memcpy (®isters
[REGISTER_BYTE(ii
+3)],
756 ((char*)VALUE_CONTENTS (arg
))+argbytes
,
757 (len
- argbytes
) > 4 ? 4 : len
- argbytes
);
761 goto ran_out_of_registers_for_arguments
;
766 else { /* Argument can fit in one register. No problem. */
767 *(int*)®isters
[REGISTER_BYTE(ii
+3)] = 0;
768 memcpy (®isters
[REGISTER_BYTE(ii
+3)], VALUE_CONTENTS (arg
), len
);
773 ran_out_of_registers_for_arguments
:
775 /* location for 8 parameters are always reserved. */
778 /* another six words for back chain, TOC register, link register, etc. */
781 /* if there are more arguments, allocate space for them in
782 the stack, then push them starting from the ninth one. */
784 if ((argno
< nargs
) || argbytes
) {
788 space
+= ((len
- argbytes
+ 3) & -4);
794 for (; jj
< nargs
; ++jj
) {
795 value_ptr val
= args
[jj
];
796 space
+= ((TYPE_LENGTH (VALUE_TYPE (val
))) + 3) & -4;
799 /* add location required for the rest of the parameters */
800 space
= (space
+ 7) & -8;
803 /* This is another instance we need to be concerned about securing our
804 stack space. If we write anything underneath %sp (r1), we might conflict
805 with the kernel who thinks he is free to use this area. So, update %sp
806 first before doing anything else. */
808 write_register (SP_REGNUM
, sp
);
810 /* if the last argument copied into the registers didn't fit there
811 completely, push the rest of it into stack. */
815 sp
+24+(ii
*4), ((char*)VALUE_CONTENTS (arg
))+argbytes
, len
- argbytes
);
817 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
820 /* push the rest of the arguments into stack. */
821 for (; argno
< nargs
; ++argno
) {
824 type
= check_typedef (VALUE_TYPE (arg
));
825 len
= TYPE_LENGTH (type
);
828 /* float types should be passed in fpr's, as well as in the stack. */
829 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& f_argno
< 13) {
833 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
835 memcpy (®isters
[REGISTER_BYTE(FP0_REGNUM
+ 1 + f_argno
)], VALUE_CONTENTS (arg
),
840 write_memory (sp
+24+(ii
*4), (char *) VALUE_CONTENTS (arg
), len
);
841 ii
+= ((len
+ 3) & -4) / 4;
845 /* Secure stack areas first, before doing anything else. */
846 write_register (SP_REGNUM
, sp
);
848 saved_sp
= dummy_frame_addr
[dummy_frame_count
- 1];
849 read_memory (saved_sp
, tmp_buffer
, 24);
850 write_memory (sp
, tmp_buffer
, 24);
852 /* set back chain properly */
853 store_address (tmp_buffer
, 4, saved_sp
);
854 write_memory (sp
, tmp_buffer
, 4);
856 target_store_registers (-1);
860 /* a given return value in `regbuf' with a type `valtype', extract and copy its
861 value into `valbuf' */
864 extract_return_value (valtype
, regbuf
, valbuf
)
865 struct type
*valtype
;
866 char regbuf
[REGISTER_BYTES
];
871 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
) {
874 /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes.
875 We need to truncate the return value into float size (4 byte) if
878 if (TYPE_LENGTH (valtype
) > 4) /* this is a double */
879 memcpy (valbuf
, ®buf
[REGISTER_BYTE (FP0_REGNUM
+ 1)],
880 TYPE_LENGTH (valtype
));
882 memcpy (&dd
, ®buf
[REGISTER_BYTE (FP0_REGNUM
+ 1)], 8);
884 memcpy (valbuf
, &ff
, sizeof(float));
888 /* return value is copied starting from r3. */
889 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
890 && TYPE_LENGTH (valtype
) < REGISTER_RAW_SIZE (3))
891 offset
= REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype
);
893 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (3) + offset
,
894 TYPE_LENGTH (valtype
));
899 /* keep structure return address in this variable.
900 FIXME: This is a horrid kludge which should not be allowed to continue
901 living. This only allows a single nested call to a structure-returning
902 function. Come on, guys! -- gnu@cygnus.com, Aug 92 */
904 CORE_ADDR rs6000_struct_return_address
;
907 /* Indirect function calls use a piece of trampoline code to do context
908 switching, i.e. to set the new TOC table. Skip such code if we are on
909 its first instruction (as when we have single-stepped to here).
910 Also skip shared library trampoline code (which is different from
911 indirect function call trampolines).
912 Result is desired PC to step until, or NULL if we are not in
916 skip_trampoline_code (pc
)
919 register unsigned int ii
, op
;
920 CORE_ADDR solib_target_pc
;
922 static unsigned trampoline_code
[] = {
923 0x800b0000, /* l r0,0x0(r11) */
924 0x90410014, /* st r2,0x14(r1) */
925 0x7c0903a6, /* mtctr r0 */
926 0x804b0004, /* l r2,0x4(r11) */
927 0x816b0008, /* l r11,0x8(r11) */
928 0x4e800420, /* bctr */
933 /* If pc is in a shared library trampoline, return its target. */
934 solib_target_pc
= find_solib_trampoline_target (pc
);
936 return solib_target_pc
;
938 for (ii
=0; trampoline_code
[ii
]; ++ii
) {
939 op
= read_memory_integer (pc
+ (ii
*4), 4);
940 if (op
!= trampoline_code
[ii
])
943 ii
= read_register (11); /* r11 holds destination addr */
944 pc
= read_memory_integer (ii
, 4); /* (r11) value */
948 /* Determines whether the function FI has a frame on the stack or not. */
951 frameless_function_invocation (fi
)
952 struct frame_info
*fi
;
954 CORE_ADDR func_start
;
955 struct rs6000_framedata fdata
;
957 /* Don't even think about framelessness except on the innermost frame
958 or if the function was interrupted by a signal. */
959 if (fi
->next
!= NULL
&& !fi
->next
->signal_handler_caller
)
962 func_start
= get_pc_function_start (fi
->pc
);
964 /* If we failed to find the start of the function, it is a mistake
965 to inspect the instructions. */
969 /* A frame with a zero PC is usually created by dereferencing a NULL
970 function pointer, normally causing an immediate core dump of the
971 inferior. Mark function as frameless, as the inferior has no chance
972 of setting up a stack frame. */
979 func_start
+= FUNCTION_START_OFFSET
;
980 (void) skip_prologue (func_start
, &fdata
);
981 return fdata
.frameless
;
984 /* Return the PC saved in a frame */
988 struct frame_info
*fi
;
990 CORE_ADDR func_start
;
991 struct rs6000_framedata fdata
;
993 if (fi
->signal_handler_caller
)
994 return read_memory_integer (fi
->frame
+ SIG_FRAME_PC_OFFSET
, 4);
996 func_start
= get_pc_function_start (fi
->pc
) + FUNCTION_START_OFFSET
;
998 /* If we failed to find the start of the function, it is a mistake
999 to inspect the instructions. */
1003 (void) skip_prologue (func_start
, &fdata
);
1005 if (fdata
.lr_offset
== 0 && fi
->next
!= NULL
)
1007 if (fi
->next
->signal_handler_caller
)
1008 return read_memory_integer (fi
->next
->frame
+ SIG_FRAME_LR_OFFSET
, 4);
1010 return read_memory_integer (rs6000_frame_chain (fi
) + DEFAULT_LR_SAVE
,
1014 if (fdata
.lr_offset
== 0)
1015 return read_register (LR_REGNUM
);
1017 return read_memory_integer (rs6000_frame_chain (fi
) + fdata
.lr_offset
, 4);
1020 /* If saved registers of frame FI are not known yet, read and cache them.
1021 &FDATAP contains rs6000_framedata; TDATAP can be NULL,
1022 in which case the framedata are read. */
1025 frame_get_cache_fsr (fi
, fdatap
)
1026 struct frame_info
*fi
;
1027 struct rs6000_framedata
*fdatap
;
1030 CORE_ADDR frame_addr
;
1031 struct rs6000_framedata work_fdata
;
1036 if (fdatap
== NULL
) {
1037 fdatap
= &work_fdata
;
1038 (void) skip_prologue (get_pc_function_start (fi
->pc
), fdatap
);
1041 fi
->cache_fsr
= (struct frame_saved_regs
*)
1042 obstack_alloc (&frame_cache_obstack
, sizeof (struct frame_saved_regs
));
1043 memset (fi
->cache_fsr
, '\0', sizeof (struct frame_saved_regs
));
1045 if (fi
->prev
&& fi
->prev
->frame
)
1046 frame_addr
= fi
->prev
->frame
;
1048 frame_addr
= read_memory_integer (fi
->frame
, 4);
1050 /* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr.
1051 All fpr's from saved_fpr to fp31 are saved. */
1053 if (fdatap
->saved_fpr
>= 0) {
1054 int fpr_offset
= frame_addr
+ fdatap
->fpr_offset
;
1055 for (ii
= fdatap
->saved_fpr
; ii
< 32; ii
++) {
1056 fi
->cache_fsr
->regs
[FP0_REGNUM
+ ii
] = fpr_offset
;
1061 /* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr.
1062 All gpr's from saved_gpr to gpr31 are saved. */
1064 if (fdatap
->saved_gpr
>= 0) {
1065 int gpr_offset
= frame_addr
+ fdatap
->gpr_offset
;
1066 for (ii
= fdatap
->saved_gpr
; ii
< 32; ii
++) {
1067 fi
->cache_fsr
->regs
[ii
] = gpr_offset
;
1072 /* If != 0, fdatap->cr_offset is the offset from the frame that holds
1074 if (fdatap
->cr_offset
!= 0)
1075 fi
->cache_fsr
->regs
[CR_REGNUM
] = frame_addr
+ fdatap
->cr_offset
;
1077 /* If != 0, fdatap->lr_offset is the offset from the frame that holds
1079 if (fdatap
->lr_offset
!= 0)
1080 fi
->cache_fsr
->regs
[LR_REGNUM
] = frame_addr
+ fdatap
->lr_offset
;
1083 /* Return the address of a frame. This is the inital %sp value when the frame
1084 was first allocated. For functions calling alloca(), it might be saved in
1085 an alloca register. */
1088 frame_initial_stack_address (fi
)
1089 struct frame_info
*fi
;
1092 struct rs6000_framedata fdata
;
1093 struct frame_info
*callee_fi
;
1095 /* if the initial stack pointer (frame address) of this frame is known,
1099 return fi
->initial_sp
;
1101 /* find out if this function is using an alloca register.. */
1103 (void) skip_prologue (get_pc_function_start (fi
->pc
), &fdata
);
1105 /* if saved registers of this frame are not known yet, read and cache them. */
1108 frame_get_cache_fsr (fi
, &fdata
);
1110 /* If no alloca register used, then fi->frame is the value of the %sp for
1111 this frame, and it is good enough. */
1113 if (fdata
.alloca_reg
< 0) {
1114 fi
->initial_sp
= fi
->frame
;
1115 return fi
->initial_sp
;
1118 /* This function has an alloca register. If this is the top-most frame
1119 (with the lowest address), the value in alloca register is good. */
1122 return fi
->initial_sp
= read_register (fdata
.alloca_reg
);
1124 /* Otherwise, this is a caller frame. Callee has usually already saved
1125 registers, but there are exceptions (such as when the callee
1126 has no parameters). Find the address in which caller's alloca
1127 register is saved. */
1129 for (callee_fi
= fi
->next
; callee_fi
; callee_fi
= callee_fi
->next
) {
1131 if (!callee_fi
->cache_fsr
)
1132 frame_get_cache_fsr (callee_fi
, NULL
);
1134 /* this is the address in which alloca register is saved. */
1136 tmpaddr
= callee_fi
->cache_fsr
->regs
[fdata
.alloca_reg
];
1138 fi
->initial_sp
= read_memory_integer (tmpaddr
, 4);
1139 return fi
->initial_sp
;
1142 /* Go look into deeper levels of the frame chain to see if any one of
1143 the callees has saved alloca register. */
1146 /* If alloca register was not saved, by the callee (or any of its callees)
1147 then the value in the register is still good. */
1149 return fi
->initial_sp
= read_register (fdata
.alloca_reg
);
1153 rs6000_frame_chain (thisframe
)
1154 struct frame_info
*thisframe
;
1157 if (inside_entry_file ((thisframe
)->pc
))
1159 if (thisframe
->signal_handler_caller
)
1160 fp
= read_memory_integer (thisframe
->frame
+ SIG_FRAME_FP_OFFSET
, 4);
1161 else if (thisframe
->next
!= NULL
1162 && thisframe
->next
->signal_handler_caller
1163 && frameless_function_invocation (thisframe
))
1164 /* A frameless function interrupted by a signal did not change the
1166 fp
= FRAME_FP (thisframe
);
1168 fp
= read_memory_integer ((thisframe
)->frame
, 4);
1173 /* Return nonzero if ADDR (a function pointer) is in the data space and
1174 is therefore a special function pointer. */
1177 is_magic_function_pointer (addr
)
1180 struct obj_section
*s
;
1182 s
= find_pc_section (addr
);
1183 if (s
&& s
->the_bfd_section
->flags
& SEC_CODE
)
1189 #ifdef GDB_TARGET_POWERPC
1191 gdb_print_insn_powerpc (memaddr
, info
)
1193 disassemble_info
*info
;
1195 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1196 return print_insn_big_powerpc (memaddr
, info
);
1198 return print_insn_little_powerpc (memaddr
, info
);
1203 _initialize_rs6000_tdep ()
1205 /* FIXME, this should not be decided via ifdef. */
1206 #ifdef GDB_TARGET_POWERPC
1207 tm_print_insn
= gdb_print_insn_powerpc
;
1209 tm_print_insn
= print_insn_rs6000
;