1 /* Target-dependent code for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 #include <sys/param.h>
30 #include <sys/ioctl.h>
40 extern struct obstack frame_cache_obstack
;
44 /* Nonzero if we just simulated a single step break. */
47 /* Breakpoint shadows for the single step instructions will be kept here. */
49 static struct sstep_breaks
{
54 /* Static function prototypes */
57 add_text_to_loadinfo
PARAMS ((CORE_ADDR textaddr
, CORE_ADDR dataaddr
));
60 find_toc_address
PARAMS ((CORE_ADDR pc
));
63 branch_dest
PARAMS ((int opcode
, int instr
, CORE_ADDR pc
, CORE_ADDR safety
));
66 frame_get_cache_fsr
PARAMS ((struct frame_info
*fi
,
67 struct aix_framedata
*fdatap
));
70 * Calculate the destination of a branch/jump. Return -1 if not a branch.
73 branch_dest (opcode
, instr
, pc
, safety
)
85 absolute
= (int) ((instr
>> 1) & 1);
89 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
92 if (opcode
!= 18) /* br conditional */
93 immediate
= ((instr
& ~3) << 16) >> 16;
97 dest
= pc
+ immediate
;
101 ext_op
= (instr
>>1) & 0x3ff;
103 if (ext_op
== 16) /* br conditional register */
104 dest
= read_register (LR_REGNUM
) & ~3;
106 else if (ext_op
== 528) /* br cond to count reg */
107 dest
= read_register (CTR_REGNUM
) & ~3;
114 return (dest
< TEXT_SEGMENT_BASE
) ? safety
: dest
;
119 /* AIX does not support PT_STEP. Simulate it. */
125 #define INSNLEN(OPCODE) 4
127 static char breakp
[] = BREAKPOINT
;
128 int ii
, insn
, ret
, loc
;
129 int breaks
[2], opcode
;
134 ret
= read_memory (loc
, &insn
, sizeof (int));
136 printf ("Error in single_step()!!\n");
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
= -1;
148 for (ii
=0; ii
< 2; ++ii
) {
150 /* ignore invalid breakpoint. */
151 if ( breaks
[ii
] == -1)
154 read_memory (breaks
[ii
], &(stepBreaks
[ii
].data
), sizeof(int));
156 ret
= write_memory (breaks
[ii
], breakp
, sizeof(int));
157 stepBreaks
[ii
].address
= breaks
[ii
];
163 /* remove step breakpoints. */
164 for (ii
=0; ii
< 2; ++ii
)
165 if (stepBreaks
[ii
].address
!= -1)
167 (stepBreaks
[ii
].address
, &(stepBreaks
[ii
].data
), sizeof(int));
171 errno
= 0; /* FIXME, don't ignore errors! */
175 /* return pc value after skipping a function prologue. */
181 unsigned int op
; /* FIXME, assumes instruction size matches host int!!! */
183 if (target_read_memory (pc
, (char *)&op
, sizeof (op
)))
184 return pc
; /* Can't access it -- assume no prologue. */
185 SWAP_TARGET_AND_HOST (&op
, sizeof (op
));
187 /* Assume that subsequent fetches can fail with low probability. */
189 if (op
== 0x7c0802a6) { /* mflr r0 */
191 op
= read_memory_integer (pc
, 4);
194 if ((op
& 0xfc00003e) == 0x7c000026) { /* mfcr Rx */
196 op
= read_memory_integer (pc
, 4);
199 if ((op
& 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
201 op
= read_memory_integer (pc
, 4);
203 /* At this point, make sure this is not a trampoline function
204 (a function that simply calls another functions, and nothing else).
205 If the next is not a nop, this branch was part of the function
208 if (op
== 0x4def7b82 || /* crorc 15, 15, 15 */
210 return pc
- 4; /* don't skip over this branch */
213 if ((op
& 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
215 op
= read_memory_integer (pc
, 4);
218 while (((tmp
= op
>> 16) == 0x9001) || /* st r0, NUM(r1) */
219 (tmp
== 0x9421) || /* stu r1, NUM(r1) */
220 (op
== 0x93e1fffc)) /* st r31,-4(r1) */
223 op
= read_memory_integer (pc
, 4);
226 while ((tmp
= (op
>> 22)) == 0x20f) { /* l r31, ... or */
227 pc
+= 4; /* l r30, ... */
228 op
= read_memory_integer (pc
, 4);
231 /* store parameters into stack */
233 (op
& 0xfc1f0000) == 0xd8010000 || /* stfd Rx,NUM(r1) */
234 (op
& 0xfc1f0000) == 0x90010000 || /* st r?, NUM(r1) */
235 (op
& 0xfc000000) == 0xfc000000 || /* frsp, fp?, .. */
236 (op
& 0xd0000000) == 0xd0000000) /* stfs, fp?, .. */
238 pc
+= 4; /* store fpr double */
239 op
= read_memory_integer (pc
, 4);
242 if (op
== 0x603f0000) { /* oril r31, r1, 0x0 */
243 pc
+= 4; /* this happens if r31 is used as */
244 op
= read_memory_integer (pc
, 4); /* frame ptr. (gcc does that) */
247 while ((op
>> 16) == (0x907f + tmp
)) { /* st r3, NUM(r31) */
248 pc
+= 4; /* st r4, NUM(r31), ... */
249 op
= read_memory_integer (pc
, 4);
254 /* I have problems with skipping over __main() that I need to address
255 * sometime. Previously, I used to use misc_function_vector which
256 * didn't work as well as I wanted to be. -MGO */
258 /* If the first thing after skipping a prolog is a branch to a function,
259 this might be a call to an initializer in main(), introduced by gcc2.
260 We'd like to skip over it as well. Fortunately, xlc does some extra
261 work before calling a function right after a prologue, thus we can
262 single out such gcc2 behaviour. */
265 if ((op
& 0xfc000001) == 0x48000001) { /* bl foo, an initializer function? */
266 op
= read_memory_integer (pc
+4, 4);
268 if (op
== 0x4def7b82) { /* cror 0xf, 0xf, 0xf (nop) */
270 /* check and see if we are in main. If so, skip over this initializer
273 tmp
= find_pc_misc_function (pc
);
274 if (tmp
>= 0 && !strcmp (misc_function_vector
[tmp
].name
, "main"))
284 /*************************************************************************
285 Support for creating pushind a dummy frame into the stack, and popping
287 *************************************************************************/
289 /* The total size of dummy frame is 436, which is;
294 and 24 extra bytes for the callee's link area. The last 24 bytes
295 for the link area might not be necessary, since it will be taken
296 care of by push_arguments(). */
298 #define DUMMY_FRAME_SIZE 436
300 #define DUMMY_FRAME_ADDR_SIZE 10
302 /* Make sure you initialize these in somewhere, in case gdb gives up what it
303 was debugging and starts debugging something else. FIXMEibm */
305 static int dummy_frame_count
= 0;
306 static int dummy_frame_size
= 0;
307 static CORE_ADDR
*dummy_frame_addr
= 0;
309 extern int stop_stack_dummy
;
311 /* push a dummy frame into stack, save all register. Currently we are saving
312 only gpr's and fpr's, which is not good enough! FIXMEmgo */
317 int sp
, pc
; /* stack pointer and link register */
320 target_fetch_registers (-1);
322 if (dummy_frame_count
>= dummy_frame_size
) {
323 dummy_frame_size
+= DUMMY_FRAME_ADDR_SIZE
;
324 if (dummy_frame_addr
)
325 dummy_frame_addr
= (CORE_ADDR
*) xrealloc
326 (dummy_frame_addr
, sizeof(CORE_ADDR
) * (dummy_frame_size
));
328 dummy_frame_addr
= (CORE_ADDR
*)
329 xmalloc (sizeof(CORE_ADDR
) * (dummy_frame_size
));
332 sp
= read_register(SP_REGNUM
);
333 pc
= read_register(PC_REGNUM
);
335 dummy_frame_addr
[dummy_frame_count
++] = sp
;
337 /* Be careful! If the stack pointer is not decremented first, then kernel
338 thinks he is free to use the space underneath it. And kernel actually
339 uses that area for IPC purposes when executing ptrace(2) calls. So
340 before writing register values into the new frame, decrement and update
341 %sp first in order to secure your frame. */
343 write_register (SP_REGNUM
, sp
-DUMMY_FRAME_SIZE
);
345 /* gdb relies on the state of current_frame. We'd better update it,
346 otherwise things like do_registers_info() wouldn't work properly! */
348 flush_cached_frames ();
349 set_current_frame (create_new_frame (sp
-DUMMY_FRAME_SIZE
, pc
));
351 /* save program counter in link register's space. */
352 write_memory (sp
+8, &pc
, 4);
354 /* save all floating point and general purpose registers here. */
357 for (ii
= 0; ii
< 32; ++ii
)
358 write_memory (sp
-8-(ii
*8), ®isters
[REGISTER_BYTE (31-ii
+FP0_REGNUM
)], 8);
361 for (ii
=1; ii
<=32; ++ii
)
362 write_memory (sp
-256-(ii
*4), ®isters
[REGISTER_BYTE (32-ii
)], 4);
364 /* so far, 32*2 + 32 words = 384 bytes have been written.
365 7 extra registers in our register set: pc, ps, cnd, lr, cnt, xer, mq */
367 for (ii
=1; ii
<= (LAST_SP_REGNUM
-FIRST_SP_REGNUM
+1); ++ii
) {
368 write_memory (sp
-384-(ii
*4),
369 ®isters
[REGISTER_BYTE (FPLAST_REGNUM
+ ii
)], 4);
372 /* Save sp or so called back chain right here. */
373 write_memory (sp
-DUMMY_FRAME_SIZE
, &sp
, 4);
374 sp
-= DUMMY_FRAME_SIZE
;
376 /* And finally, this is the back chain. */
377 write_memory (sp
+8, &pc
, 4);
381 /* Pop a dummy frame.
383 In rs6000 when we push a dummy frame, we save all of the registers. This
384 is usually done before user calls a function explicitly.
386 After a dummy frame is pushed, some instructions are copied into stack,
387 and stack pointer is decremented even more. Since we don't have a frame
388 pointer to get back to the parent frame of the dummy, we start having
389 trouble poping it. Therefore, we keep a dummy frame stack, keeping
390 addresses of dummy frames as such. When poping happens and when we
391 detect that was a dummy frame, we pop it back to its parent by using
392 dummy frame stack (`dummy_frame_addr' array).
394 FIXME: This whole concept is broken. You should be able to detect
395 a dummy stack frame *on the user's stack itself*. When you do,
396 then you know the format of that stack frame -- including its
397 saved SP register! There should *not* be a separate stack in the
398 GDB process that keeps track of these dummy frames! -- gnu@cygnus.com Aug92
405 sp
= dummy_frame_addr
[--dummy_frame_count
];
407 /* restore all fpr's. */
408 for (ii
= 1; ii
<= 32; ++ii
)
409 read_memory (sp
-(ii
*8), ®isters
[REGISTER_BYTE (32-ii
+FP0_REGNUM
)], 8);
411 /* restore all gpr's */
412 for (ii
=1; ii
<= 32; ++ii
) {
413 read_memory (sp
-256-(ii
*4), ®isters
[REGISTER_BYTE (32-ii
)], 4);
416 /* restore the rest of the registers. */
417 for (ii
=1; ii
<=(LAST_SP_REGNUM
-FIRST_SP_REGNUM
+1); ++ii
)
418 read_memory (sp
-384-(ii
*4),
419 ®isters
[REGISTER_BYTE (FPLAST_REGNUM
+ ii
)], 4);
421 read_memory (sp
-(DUMMY_FRAME_SIZE
-8),
422 ®isters
[REGISTER_BYTE(PC_REGNUM
)], 4);
424 /* when a dummy frame was being pushed, we had to decrement %sp first, in
425 order to secure astack space. Thus, saved %sp (or %r1) value, is not the
426 one we should restore. Change it with the one we need. */
428 *(int*)®isters
[REGISTER_BYTE(FP_REGNUM
)] = sp
;
430 /* Now we can restore all registers. */
432 target_store_registers (-1);
434 flush_cached_frames ();
435 set_current_frame (create_new_frame (sp
, pc
));
439 /* pop the innermost frame, go back to the caller. */
444 int pc
, lr
, sp
, prev_sp
; /* %pc, %lr, %sp */
445 struct aix_framedata fdata
;
446 FRAME fr
= get_current_frame ();
452 if (stop_stack_dummy
&& dummy_frame_count
) {
457 /* figure out previous %pc value. If the function is frameless, it is
458 still in the link register, otherwise walk the frames and retrieve the
459 saved %pc value in the previous frame. */
461 addr
= get_pc_function_start (fr
->pc
) + FUNCTION_START_OFFSET
;
462 function_frame_info (addr
, &fdata
);
464 read_memory (sp
, &prev_sp
, 4);
466 lr
= read_register (LR_REGNUM
);
468 read_memory (prev_sp
+8, &lr
, 4);
470 /* reset %pc value. */
471 write_register (PC_REGNUM
, lr
);
473 /* reset register values if any was saved earlier. */
474 addr
= prev_sp
- fdata
.offset
;
476 if (fdata
.saved_gpr
!= -1)
477 for (ii
=fdata
.saved_gpr
; ii
<= 31; ++ii
) {
478 read_memory (addr
, ®isters
[REGISTER_BYTE (ii
)], 4);
479 addr
+= sizeof (int);
482 if (fdata
.saved_fpr
!= -1)
483 for (ii
=fdata
.saved_fpr
; ii
<= 31; ++ii
) {
484 read_memory (addr
, ®isters
[REGISTER_BYTE (ii
+FP0_REGNUM
)], 8);
488 write_register (SP_REGNUM
, prev_sp
);
489 target_store_registers (-1);
490 flush_cached_frames ();
491 set_current_frame (create_new_frame (prev_sp
, lr
));
495 /* fixup the call sequence of a dummy function, with the real function address.
496 its argumets will be passed by gdb. */
499 fix_call_dummy(dummyname
, pc
, fun
, nargs
, type
)
503 int nargs
; /* not used */
504 int type
; /* not used */
506 #define TOC_ADDR_OFFSET 20
507 #define TARGET_ADDR_OFFSET 28
510 CORE_ADDR target_addr
;
514 tocvalue
= find_toc_address (target_addr
);
516 ii
= *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
);
517 ii
= (ii
& 0xffff0000) | (tocvalue
>> 16);
518 *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
) = ii
;
520 ii
= *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
+4);
521 ii
= (ii
& 0xffff0000) | (tocvalue
& 0x0000ffff);
522 *(int*)((char*)dummyname
+ TOC_ADDR_OFFSET
+4) = ii
;
524 ii
= *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
);
525 ii
= (ii
& 0xffff0000) | (target_addr
>> 16);
526 *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
) = ii
;
528 ii
= *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
+4);
529 ii
= (ii
& 0xffff0000) | (target_addr
& 0x0000ffff);
530 *(int*)((char*)dummyname
+ TARGET_ADDR_OFFSET
+4) = ii
;
534 /* return information about a function frame.
535 in struct aix_frameinfo fdata:
536 - frameless is TRUE, if function does not save %pc value in its frame.
537 - offset is the number of bytes used in the frame to save registers.
538 - saved_gpr is the number of the first saved gpr.
539 - saved_fpr is the number of the first saved fpr.
540 - alloca_reg is the number of the register used for alloca() handling.
544 function_frame_info (pc
, fdata
)
546 struct aix_framedata
*fdata
;
549 register unsigned int op
;
552 fdata
->saved_gpr
= fdata
->saved_fpr
= fdata
->alloca_reg
= -1;
554 op
= read_memory_integer (pc
, 4);
555 if (op
== 0x7c0802a6) { /* mflr r0 */
557 op
= read_memory_integer (pc
, 4);
558 fdata
->frameless
= 0;
560 else /* else, this is a frameless invocation */
561 fdata
->frameless
= 1;
564 if ((op
& 0xfc00003e) == 0x7c000026) { /* mfcr Rx */
566 op
= read_memory_integer (pc
, 4);
569 if ((op
& 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
571 op
= read_memory_integer (pc
, 4);
572 /* At this point, make sure this is not a trampoline function
573 (a function that simply calls another functions, and nothing else).
574 If the next is not a nop, this branch was part of the function
577 if (op
== 0x4def7b82 || /* crorc 15, 15, 15 */
579 return; /* prologue is over */
582 if ((op
& 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
583 pc
+= 4; /* store floating register double */
584 op
= read_memory_integer (pc
, 4);
587 if ((op
& 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
589 fdata
->saved_gpr
= (op
>> 21) & 0x1f;
592 tmp2
= 0xffff0000 | tmp2
;
596 fdata
->saved_fpr
= (tmp2
- ((32 - fdata
->saved_gpr
) * 4)) / 8;
597 if ( fdata
->saved_fpr
> 0)
598 fdata
->saved_fpr
= 32 - fdata
->saved_fpr
;
600 fdata
->saved_fpr
= -1;
602 fdata
->offset
= tmp2
;
604 op
= read_memory_integer (pc
, 4);
607 while (((tmp
= op
>> 16) == 0x9001) || /* st r0, NUM(r1) */
608 (tmp
== 0x9421) || /* stu r1, NUM(r1) */
609 (op
== 0x93e1fffc)) /* st r31,-4(r1) */
611 /* gcc takes a short cut and uses this instruction to save r31 only. */
613 if (op
== 0x93e1fffc) {
615 /* fatal ("Unrecognized prolog."); */
616 printf ("Unrecognized prolog!\n");
618 fdata
->saved_gpr
= 31;
622 op
= read_memory_integer (pc
, 4);
625 while ((tmp
= (op
>> 22)) == 0x20f) { /* l r31, ... or */
626 pc
+= 4; /* l r30, ... */
627 op
= read_memory_integer (pc
, 4);
630 /* store parameters into stack */
632 (op
& 0xfc1f0000) == 0xd8010000 || /* stfd Rx,NUM(r1) */
633 (op
& 0xfc1f0000) == 0x90010000 || /* st r?, NUM(r1) */
634 (op
& 0xfc000000) == 0xfc000000 || /* frsp, fp?, .. */
635 (op
& 0xd0000000) == 0xd0000000) /* stfs, fp?, .. */
637 pc
+= 4; /* store fpr double */
638 op
= read_memory_integer (pc
, 4);
641 if (op
== 0x603f0000) /* oril r31, r1, 0x0 */
642 fdata
->alloca_reg
= 31;
646 /* Pass the arguments in either registers, or in the stack. In RS6000, the first
647 eight words of the argument list (that might be less than eight parameters if
648 some parameters occupy more than one word) are passed in r3..r11 registers.
649 float and double parameters are passed in fpr's, in addition to that. Rest of
650 the parameters if any are passed in user stack. There might be cases in which
651 half of the parameter is copied into registers, the other half is pushed into
654 If the function is returning a structure, then the return address is passed
655 in r3, then the first 7 words of the parametes can be passed in registers,
659 push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
664 CORE_ADDR struct_addr
;
667 int argno
; /* current argument number */
668 int argbytes
; /* current argument byte */
669 char tmp_buffer
[50];
671 int f_argno
= 0; /* current floating point argno */
673 CORE_ADDR saved_sp
, pc
;
675 if ( dummy_frame_count
<= 0)
676 printf ("FATAL ERROR -push_arguments()! frame not found!!\n");
678 /* The first eight words of ther arguments are passed in registers. Copy
681 If the function is returning a `struct', then the first word (which
682 will be passed in r3) is used for struct return address. In that
683 case we should advance one word and start from r4 register to copy
686 ii
= struct_return
? 1 : 0;
688 for (argno
=0, argbytes
=0; argno
< nargs
&& ii
<8; ++ii
) {
690 arg
= value_arg_coerce (args
[argno
]);
691 len
= TYPE_LENGTH (VALUE_TYPE (arg
));
693 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FLT
) {
695 /* floating point arguments are passed in fpr's, as well as gpr's.
696 There are 13 fpr's reserved for passing parameters. At this point
697 there is no way we would run out of them. */
701 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
703 bcopy (VALUE_CONTENTS (arg
),
704 ®isters
[REGISTER_BYTE(FP0_REGNUM
+ 1 + f_argno
)], len
);
710 /* Argument takes more than one register. */
711 while (argbytes
< len
) {
713 *(int*)®isters
[REGISTER_BYTE(ii
+3)] = 0;
714 bcopy ( ((char*)VALUE_CONTENTS (arg
))+argbytes
,
715 ®isters
[REGISTER_BYTE(ii
+3)],
716 (len
- argbytes
) > 4 ? 4 : len
- argbytes
);
720 goto ran_out_of_registers_for_arguments
;
725 else { /* Argument can fit in one register. No problem. */
726 *(int*)®isters
[REGISTER_BYTE(ii
+3)] = 0;
727 bcopy (VALUE_CONTENTS (arg
), ®isters
[REGISTER_BYTE(ii
+3)], len
);
732 ran_out_of_registers_for_arguments
:
734 /* location for 8 parameters are always reserved. */
737 /* another six words for back chain, TOC register, link register, etc. */
740 /* if there are more arguments, allocate space for them in
741 the stack, then push them starting from the ninth one. */
743 if ((argno
< nargs
) || argbytes
) {
748 space
+= ((len
- argbytes
+ 3) & -4);
754 for (; jj
< nargs
; ++jj
) {
755 val
= value_arg_coerce (args
[jj
]);
756 space
+= ((TYPE_LENGTH (VALUE_TYPE (val
))) + 3) & -4;
759 /* add location required for the rest of the parameters */
760 space
= (space
+ 7) & -8;
763 /* This is another instance we need to be concerned about securing our
764 stack space. If we write anything underneath %sp (r1), we might conflict
765 with the kernel who thinks he is free to use this area. So, update %sp
766 first before doing anything else. */
768 write_register (SP_REGNUM
, sp
);
770 /* if the last argument copied into the registers didn't fit there
771 completely, push the rest of it into stack. */
775 sp
+24+(ii
*4), ((char*)VALUE_CONTENTS (arg
))+argbytes
, len
- argbytes
);
777 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
780 /* push the rest of the arguments into stack. */
781 for (; argno
< nargs
; ++argno
) {
783 arg
= value_arg_coerce (args
[argno
]);
784 len
= TYPE_LENGTH (VALUE_TYPE (arg
));
787 /* float types should be passed in fpr's, as well as in the stack. */
788 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FLT
&& f_argno
< 13) {
792 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno
);
794 bcopy (VALUE_CONTENTS (arg
),
795 ®isters
[REGISTER_BYTE(FP0_REGNUM
+ 1 + f_argno
)], len
);
799 write_memory (sp
+24+(ii
*4), VALUE_CONTENTS (arg
), len
);
800 ii
+= ((len
+ 3) & -4) / 4;
804 /* Secure stack areas first, before doing anything else. */
805 write_register (SP_REGNUM
, sp
);
807 saved_sp
= dummy_frame_addr
[dummy_frame_count
- 1];
808 read_memory (saved_sp
, tmp_buffer
, 24);
809 write_memory (sp
, tmp_buffer
, 24);
811 write_memory (sp
, &saved_sp
, 4); /* set back chain properly */
813 target_store_registers (-1);
817 /* a given return value in `regbuf' with a type `valtype', extract and copy its
818 value into `valbuf' */
821 extract_return_value (valtype
, regbuf
, valbuf
)
822 struct type
*valtype
;
823 char regbuf
[REGISTER_BYTES
];
827 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
) {
830 /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes.
831 We need to truncate the return value into float size (4 byte) if
834 if (TYPE_LENGTH (valtype
) > 4) /* this is a double */
835 bcopy (®buf
[REGISTER_BYTE (FP0_REGNUM
+ 1)], valbuf
,
836 TYPE_LENGTH (valtype
));
838 bcopy (®buf
[REGISTER_BYTE (FP0_REGNUM
+ 1)], &dd
, 8);
840 bcopy (&ff
, valbuf
, sizeof(float));
844 /* return value is copied starting from r3. */
845 bcopy (®buf
[REGISTER_BYTE (3)], valbuf
, TYPE_LENGTH (valtype
));
849 /* keep structure return address in this variable.
850 FIXME: This is a horrid kludge which should not be allowed to continue
851 living. This only allows a single nested call to a structure-returning
852 function. Come on, guys! -- gnu@cygnus.com, Aug 92 */
854 CORE_ADDR rs6000_struct_return_address
;
857 /* Throw away this debugging code. FIXMEmgo. */
863 for (ii
=0; ii
<40; ++ii
) {
866 val
= read_memory_integer (fram
+ ii
* 4, 4);
867 printf ("0x%08x\t", val
);
874 /* Indirect function calls use a piece of trampoline code to do context
875 switching, i.e. to set the new TOC table. Skip such code if we are on
876 its first instruction (as when we have single-stepped to here).
877 Result is desired PC to step until, or NULL if we are not in
881 skip_trampoline_code (pc
)
884 register unsigned int ii
, op
;
886 static unsigned trampoline_code
[] = {
887 0x800b0000, /* l r0,0x0(r11) */
888 0x90410014, /* st r2,0x14(r1) */
889 0x7c0903a6, /* mtctr r0 */
890 0x804b0004, /* l r2,0x4(r11) */
891 0x816b0008, /* l r11,0x8(r11) */
892 0x4e800420, /* bctr */
897 for (ii
=0; trampoline_code
[ii
]; ++ii
) {
898 op
= read_memory_integer (pc
+ (ii
*4), 4);
899 if (op
!= trampoline_code
[ii
])
902 ii
= read_register (11); /* r11 holds destination addr */
903 pc
= read_memory_integer (ii
, 4); /* (r11) value */
908 /* Determines whether the function FI has a frame on the stack or not.
909 Called from the FRAMELESS_FUNCTION_INVOCATION macro in tm.h. */
912 frameless_function_invocation (fi
)
913 struct frame_info
*fi
;
915 CORE_ADDR func_start
;
916 struct aix_framedata fdata
;
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 function_frame_info (func_start
, &fdata
);
927 return fdata
.frameless
;
931 /* If saved registers of frame FI are not known yet, read and cache them.
932 &FDATAP contains aix_framedata; TDATAP can be NULL,
933 in which case the framedata are read. */
936 frame_get_cache_fsr (fi
, fdatap
)
937 struct frame_info
*fi
;
938 struct aix_framedata
*fdatap
;
941 CORE_ADDR frame_addr
;
942 struct aix_framedata work_fdata
;
947 if (fdatap
== NULL
) {
948 fdatap
= &work_fdata
;
949 function_frame_info (get_pc_function_start (fi
->pc
), fdatap
);
952 fi
->cache_fsr
= (struct frame_saved_regs
*)
953 obstack_alloc (&frame_cache_obstack
, sizeof (struct frame_saved_regs
));
954 bzero (fi
->cache_fsr
, sizeof (struct frame_saved_regs
));
956 if (fi
->prev
&& fi
->prev
->frame
)
957 frame_addr
= fi
->prev
->frame
;
959 frame_addr
= read_memory_integer (fi
->frame
, 4);
961 /* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr.
962 All fpr's from saved_fpr to fp31 are saved right underneath caller
963 stack pointer, starting from fp31 first. */
965 if (fdatap
->saved_fpr
>= 0) {
966 for (ii
=31; ii
>= fdatap
->saved_fpr
; --ii
)
967 fi
->cache_fsr
->regs
[FP0_REGNUM
+ ii
] = frame_addr
- ((32 - ii
) * 8);
968 frame_addr
-= (32 - fdatap
->saved_fpr
) * 8;
971 /* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr.
972 All gpr's from saved_gpr to gpr31 are saved right under saved fprs,
973 starting from r31 first. */
975 if (fdatap
->saved_gpr
>= 0)
976 for (ii
=31; ii
>= fdatap
->saved_gpr
; --ii
)
977 fi
->cache_fsr
->regs
[ii
] = frame_addr
- ((32 - ii
) * 4);
980 /* Return the address of a frame. This is the inital %sp value when the frame
981 was first allocated. For functions calling alloca(), it might be saved in
982 an alloca register. */
985 frame_initial_stack_address (fi
)
986 struct frame_info
*fi
;
989 struct aix_framedata fdata
;
990 struct frame_info
*callee_fi
;
992 /* if the initial stack pointer (frame address) of this frame is known,
996 return fi
->initial_sp
;
998 /* find out if this function is using an alloca register.. */
1000 function_frame_info (get_pc_function_start (fi
->pc
), &fdata
);
1002 /* if saved registers of this frame are not known yet, read and cache them. */
1005 frame_get_cache_fsr (fi
, &fdata
);
1007 /* If no alloca register used, then fi->frame is the value of the %sp for
1008 this frame, and it is good enough. */
1010 if (fdata
.alloca_reg
< 0) {
1011 fi
->initial_sp
= fi
->frame
;
1012 return fi
->initial_sp
;
1015 /* This function has an alloca register. If this is the top-most frame
1016 (with the lowest address), the value in alloca register is good. */
1019 return fi
->initial_sp
= read_register (fdata
.alloca_reg
);
1021 /* Otherwise, this is a caller frame. Callee has usually already saved
1022 registers, but there are exceptions (such as when the callee
1023 has no parameters). Find the address in which caller's alloca
1024 register is saved. */
1026 for (callee_fi
= fi
->next
; callee_fi
; callee_fi
= callee_fi
->next
) {
1028 if (!callee_fi
->cache_fsr
)
1029 frame_get_cache_fsr (fi
, NULL
);
1031 /* this is the address in which alloca register is saved. */
1033 tmpaddr
= callee_fi
->cache_fsr
->regs
[fdata
.alloca_reg
];
1035 fi
->initial_sp
= read_memory_integer (tmpaddr
, 4);
1036 return fi
->initial_sp
;
1039 /* Go look into deeper levels of the frame chain to see if any one of
1040 the callees has saved alloca register. */
1043 /* If alloca register was not saved, by the callee (or any of its callees)
1044 then the value in the register is still good. */
1046 return fi
->initial_sp
= read_register (fdata
.alloca_reg
);
1049 /* xcoff_relocate_symtab - hook for symbol table relocation.
1050 also reads shared libraries.. */
1052 xcoff_relocate_symtab (pid
)
1055 #define MAX_LOAD_SEGS 64 /* maximum number of load segments */
1057 struct ld_info
*ldi
;
1060 ldi
= (void *) alloca(MAX_LOAD_SEGS
* sizeof (*ldi
));
1062 /* According to my humble theory, AIX has some timing problems and
1063 when the user stack grows, kernel doesn't update stack info in time
1064 and ptrace calls step on user stack. That is why we sleep here a little,
1065 and give kernel to update its internals. */
1070 ptrace(PT_LDINFO
, pid
, (PTRACE_ARG3_TYPE
) ldi
,
1071 MAX_LOAD_SEGS
* sizeof(*ldi
), ldi
);
1073 perror_with_name ("ptrace ldinfo");
1080 add_text_to_loadinfo (ldi
->ldinfo_textorg
, ldi
->ldinfo_dataorg
);
1081 } while (ldi
->ldinfo_next
1082 && (ldi
= (void *) (ldi
->ldinfo_next
+ (char *) ldi
)));
1085 /* Now that we've jumbled things around, re-sort them. */
1086 sort_minimal_symbols ();
1089 /* relocate the exec and core sections as well. */
1093 /* Keep an array of load segment information and their TOC table addresses.
1094 This info will be useful when calling a shared library function by hand. */
1097 CORE_ADDR textorg
, dataorg
;
1098 unsigned long toc_offset
;
1101 #define LOADINFOLEN 10
1103 /* FIXME Warning -- loadinfotextindex is used for a nefarious purpose by
1106 static struct loadinfo
*loadinfo
= NULL
;
1107 static int loadinfolen
= 0;
1108 static int loadinfotocindex
= 0;
1109 int loadinfotextindex
= 0;
1113 xcoff_init_loadinfo ()
1115 loadinfotocindex
= 0;
1116 loadinfotextindex
= 0;
1118 if (loadinfolen
== 0) {
1119 loadinfo
= (struct loadinfo
*)
1120 xmalloc (sizeof (struct loadinfo
) * LOADINFOLEN
);
1121 loadinfolen
= LOADINFOLEN
;
1126 /* FIXME -- this is never called! */
1134 loadinfotocindex
= 0;
1135 loadinfotextindex
= 0;
1138 /* this is called from xcoffread.c */
1141 xcoff_add_toc_to_loadinfo (unsigned long tocoff
)
1143 while (loadinfotocindex
>= loadinfolen
) {
1144 loadinfolen
+= LOADINFOLEN
;
1145 loadinfo
= (struct loadinfo
*)
1146 xrealloc (loadinfo
, sizeof(struct loadinfo
) * loadinfolen
);
1148 loadinfo
[loadinfotocindex
++].toc_offset
= tocoff
;
1153 add_text_to_loadinfo (textaddr
, dataaddr
)
1157 while (loadinfotextindex
>= loadinfolen
) {
1158 loadinfolen
+= LOADINFOLEN
;
1159 loadinfo
= (struct loadinfo
*)
1160 xrealloc (loadinfo
, sizeof(struct loadinfo
) * loadinfolen
);
1162 loadinfo
[loadinfotextindex
].textorg
= textaddr
;
1163 loadinfo
[loadinfotextindex
].dataorg
= dataaddr
;
1164 ++loadinfotextindex
;
1168 /* FIXME: This assumes that the "textorg" and "dataorg" elements
1169 of a member of this array are correlated with the "toc_offset"
1170 element of the same member. But they are sequentially assigned in wildly
1171 different places, and probably there is no correlation. FIXME! */
1174 find_toc_address (pc
)
1177 int ii
, toc_entry
, tocbase
= 0;
1179 for (ii
=0; ii
< loadinfotextindex
; ++ii
)
1180 if (pc
> loadinfo
[ii
].textorg
&& loadinfo
[ii
].textorg
> tocbase
) {
1182 tocbase
= loadinfo
[ii
].textorg
;
1185 return loadinfo
[toc_entry
].dataorg
+ loadinfo
[toc_entry
].toc_offset
;