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., 675 Mass Ave, Cambridge, MA 02139, USA. */
28 #include "xcoffsolib.h"
32 extern struct obstack frame_cache_obstack
;
36 /* Nonzero if we just simulated a single step break. */
39 /* Breakpoint shadows for the single step instructions will be kept here. */
41 static struct sstep_breaks
{
42 /* Address, or 0 if this is not in use. */
44 /* Shadow contents. */
48 /* Static function prototypes */
51 find_toc_address
PARAMS ((CORE_ADDR pc
));
54 branch_dest
PARAMS ((int opcode
, int instr
, CORE_ADDR pc
, CORE_ADDR safety
));
57 frame_get_cache_fsr
PARAMS ((struct frame_info
*fi
,
58 struct rs6000_framedata
*fdatap
));
61 * Calculate the destination of a branch/jump. Return -1 if not a branch.
64 branch_dest (opcode
, instr
, pc
, safety
)
76 absolute
= (int) ((instr
>> 1) & 1);
80 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
84 dest
= pc
+ immediate
;
88 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
92 dest
= pc
+ immediate
;
96 ext_op
= (instr
>>1) & 0x3ff;
98 if (ext_op
== 16) /* br conditional register */
99 dest
= read_register (LR_REGNUM
) & ~3;
101 else if (ext_op
== 528) /* br cond to count reg */
103 dest
= read_register (CTR_REGNUM
) & ~3;
105 /* If we are about to execute a system call, dest is something
106 like 0x22fc or 0x3b00. Upon completion the system call
107 will return to the address in the link register. */
108 if (dest
< TEXT_SEGMENT_BASE
)
109 dest
= read_register (LR_REGNUM
) & ~3;
116 return (dest
< TEXT_SEGMENT_BASE
) ? safety
: dest
;
121 /* AIX does not support PT_STEP. Simulate it. */
127 #define INSNLEN(OPCODE) 4
129 static char le_breakp
[] = LITTLE_BREAKPOINT
;
130 static char be_breakp
[] = BIG_BREAKPOINT
;
131 char *breakp
= TARGET_BYTE_ORDER
== BIG_ENDIAN
? be_breakp
: le_breakp
;
140 insn
= read_memory_integer (loc
, 4);
142 breaks
[0] = loc
+ INSNLEN(insn
);
144 breaks
[1] = branch_dest (opcode
, insn
, loc
, breaks
[0]);
146 /* Don't put two breakpoints on the same address. */
147 if (breaks
[1] == breaks
[0])
150 stepBreaks
[1].address
= 0;
152 for (ii
=0; ii
< 2; ++ii
) {
154 /* ignore invalid breakpoint. */
155 if ( breaks
[ii
] == -1)
158 read_memory (breaks
[ii
], stepBreaks
[ii
].data
, 4);
160 write_memory (breaks
[ii
], breakp
, 4);
161 stepBreaks
[ii
].address
= breaks
[ii
];
167 /* remove step breakpoints. */
168 for (ii
=0; ii
< 2; ++ii
)
169 if (stepBreaks
[ii
].address
!= 0)
171 (stepBreaks
[ii
].address
, stepBreaks
[ii
].data
, 4);
175 errno
= 0; /* FIXME, don't ignore errors! */
176 /* What errors? {read,write}_memory call error(). */
180 /* return pc value after skipping a function prologue and also return
181 information about a function frame.
183 in struct rs6000_frameinfo fdata:
184 - frameless is TRUE, if function does not have a frame.
185 - nosavedpc is TRUE, if function does not save %pc value in its frame.
186 - offset is the number of bytes used in the frame to save registers.
187 - saved_gpr is the number of the first saved gpr.
188 - saved_fpr is the number of the first saved fpr.
189 - alloca_reg is the number of the register used for alloca() handling.
191 - gpr_offset is the offset of the saved gprs
192 - fpr_offset is the offset of the saved fprs
193 - lr_offset is the offset of the saved lr
194 - cr_offset is the offset of the saved cr
197 #define SIGNED_SHORT(x) \
198 ((sizeof (short) == 2) \
199 ? ((int)(short)(x)) \
200 : ((int)((((x) & 0xffff) ^ 0x8000) - 0x8000)))
202 #define GET_SRC_REG(x) (((x) >> 21) & 0x1f)
205 skip_prologue (pc
, fdata
)
207 struct rs6000_framedata
*fdata
;
209 CORE_ADDR orig_pc
= pc
;
215 static struct rs6000_framedata zero_frame
;
218 fdata
->saved_gpr
= -1;
219 fdata
->saved_fpr
= -1;
220 fdata
->alloca_reg
= -1;
221 fdata
->frameless
= 1;
222 fdata
->nosavedpc
= 1;
224 if (target_read_memory (pc
, buf
, 4))
225 return pc
; /* Can't access it -- assume no prologue. */
227 /* Assume that subsequent fetches can fail with low probability. */
232 op
= read_memory_integer (pc
, 4);
234 if ((op
& 0xfc1fffff) == 0x7c0802a6) { /* mflr Rx */
235 lr_reg
= (op
& 0x03e00000) | 0x90010000;
238 } else if ((op
& 0xfc1fffff) == 0x7c000026) { /* mfcr Rx */
239 cr_reg
= (op
& 0x03e00000) | 0x90010000;
242 } else if ((op
& 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
243 reg
= GET_SRC_REG (op
);
244 if (fdata
->saved_fpr
== -1 || fdata
->saved_fpr
> reg
) {
245 fdata
->saved_fpr
= reg
;
246 fdata
->fpr_offset
= SIGNED_SHORT (op
);
250 } else if (((op
& 0xfc1f0000) == 0xbc010000) || /* stm Rx, NUM(r1) */
251 ((op
& 0xfc1f0000) == 0x90010000 && /* st rx,NUM(r1), rx >= r13 */
252 (op
& 0x03e00000) >= 0x01a00000)) {
254 reg
= GET_SRC_REG (op
);
255 if (fdata
->saved_gpr
== -1 || fdata
->saved_gpr
> reg
) {
256 fdata
->saved_gpr
= reg
;
257 fdata
->gpr_offset
= SIGNED_SHORT (op
);
261 } else if ((op
& 0xffff0000) == 0x3c000000) { /* addis 0,0,NUM, used for >= 32k frames */
262 fdata
->offset
= (op
& 0x0000ffff) << 16;
265 } else if ((op
& 0xffff0000) == 0x60000000) { /* ori 0,0,NUM, 2nd half of >= 32k frames */
266 fdata
->offset
|= (op
& 0x0000ffff);
269 } else if ((op
& 0xffff0000) == lr_reg
) { /* st Rx,NUM(r1) where Rx == lr */
270 fdata
->lr_offset
= SIGNED_SHORT (op
);
271 fdata
->nosavedpc
= 0;
275 } else if ((op
& 0xffff0000) == cr_reg
) { /* st Rx,NUM(r1) where Rx == cr */
276 fdata
->cr_offset
= SIGNED_SHORT (op
);
280 } else if ((op
& 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
281 op
= read_memory_integer (pc
+4, 4);
283 /* At this point, make sure this is not a trampoline function
284 (a function that simply calls another functions, and nothing else).
285 If the next is not a nop, this branch was part of the function
288 if (op
== 0x4def7b82 || op
== 0) /* crorc 15, 15, 15 */
289 return pc
; /* don't skip over this branch */
293 } else if ((op
& 0xffff0000) == 0x94210000) { /* stu r1,NUM(r1) */
294 fdata
->offset
= - SIGNED_SHORT (op
);
296 op
= read_memory_integer (pc
, 4);
299 } else if (op
== 0x7c21016e) { /* stwux 1,1,0 */
300 pc
+= 4; /* offset set above */
301 op
= read_memory_integer (pc
, 4);
309 /* Skip -mreloctable (V.4/eabi) load up the toc case */
310 if (op
== 0x48000005 && /* bl .+4 */
311 read_memory_integer (pc
+4, 4) == 0x7fc802a6 && /* mflr r30 */
312 (read_memory_integer (pc
+8, 4) & 0xffff) == 0x801e0000 && /* lwz 0,NUM(r30) */
313 read_memory_integer (pc
+12, 4) == 0x7fc0f214) { /* add r30,r0,r30 */
315 op
= read_memory_integer (pc
, 4);
317 /* And -mminimal-toc code on V.4 */
318 } else if ((op
& 0xffff0000) == 0x3fc00000 && /* addis 30,0,foo@ha */
319 /* addi 30,30,foo@l */
320 ((read_memory_integer (pc
+4, 4) & 0xffff0000) == 0x3bde0000)) {
322 op
= read_memory_integer (pc
, 8);
325 while ((op
>> 22) == 0x20f) { /* l r31, ... or */
326 pc
+= 4; /* l r30, ... */
327 op
= read_memory_integer (pc
, 4);
330 /* store parameters into stack */
332 (op
& 0xfc1f0000) == 0x90010000 || /* st rx,NUM(r1) */
333 (op
& 0xfc1f0000) == 0xd8010000 || /* stfd Rx,NUM(r1) */
334 (op
& 0xfc1f0000) == 0xfc010000) { /* frsp, fp?,NUM(r1) */
336 op
= read_memory_integer (pc
, 4);
339 /* Set up frame pointer */
340 if (op
== 0x603f0000 /* oril r31, r1, 0x0 */
341 || op
== 0x7c3f0b78) { /* mr r31, r1 */
342 pc
+= 4; /* this happens if r31 is used as */
343 op
= read_memory_integer (pc
, 4); /* frame ptr. (gcc does that) */
345 /* store parameters into frame */
347 (op
& 0xfc1f0000) == 0x901f0000 || /* st rx,NUM(r1) */
348 (op
& 0xfc1f0000) == 0xd81f0000 || /* stfd Rx,NUM(r1) */
349 (op
& 0xfc1f0000) == 0xfc1f0000) { /* frsp, fp?,NUM(r1) */
351 op
= read_memory_integer (pc
, 4);
356 /* I have problems with skipping over __main() that I need to address
357 * sometime. Previously, I used to use misc_function_vector which
358 * didn't work as well as I wanted to be. -MGO */
360 /* If the first thing after skipping a prolog is a branch to a function,
361 this might be a call to an initializer in main(), introduced by gcc2.
362 We'd like to skip over it as well. Fortunately, xlc does some extra
363 work before calling a function right after a prologue, thus we can
364 single out such gcc2 behaviour. */
367 if ((op
& 0xfc000001) == 0x48000001) { /* bl foo, an initializer function? */
368 op
= read_memory_integer (pc
+4, 4);
370 if (op
== 0x4def7b82) { /* cror 0xf, 0xf, 0xf (nop) */
372 /* check and see if we are in main. If so, skip over this initializer
375 tmp
= find_pc_misc_function (pc
);
376 if (tmp
>= 0 && STREQ (misc_function_vector
[tmp
].name
, "main"))
382 fdata
->frameless
= (pc
== orig_pc
);
387 /*************************************************************************
388 Support for creating pushind a dummy frame into the stack, and popping
390 *************************************************************************/
392 /* The total size of dummy frame is 436, which is;
397 and 24 extra bytes for the callee's link area. The last 24 bytes
398 for the link area might not be necessary, since it will be taken
399 care of by push_arguments(). */
401 #define DUMMY_FRAME_SIZE 436
403 #define DUMMY_FRAME_ADDR_SIZE 10
405 /* Make sure you initialize these in somewhere, in case gdb gives up what it
406 was debugging and starts debugging something else. FIXMEibm */
408 static int dummy_frame_count
= 0;
409 static int dummy_frame_size
= 0;
410 static CORE_ADDR
*dummy_frame_addr
= 0;
412 extern int stop_stack_dummy
;
414 /* push a dummy frame into stack, save all register. Currently we are saving
415 only gpr's and fpr's, which is not good enough! FIXMEmgo */
422 /* Same thing, target byte order. */
427 /* Same thing, target byte order. */
432 target_fetch_registers (-1);
434 if (dummy_frame_count
>= dummy_frame_size
) {
435 dummy_frame_size
+= DUMMY_FRAME_ADDR_SIZE
;
436 if (dummy_frame_addr
)
437 dummy_frame_addr
= (CORE_ADDR
*) xrealloc
438 (dummy_frame_addr
, sizeof(CORE_ADDR
) * (dummy_frame_size
));
440 dummy_frame_addr
= (CORE_ADDR
*)
441 xmalloc (sizeof(CORE_ADDR
) * (dummy_frame_size
));
444 sp
= read_register(SP_REGNUM
);
445 pc
= read_register(PC_REGNUM
);
446 store_address (pc_targ
, 4, pc
);
448 dummy_frame_addr
[dummy_frame_count
++] = sp
;
450 /* Be careful! If the stack pointer is not decremented first, then kernel
451 thinks he is free to use the space underneath it. And kernel actually
452 uses that area for IPC purposes when executing ptrace(2) calls. So
453 before writing register values into the new frame, decrement and update
454 %sp first in order to secure your frame. */
456 write_register (SP_REGNUM
, sp
-DUMMY_FRAME_SIZE
);
458 /* gdb relies on the state of current_frame. We'd better update it,
459 otherwise things like do_registers_info() wouldn't work properly! */
461 flush_cached_frames ();
463 /* save program counter in link register's space. */
464 write_memory (sp
+8, pc_targ
, 4);
466 /* save all floating point and general purpose registers here. */
469 for (ii
= 0; ii
< 32; ++ii
)
470 write_memory (sp
-8-(ii
*8), ®isters
[REGISTER_BYTE (31-ii
+FP0_REGNUM
)], 8);
473 for (ii
=1; ii
<=32; ++ii
)
474 write_memory (sp
-256-(ii
*4), ®isters
[REGISTER_BYTE (32-ii
)], 4);
476 /* so far, 32*2 + 32 words = 384 bytes have been written.
477 7 extra registers in our register set: pc, ps, cnd, lr, cnt, xer, mq */
479 for (ii
=1; ii
<= (LAST_SP_REGNUM
-FIRST_SP_REGNUM
+1); ++ii
) {
480 write_memory (sp
-384-(ii
*4),
481 ®isters
[REGISTER_BYTE (FPLAST_REGNUM
+ ii
)], 4);
484 /* Save sp or so called back chain right here. */
485 store_address (sp_targ
, 4, sp
);
486 write_memory (sp
-DUMMY_FRAME_SIZE
, sp_targ
, 4);
487 sp
-= DUMMY_FRAME_SIZE
;
489 /* And finally, this is the back chain. */
490 write_memory (sp
+8, pc_targ
, 4);
494 /* Pop a dummy frame.
496 In rs6000 when we push a dummy frame, we save all of the registers. This
497 is usually done before user calls a function explicitly.
499 After a dummy frame is pushed, some instructions are copied into stack,
500 and stack pointer is decremented even more. Since we don't have a frame
501 pointer to get back to the parent frame of the dummy, we start having
502 trouble poping it. Therefore, we keep a dummy frame stack, keeping
503 addresses of dummy frames as such. When poping happens and when we
504 detect that was a dummy frame, we pop it back to its parent by using
505 dummy frame stack (`dummy_frame_addr' array).
507 FIXME: This whole concept is broken. You should be able to detect
508 a dummy stack frame *on the user's stack itself*. When you do,
509 then you know the format of that stack frame -- including its
510 saved SP register! There should *not* be a separate stack in the
511 GDB process that keeps track of these dummy frames! -- gnu@cygnus.com Aug92
518 sp
= dummy_frame_addr
[--dummy_frame_count
];
520 /* restore all fpr's. */
521 for (ii
= 1; ii
<= 32; ++ii
)
522 read_memory (sp
-(ii
*8), ®isters
[REGISTER_BYTE (32-ii
+FP0_REGNUM
)], 8);
524 /* restore all gpr's */
525 for (ii
=1; ii
<= 32; ++ii
) {
526 read_memory (sp
-256-(ii
*4), ®isters
[REGISTER_BYTE (32-ii
)], 4);
529 /* restore the rest of the registers. */
530 for (ii
=1; ii
<=(LAST_SP_REGNUM
-FIRST_SP_REGNUM
+1); ++ii
)
531 read_memory (sp
-384-(ii
*4),
532 ®isters
[REGISTER_BYTE (FPLAST_REGNUM
+ ii
)], 4);
534 read_memory (sp
-(DUMMY_FRAME_SIZE
-8),
535 ®isters
[REGISTER_BYTE(PC_REGNUM
)], 4);
537 /* when a dummy frame was being pushed, we had to decrement %sp first, in
538 order to secure astack space. Thus, saved %sp (or %r1) value, is not the
539 one we should restore. Change it with the one we need. */
541 *(int*)®isters
[REGISTER_BYTE(FP_REGNUM
)] = sp
;
543 /* Now we can restore all registers. */
545 target_store_registers (-1);
547 flush_cached_frames ();
551 /* pop the innermost frame, go back to the caller. */
556 CORE_ADDR pc
, lr
, sp
, prev_sp
; /* %pc, %lr, %sp */
557 struct rs6000_framedata fdata
;
558 struct frame_info
*frame
= get_current_frame ();
562 sp
= FRAME_FP (frame
);
564 if (stop_stack_dummy
&& dummy_frame_count
) {
569 /* Make sure that all registers are valid. */
570 read_register_bytes (0, NULL
, REGISTER_BYTES
);
572 /* figure out previous %pc value. If the function is frameless, it is
573 still in the link register, otherwise walk the frames and retrieve the
574 saved %pc value in the previous frame. */
576 addr
= get_pc_function_start (frame
->pc
) + FUNCTION_START_OFFSET
;
577 (void) skip_prologue (addr
, &fdata
);
582 prev_sp
= read_memory_integer (sp
, 4);
583 if (fdata
.lr_offset
== 0)
584 lr
= read_register (LR_REGNUM
);
586 lr
= read_memory_integer (prev_sp
+ fdata
.lr_offset
, 4);
588 /* reset %pc value. */
589 write_register (PC_REGNUM
, lr
);
591 /* reset register values if any was saved earlier. */
592 addr
= prev_sp
- fdata
.offset
;
594 if (fdata
.saved_gpr
!= -1)
595 for (ii
= fdata
.saved_gpr
; ii
<= 31; ++ii
) {
596 read_memory (addr
, ®isters
[REGISTER_BYTE (ii
)], 4);
600 if (fdata
.saved_fpr
!= -1)
601 for (ii
= fdata
.saved_fpr
; ii
<= 31; ++ii
) {
602 read_memory (addr
, ®isters
[REGISTER_BYTE (ii
+FP0_REGNUM
)], 8);
606 write_register (SP_REGNUM
, prev_sp
);
607 target_store_registers (-1);
608 flush_cached_frames ();
611 /* fixup the call sequence of a dummy function, with the real function address.
612 its argumets will be passed by gdb. */
615 fix_call_dummy(dummyname
, pc
, fun
, nargs
, type
)
619 int nargs
; /* not used */
620 int type
; /* not used */
622 #define TOC_ADDR_OFFSET 20
623 #define TARGET_ADDR_OFFSET 28
626 CORE_ADDR target_addr
;
630 tocvalue
= find_toc_address (target_addr
);
632 ii
= *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
);
633 ii
= (ii
& 0xffff0000) | (tocvalue
>> 16);
634 *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
) = ii
;
636 ii
= *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
+4);
637 ii
= (ii
& 0xffff0000) | (tocvalue
& 0x0000ffff);
638 *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
+4) = ii
;
640 ii
= *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
);
641 ii
= (ii
& 0xffff0000) | (target_addr
>> 16);
642 *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
) = ii
;
644 ii
= *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
+4);
645 ii
= (ii
& 0xffff0000) | (target_addr
& 0x0000ffff);
646 *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
+4) = ii
;
649 /* Pass the arguments in either registers, or in the stack. In RS6000, the first
650 eight words of the argument list (that might be less than eight parameters if
651 some parameters occupy more than one word) are passed in r3..r11 registers.
652 float and double parameters are passed in fpr's, in addition to that. Rest of
653 the parameters if any are passed in user stack. There might be cases in which
654 half of the parameter is copied into registers, the other half is pushed into
657 If the function is returning a structure, then the return address is passed
658 in r3, then the first 7 words of the parametes can be passed in registers,
662 push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
667 CORE_ADDR struct_addr
;
670 int argno
; /* current argument number */
671 int argbytes
; /* current argument byte */
672 char tmp_buffer
[50];
674 int f_argno
= 0; /* current floating point argno */
676 CORE_ADDR saved_sp
, pc
;
678 if ( dummy_frame_count
<= 0)
679 printf_unfiltered ("FATAL ERROR -push_arguments()! frame not found!!\n");
681 /* The first eight words of ther arguments are passed in registers. Copy
684 If the function is returning a `struct', then the first word (which
685 will be passed in r3) is used for struct return address. In that
686 case we should advance one word and start from r4 register to copy
689 ii
= struct_return
? 1 : 0;
691 for (argno
=0, argbytes
=0; argno
< nargs
&& ii
<8; ++ii
) {
694 len
= TYPE_LENGTH (VALUE_TYPE (arg
));
696 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FLT
) {
698 /* floating point arguments are passed in fpr's, as well as gpr's.
699 There are 13 fpr's reserved for passing parameters. At this point
700 there is no way we would run out of them. */
704 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
706 memcpy (®isters
[REGISTER_BYTE(FP0_REGNUM
+ 1 + f_argno
)], VALUE_CONTENTS (arg
),
713 /* Argument takes more than one register. */
714 while (argbytes
< len
) {
716 *(int*)®isters
[REGISTER_BYTE(ii
+3)] = 0;
717 memcpy (®isters
[REGISTER_BYTE(ii
+3)],
718 ((char*)VALUE_CONTENTS (arg
))+argbytes
,
719 (len
- argbytes
) > 4 ? 4 : len
- argbytes
);
723 goto ran_out_of_registers_for_arguments
;
728 else { /* Argument can fit in one register. No problem. */
729 *(int*)®isters
[REGISTER_BYTE(ii
+3)] = 0;
730 memcpy (®isters
[REGISTER_BYTE(ii
+3)], VALUE_CONTENTS (arg
), len
);
735 ran_out_of_registers_for_arguments
:
737 /* location for 8 parameters are always reserved. */
740 /* another six words for back chain, TOC register, link register, etc. */
743 /* if there are more arguments, allocate space for them in
744 the stack, then push them starting from the ninth one. */
746 if ((argno
< nargs
) || argbytes
) {
751 space
+= ((len
- argbytes
+ 3) & -4);
757 for (; jj
< nargs
; ++jj
) {
759 space
+= ((TYPE_LENGTH (VALUE_TYPE (val
))) + 3) & -4;
762 /* add location required for the rest of the parameters */
763 space
= (space
+ 7) & -8;
766 /* This is another instance we need to be concerned about securing our
767 stack space. If we write anything underneath %sp (r1), we might conflict
768 with the kernel who thinks he is free to use this area. So, update %sp
769 first before doing anything else. */
771 write_register (SP_REGNUM
, sp
);
773 /* if the last argument copied into the registers didn't fit there
774 completely, push the rest of it into stack. */
778 sp
+24+(ii
*4), ((char*)VALUE_CONTENTS (arg
))+argbytes
, len
- argbytes
);
780 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
783 /* push the rest of the arguments into stack. */
784 for (; argno
< nargs
; ++argno
) {
787 len
= TYPE_LENGTH (VALUE_TYPE (arg
));
790 /* float types should be passed in fpr's, as well as in the stack. */
791 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FLT
&& f_argno
< 13) {
795 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
797 memcpy (®isters
[REGISTER_BYTE(FP0_REGNUM
+ 1 + f_argno
)], VALUE_CONTENTS (arg
),
802 write_memory (sp
+24+(ii
*4), (char *) VALUE_CONTENTS (arg
), len
);
803 ii
+= ((len
+ 3) & -4) / 4;
807 /* Secure stack areas first, before doing anything else. */
808 write_register (SP_REGNUM
, sp
);
810 saved_sp
= dummy_frame_addr
[dummy_frame_count
- 1];
811 read_memory (saved_sp
, tmp_buffer
, 24);
812 write_memory (sp
, tmp_buffer
, 24);
814 /* set back chain properly */
815 store_address (tmp_buffer
, 4, saved_sp
);
816 write_memory (sp
, tmp_buffer
, 4);
818 target_store_registers (-1);
822 /* a given return value in `regbuf' with a type `valtype', extract and copy its
823 value into `valbuf' */
826 extract_return_value (valtype
, regbuf
, valbuf
)
827 struct type
*valtype
;
828 char regbuf
[REGISTER_BYTES
];
832 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
) {
835 /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes.
836 We need to truncate the return value into float size (4 byte) if
839 if (TYPE_LENGTH (valtype
) > 4) /* this is a double */
840 memcpy (valbuf
, ®buf
[REGISTER_BYTE (FP0_REGNUM
+ 1)],
841 TYPE_LENGTH (valtype
));
843 memcpy (&dd
, ®buf
[REGISTER_BYTE (FP0_REGNUM
+ 1)], 8);
845 memcpy (valbuf
, &ff
, sizeof(float));
849 /* return value is copied starting from r3. */
850 memcpy (valbuf
, ®buf
[REGISTER_BYTE (3)], TYPE_LENGTH (valtype
));
854 /* keep structure return address in this variable.
855 FIXME: This is a horrid kludge which should not be allowed to continue
856 living. This only allows a single nested call to a structure-returning
857 function. Come on, guys! -- gnu@cygnus.com, Aug 92 */
859 CORE_ADDR rs6000_struct_return_address
;
862 /* Indirect function calls use a piece of trampoline code to do context
863 switching, i.e. to set the new TOC table. Skip such code if we are on
864 its first instruction (as when we have single-stepped to here).
865 Also skip shared library trampoline code (which is different from
866 indirect function call trampolines).
867 Result is desired PC to step until, or NULL if we are not in
871 skip_trampoline_code (pc
)
874 register unsigned int ii
, op
;
875 CORE_ADDR solib_target_pc
;
877 static unsigned trampoline_code
[] = {
878 0x800b0000, /* l r0,0x0(r11) */
879 0x90410014, /* st r2,0x14(r1) */
880 0x7c0903a6, /* mtctr r0 */
881 0x804b0004, /* l r2,0x4(r11) */
882 0x816b0008, /* l r11,0x8(r11) */
883 0x4e800420, /* bctr */
888 /* If pc is in a shared library trampoline, return its target. */
889 solib_target_pc
= find_solib_trampoline_target (pc
);
891 return solib_target_pc
;
893 for (ii
=0; trampoline_code
[ii
]; ++ii
) {
894 op
= read_memory_integer (pc
+ (ii
*4), 4);
895 if (op
!= trampoline_code
[ii
])
898 ii
= read_register (11); /* r11 holds destination addr */
899 pc
= read_memory_integer (ii
, 4); /* (r11) value */
904 /* Determines whether the function FI has a frame on the stack or not. */
906 frameless_function_invocation (fi
)
907 struct frame_info
*fi
;
909 CORE_ADDR func_start
;
910 struct rs6000_framedata fdata
;
912 if (fi
->next
!= NULL
)
913 /* Don't even think about framelessness except on the innermost frame. */
914 /* FIXME: Can also be frameless if fi->next->signal_handler_caller (if
915 a signal happens while executing in a frameless function). */
918 func_start
= get_pc_function_start (fi
->pc
) + FUNCTION_START_OFFSET
;
920 /* If we failed to find the start of the function, it is a mistake
921 to inspect the instructions. */
926 (void) skip_prologue (func_start
, &fdata
);
927 return fdata
.frameless
;
930 /* Return the PC saved in a frame */
933 struct frame_info
*fi
;
935 CORE_ADDR func_start
;
936 struct rs6000_framedata fdata
;
939 func_start
= get_pc_function_start (fi
->pc
) + FUNCTION_START_OFFSET
;
941 /* If we failed to find the start of the function, it is a mistake
942 to inspect the instructions. */
946 (void) skip_prologue (func_start
, &fdata
);
947 if (fdata
.lr_offset
== 0)
948 return read_register (LR_REGNUM
);
950 if (fi
->signal_handler_caller
)
951 return read_memory_integer (fi
->frame
+ SIG_FRAME_PC_OFFSET
, 4);
953 return read_memory_integer (rs6000_frame_chain (fi
) + fdata
.lr_offset
, 4);
956 /* If saved registers of frame FI are not known yet, read and cache them.
957 &FDATAP contains rs6000_framedata; TDATAP can be NULL,
958 in which case the framedata are read. */
961 frame_get_cache_fsr (fi
, fdatap
)
962 struct frame_info
*fi
;
963 struct rs6000_framedata
*fdatap
;
966 CORE_ADDR frame_addr
;
967 struct rs6000_framedata work_fdata
;
972 if (fdatap
== NULL
) {
973 fdatap
= &work_fdata
;
974 (void) skip_prologue (get_pc_function_start (fi
->pc
), fdatap
);
977 fi
->cache_fsr
= (struct frame_saved_regs
*)
978 obstack_alloc (&frame_cache_obstack
, sizeof (struct frame_saved_regs
));
979 memset (fi
->cache_fsr
, '\0', sizeof (struct frame_saved_regs
));
981 if (fi
->prev
&& fi
->prev
->frame
)
982 frame_addr
= fi
->prev
->frame
;
984 frame_addr
= read_memory_integer (fi
->frame
, 4);
986 /* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr.
987 All fpr's from saved_fpr to fp31 are saved right underneath caller
988 stack pointer, starting from fp31 first. */
990 if (fdatap
->saved_fpr
>= 0) {
991 for (ii
=31; ii
>= fdatap
->saved_fpr
; --ii
)
992 fi
->cache_fsr
->regs
[FP0_REGNUM
+ ii
] = frame_addr
- ((32 - ii
) * 8);
993 frame_addr
-= (32 - fdatap
->saved_fpr
) * 8;
996 /* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr.
997 All gpr's from saved_gpr to gpr31 are saved right under saved fprs,
998 starting from r31 first. */
1000 if (fdatap
->saved_gpr
>= 0)
1001 for (ii
=31; ii
>= fdatap
->saved_gpr
; --ii
)
1002 fi
->cache_fsr
->regs
[ii
] = frame_addr
- ((32 - ii
) * 4);
1005 /* Return the address of a frame. This is the inital %sp value when the frame
1006 was first allocated. For functions calling alloca(), it might be saved in
1007 an alloca register. */
1010 frame_initial_stack_address (fi
)
1011 struct frame_info
*fi
;
1014 struct rs6000_framedata fdata
;
1015 struct frame_info
*callee_fi
;
1017 /* if the initial stack pointer (frame address) of this frame is known,
1021 return fi
->initial_sp
;
1023 /* find out if this function is using an alloca register.. */
1025 (void) skip_prologue (get_pc_function_start (fi
->pc
), &fdata
);
1027 /* if saved registers of this frame are not known yet, read and cache them. */
1030 frame_get_cache_fsr (fi
, &fdata
);
1032 /* If no alloca register used, then fi->frame is the value of the %sp for
1033 this frame, and it is good enough. */
1035 if (fdata
.alloca_reg
< 0) {
1036 fi
->initial_sp
= fi
->frame
;
1037 return fi
->initial_sp
;
1040 /* This function has an alloca register. If this is the top-most frame
1041 (with the lowest address), the value in alloca register is good. */
1044 return fi
->initial_sp
= read_register (fdata
.alloca_reg
);
1046 /* Otherwise, this is a caller frame. Callee has usually already saved
1047 registers, but there are exceptions (such as when the callee
1048 has no parameters). Find the address in which caller's alloca
1049 register is saved. */
1051 for (callee_fi
= fi
->next
; callee_fi
; callee_fi
= callee_fi
->next
) {
1053 if (!callee_fi
->cache_fsr
)
1054 frame_get_cache_fsr (callee_fi
, NULL
);
1056 /* this is the address in which alloca register is saved. */
1058 tmpaddr
= callee_fi
->cache_fsr
->regs
[fdata
.alloca_reg
];
1060 fi
->initial_sp
= read_memory_integer (tmpaddr
, 4);
1061 return fi
->initial_sp
;
1064 /* Go look into deeper levels of the frame chain to see if any one of
1065 the callees has saved alloca register. */
1068 /* If alloca register was not saved, by the callee (or any of its callees)
1069 then the value in the register is still good. */
1071 return fi
->initial_sp
= read_register (fdata
.alloca_reg
);
1075 rs6000_frame_chain (thisframe
)
1076 struct frame_info
*thisframe
;
1079 if (inside_entry_file ((thisframe
)->pc
))
1081 if (thisframe
->signal_handler_caller
)
1082 fp
= read_memory_integer (thisframe
->frame
+ SIG_FRAME_FP_OFFSET
, 4);
1084 fp
= read_memory_integer ((thisframe
)->frame
, 4);
1089 /* Keep an array of load segment information and their TOC table addresses.
1090 This info will be useful when calling a shared library function by hand. */
1093 CORE_ADDR textorg
, dataorg
;
1094 unsigned long toc_offset
;
1097 #define LOADINFOLEN 10
1099 static struct loadinfo
*loadinfo
= NULL
;
1100 static int loadinfolen
= 0;
1101 static int loadinfotocindex
= 0;
1102 static int loadinfotextindex
= 0;
1106 xcoff_init_loadinfo ()
1108 loadinfotocindex
= 0;
1109 loadinfotextindex
= 0;
1111 if (loadinfolen
== 0) {
1112 loadinfo
= (struct loadinfo
*)
1113 xmalloc (sizeof (struct loadinfo
) * LOADINFOLEN
);
1114 loadinfolen
= LOADINFOLEN
;
1119 /* FIXME -- this is never called! */
1127 loadinfotocindex
= 0;
1128 loadinfotextindex
= 0;
1131 /* this is called from xcoffread.c */
1134 xcoff_add_toc_to_loadinfo (tocoff
)
1135 unsigned long tocoff
;
1137 while (loadinfotocindex
>= loadinfolen
) {
1138 loadinfolen
+= LOADINFOLEN
;
1139 loadinfo
= (struct loadinfo
*)
1140 xrealloc (loadinfo
, sizeof(struct loadinfo
) * loadinfolen
);
1142 loadinfo
[loadinfotocindex
++].toc_offset
= tocoff
;
1146 add_text_to_loadinfo (textaddr
, dataaddr
)
1150 while (loadinfotextindex
>= loadinfolen
) {
1151 loadinfolen
+= LOADINFOLEN
;
1152 loadinfo
= (struct loadinfo
*)
1153 xrealloc (loadinfo
, sizeof(struct loadinfo
) * loadinfolen
);
1155 loadinfo
[loadinfotextindex
].textorg
= textaddr
;
1156 loadinfo
[loadinfotextindex
].dataorg
= dataaddr
;
1157 ++loadinfotextindex
;
1161 /* Note that this assumes that the "textorg" and "dataorg" elements
1162 of a member of this array are correlated with the "toc_offset"
1163 element of the same member. This is taken care of because the loops
1164 which assign the former (in xcoff_relocate_symtab or xcoff_relocate_core)
1165 and the latter (in scan_xcoff_symtab, via vmap_symtab, in vmap_ldinfo
1166 or xcoff_relocate_core) traverse the same objfiles in the same order. */
1169 find_toc_address (pc
)
1172 int ii
, toc_entry
, tocbase
= 0;
1174 for (ii
=0; ii
< loadinfotextindex
; ++ii
)
1175 if (pc
> loadinfo
[ii
].textorg
&& loadinfo
[ii
].textorg
> tocbase
) {
1177 tocbase
= loadinfo
[ii
].textorg
;
1180 return loadinfo
[toc_entry
].dataorg
+ loadinfo
[toc_entry
].toc_offset
;
1183 #ifdef GDB_TARGET_POWERPC
1185 gdb_print_insn_powerpc (memaddr
, info
)
1187 disassemble_info
*info
;
1189 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1190 return print_insn_big_powerpc (memaddr
, info
);
1192 return print_insn_little_powerpc (memaddr
, info
);
1197 _initialize_rs6000_tdep ()
1199 /* FIXME, this should not be decided via ifdef. */
1200 #ifdef GDB_TARGET_POWERPC
1201 tm_print_insn
= gdb_print_insn_powerpc
;
1203 tm_print_insn
= print_insn_rs6000
;