1 /* Target-dependent code for PowerPC systems using the SVR4 ABI
2 for GDB, the GNU debugger.
4 Copyright (C) 2000, 2001, 2002, 2003, 2005, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "gdb_string.h"
28 #include "gdb_assert.h"
34 /* Pass the arguments in either registers, or in the stack. Using the
35 ppc sysv ABI, the first eight words of the argument list (that might
36 be less than eight parameters if some parameters occupy more than one
37 word) are passed in r3..r10 registers. float and double parameters are
38 passed in fpr's, in addition to that. Rest of the parameters if any
39 are passed in user stack.
41 If the function is returning a structure, then the return address is passed
42 in r3, then the first 7 words of the parametes can be passed in registers,
46 ppc_sysv_abi_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
47 struct regcache
*regcache
, CORE_ADDR bp_addr
,
48 int nargs
, struct value
**args
, CORE_ADDR sp
,
49 int struct_return
, CORE_ADDR struct_addr
)
51 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
53 int argspace
= 0; /* 0 is an initial wrong guess. */
56 gdb_assert (tdep
->wordsize
== 4);
58 regcache_cooked_read_unsigned (regcache
, gdbarch_sp_regnum (gdbarch
),
61 /* Go through the argument list twice.
63 Pass 1: Figure out how much new stack space is required for
64 arguments and pushed values. Unlike the PowerOpen ABI, the SysV
65 ABI doesn't reserve any extra space for parameters which are put
66 in registers, but does always push structures and then pass their
69 Pass 2: Replay the same computation but this time also write the
70 values out to the target. */
72 for (write_pass
= 0; write_pass
< 2; write_pass
++)
75 /* Next available floating point register for float and double
78 /* Next available general register for non-float, non-vector
81 /* Next available vector register for vector arguments. */
83 /* Arguments start above the "LR save word" and "Back chain". */
84 int argoffset
= 2 * tdep
->wordsize
;
85 /* Structures start after the arguments. */
86 int structoffset
= argoffset
+ argspace
;
88 /* If the function is returning a `struct', then the first word
89 (which will be passed in r3) is used for struct return
90 address. In that case we should advance one word and start
91 from r4 register to copy parameters. */
95 regcache_cooked_write_signed (regcache
,
96 tdep
->ppc_gp0_regnum
+ greg
,
101 for (argno
= 0; argno
< nargs
; argno
++)
103 struct value
*arg
= args
[argno
];
104 struct type
*type
= check_typedef (value_type (arg
));
105 int len
= TYPE_LENGTH (type
);
106 const bfd_byte
*val
= value_contents (arg
);
108 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& len
<= 8
109 && !tdep
->soft_float
)
111 /* Floating point value converted to "double" then
112 passed in an FP register, when the registers run out,
113 8 byte aligned stack is used. */
118 /* Always store the floating point value using
119 the register's floating-point format. */
120 gdb_byte regval
[MAX_REGISTER_SIZE
];
122 = register_type (gdbarch
, tdep
->ppc_fp0_regnum
+ freg
);
123 convert_typed_floating (val
, type
, regval
, regtype
);
124 regcache_cooked_write (regcache
,
125 tdep
->ppc_fp0_regnum
+ freg
,
132 /* The SysV ABI tells us to convert floats to
133 doubles before writing them to an 8 byte aligned
134 stack location. Unfortunately GCC does not do
135 that, and stores floats into 4 byte aligned
136 locations without converting them to doubles.
137 Since there is no know compiler that actually
138 follows the ABI here, we implement the GCC
141 /* Align to 4 bytes or 8 bytes depending on the type of
142 the argument (float or double). */
143 argoffset
= align_up (argoffset
, len
);
145 write_memory (sp
+ argoffset
, val
, len
);
149 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
152 && (gdbarch_long_double_format (gdbarch
)
153 == floatformats_ibm_long_double
))
155 /* IBM long double passed in two FP registers if
156 available, otherwise 8-byte aligned stack. */
161 regcache_cooked_write (regcache
,
162 tdep
->ppc_fp0_regnum
+ freg
,
164 regcache_cooked_write (regcache
,
165 tdep
->ppc_fp0_regnum
+ freg
+ 1,
172 argoffset
= align_up (argoffset
, 8);
174 write_memory (sp
+ argoffset
, val
, len
);
179 && (TYPE_CODE (type
) == TYPE_CODE_INT
/* long long */
180 || TYPE_CODE (type
) == TYPE_CODE_FLT
)) /* double */
182 /* "long long" or soft-float "double" passed in an odd/even
183 register pair with the low addressed word in the odd
184 register and the high addressed word in the even
185 register, or when the registers run out an 8 byte
186 aligned stack location. */
189 /* Just in case GREG was 10. */
191 argoffset
= align_up (argoffset
, 8);
193 write_memory (sp
+ argoffset
, val
, len
);
198 /* Must start on an odd register - r3/r4 etc. */
203 regcache_cooked_write (regcache
,
204 tdep
->ppc_gp0_regnum
+ greg
+ 0,
206 regcache_cooked_write (regcache
,
207 tdep
->ppc_gp0_regnum
+ greg
+ 1,
213 else if (len
== 16 && TYPE_CODE (type
) == TYPE_CODE_FLT
214 && (gdbarch_long_double_format (gdbarch
)
215 == floatformats_ibm_long_double
))
217 /* Soft-float IBM long double passed in four consecutive
218 registers, or on the stack. The registers are not
219 necessarily odd/even pairs. */
223 argoffset
= align_up (argoffset
, 8);
225 write_memory (sp
+ argoffset
, val
, len
);
232 regcache_cooked_write (regcache
,
233 tdep
->ppc_gp0_regnum
+ greg
+ 0,
235 regcache_cooked_write (regcache
,
236 tdep
->ppc_gp0_regnum
+ greg
+ 1,
238 regcache_cooked_write (regcache
,
239 tdep
->ppc_gp0_regnum
+ greg
+ 2,
241 regcache_cooked_write (regcache
,
242 tdep
->ppc_gp0_regnum
+ greg
+ 3,
248 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
&& len
<= 8
249 && !tdep
->soft_float
)
251 /* 32-bit and 64-bit decimal floats go in f1 .. f8. They can
258 gdb_byte regval
[MAX_REGISTER_SIZE
];
261 /* 32-bit decimal floats are right aligned in the
263 if (TYPE_LENGTH (type
) == 4)
265 memcpy (regval
+ 4, val
, 4);
271 regcache_cooked_write (regcache
,
272 tdep
->ppc_fp0_regnum
+ freg
, p
);
279 argoffset
= align_up (argoffset
, len
);
282 /* Write value in the stack's parameter save area. */
283 write_memory (sp
+ argoffset
, val
, len
);
288 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
&& len
== 16
289 && !tdep
->soft_float
)
291 /* 128-bit decimal floats go in f2 .. f7, always in even/odd
292 pairs. They can end up in memory, using two doublewords. */
296 /* Make sure freg is even. */
301 regcache_cooked_write (regcache
,
302 tdep
->ppc_fp0_regnum
+ freg
, val
);
303 regcache_cooked_write (regcache
,
304 tdep
->ppc_fp0_regnum
+ freg
+ 1, val
+ 8);
309 argoffset
= align_up (argoffset
, 8);
312 write_memory (sp
+ argoffset
, val
, 16);
317 /* If a 128-bit decimal float goes to the stack because only f7
318 and f8 are free (thus there's no even/odd register pair
319 available), these registers should be marked as occupied.
320 Hence we increase freg even when writing to memory. */
324 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
325 && TYPE_VECTOR (type
)
326 && tdep
->vector_abi
== POWERPC_VEC_ALTIVEC
)
328 /* Vector parameter passed in an Altivec register, or
329 when that runs out, 16 byte aligned stack location. */
333 regcache_cooked_write (regcache
,
334 tdep
->ppc_vr0_regnum
+ vreg
, val
);
339 argoffset
= align_up (argoffset
, 16);
341 write_memory (sp
+ argoffset
, val
, 16);
346 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
347 && TYPE_VECTOR (type
)
348 && tdep
->vector_abi
== POWERPC_VEC_SPE
)
350 /* Vector parameter passed in an e500 register, or when
351 that runs out, 8 byte aligned stack location. Note
352 that since e500 vector and general purpose registers
353 both map onto the same underlying register set, a
354 "greg" and not a "vreg" is consumed here. A cooked
355 write stores the value in the correct locations
356 within the raw register cache. */
360 regcache_cooked_write (regcache
,
361 tdep
->ppc_ev0_regnum
+ greg
, val
);
366 argoffset
= align_up (argoffset
, 8);
368 write_memory (sp
+ argoffset
, val
, 8);
374 /* Reduce the parameter down to something that fits in a
376 gdb_byte word
[MAX_REGISTER_SIZE
];
377 memset (word
, 0, MAX_REGISTER_SIZE
);
378 if (len
> tdep
->wordsize
379 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
380 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
382 /* Structs and large values are put in an
383 aligned stack slot ... */
384 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
385 && TYPE_VECTOR (type
)
387 structoffset
= align_up (structoffset
, 16);
389 structoffset
= align_up (structoffset
, 8);
392 write_memory (sp
+ structoffset
, val
, len
);
393 /* ... and then a "word" pointing to that address is
394 passed as the parameter. */
395 store_unsigned_integer (word
, tdep
->wordsize
,
399 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
400 /* Sign or zero extend the "int" into a "word". */
401 store_unsigned_integer (word
, tdep
->wordsize
,
402 unpack_long (type
, val
));
404 /* Always goes in the low address. */
405 memcpy (word
, val
, len
);
406 /* Store that "word" in a register, or on the stack.
407 The words have "4" byte alignment. */
411 regcache_cooked_write (regcache
,
412 tdep
->ppc_gp0_regnum
+ greg
, word
);
417 argoffset
= align_up (argoffset
, tdep
->wordsize
);
419 write_memory (sp
+ argoffset
, word
, tdep
->wordsize
);
420 argoffset
+= tdep
->wordsize
;
425 /* Compute the actual stack space requirements. */
428 /* Remember the amount of space needed by the arguments. */
429 argspace
= argoffset
;
430 /* Allocate space for both the arguments and the structures. */
431 sp
-= (argoffset
+ structoffset
);
432 /* Ensure that the stack is still 16 byte aligned. */
433 sp
= align_down (sp
, 16);
436 /* The psABI says that "A caller of a function that takes a
437 variable argument list shall set condition register bit 6 to
438 1 if it passes one or more arguments in the floating-point
439 registers. It is strongly recommended that the caller set the
440 bit to 0 otherwise..." Doing this for normal functions too
446 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_cr_regnum
, &cr
);
451 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_cr_regnum
, cr
);
456 regcache_cooked_write_signed (regcache
, gdbarch_sp_regnum (gdbarch
), sp
);
458 /* Write the backchain (it occupies WORDSIZED bytes). */
459 write_memory_signed_integer (sp
, tdep
->wordsize
, saved_sp
);
461 /* Point the inferior function call's return address at the dummy's
463 regcache_cooked_write_signed (regcache
, tdep
->ppc_lr_regnum
, bp_addr
);
468 /* Handle the return-value conventions for Decimal Floating Point values
469 in both ppc32 and ppc64, which are the same. */
471 get_decimal_float_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
,
472 struct regcache
*regcache
, gdb_byte
*readbuf
,
473 const gdb_byte
*writebuf
)
475 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
477 gdb_assert (TYPE_CODE (valtype
) == TYPE_CODE_DECFLOAT
);
479 /* 32-bit and 64-bit decimal floats in f1. */
480 if (TYPE_LENGTH (valtype
) <= 8)
482 if (writebuf
!= NULL
)
484 gdb_byte regval
[MAX_REGISTER_SIZE
];
487 /* 32-bit decimal float is right aligned in the doubleword. */
488 if (TYPE_LENGTH (valtype
) == 4)
490 memcpy (regval
+ 4, writebuf
, 4);
496 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, p
);
500 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, readbuf
);
502 /* Left align 32-bit decimal float. */
503 if (TYPE_LENGTH (valtype
) == 4)
504 memcpy (readbuf
, readbuf
+ 4, 4);
507 /* 128-bit decimal floats in f2,f3. */
508 else if (TYPE_LENGTH (valtype
) == 16)
510 if (writebuf
!= NULL
|| readbuf
!= NULL
)
514 for (i
= 0; i
< 2; i
++)
516 if (writebuf
!= NULL
)
517 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 2 + i
,
520 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 2 + i
,
527 internal_error (__FILE__
, __LINE__
, "Unknown decimal float size.");
529 return RETURN_VALUE_REGISTER_CONVENTION
;
532 /* Handle the return-value conventions specified by the SysV 32-bit
533 PowerPC ABI (including all the supplements):
535 no floating-point: floating-point values returned using 32-bit
536 general-purpose registers.
538 Altivec: 128-bit vectors returned using vector registers.
540 e500: 64-bit vectors returned using the full full 64 bit EV
541 register, floating-point values returned using 32-bit
542 general-purpose registers.
544 GCC (broken): Small struct values right (instead of left) aligned
545 when returned in general-purpose registers. */
547 static enum return_value_convention
548 do_ppc_sysv_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
549 struct regcache
*regcache
, gdb_byte
*readbuf
,
550 const gdb_byte
*writebuf
, int broken_gcc
)
552 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
553 gdb_assert (tdep
->wordsize
== 4);
554 if (TYPE_CODE (type
) == TYPE_CODE_FLT
555 && TYPE_LENGTH (type
) <= 8
556 && !tdep
->soft_float
)
560 /* Floats and doubles stored in "f1". Convert the value to
561 the required type. */
562 gdb_byte regval
[MAX_REGISTER_SIZE
];
563 struct type
*regtype
= register_type (gdbarch
,
564 tdep
->ppc_fp0_regnum
+ 1);
565 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
566 convert_typed_floating (regval
, regtype
, readbuf
, type
);
570 /* Floats and doubles stored in "f1". Convert the value to
571 the register's "double" type. */
572 gdb_byte regval
[MAX_REGISTER_SIZE
];
573 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
574 convert_typed_floating (writebuf
, type
, regval
, regtype
);
575 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
577 return RETURN_VALUE_REGISTER_CONVENTION
;
579 if (TYPE_CODE (type
) == TYPE_CODE_FLT
580 && TYPE_LENGTH (type
) == 16
582 && (gdbarch_long_double_format (gdbarch
) == floatformats_ibm_long_double
))
584 /* IBM long double stored in f1 and f2. */
587 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, readbuf
);
588 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 2,
593 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, writebuf
);
594 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 2,
597 return RETURN_VALUE_REGISTER_CONVENTION
;
599 if (TYPE_CODE (type
) == TYPE_CODE_FLT
600 && TYPE_LENGTH (type
) == 16
601 && (gdbarch_long_double_format (gdbarch
) == floatformats_ibm_long_double
))
603 /* Soft-float IBM long double stored in r3, r4, r5, r6. */
606 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3, readbuf
);
607 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
609 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 5,
611 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 6,
616 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3, writebuf
);
617 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
619 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 5,
621 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 6,
624 return RETURN_VALUE_REGISTER_CONVENTION
;
626 if ((TYPE_CODE (type
) == TYPE_CODE_INT
&& TYPE_LENGTH (type
) == 8)
627 || (TYPE_CODE (type
) == TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 8))
631 /* A long long, or a double stored in the 32 bit r3/r4. */
632 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3,
634 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
639 /* A long long, or a double stored in the 32 bit r3/r4. */
640 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3,
642 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
645 return RETURN_VALUE_REGISTER_CONVENTION
;
647 if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
&& !tdep
->soft_float
)
648 return get_decimal_float_return_value (gdbarch
, type
, regcache
, readbuf
,
650 else if ((TYPE_CODE (type
) == TYPE_CODE_INT
651 || TYPE_CODE (type
) == TYPE_CODE_CHAR
652 || TYPE_CODE (type
) == TYPE_CODE_BOOL
653 || TYPE_CODE (type
) == TYPE_CODE_PTR
654 || TYPE_CODE (type
) == TYPE_CODE_REF
655 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
656 && TYPE_LENGTH (type
) <= tdep
->wordsize
)
660 /* Some sort of integer stored in r3. Since TYPE isn't
661 bigger than the register, sign extension isn't a problem
662 - just do everything unsigned. */
664 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
666 store_unsigned_integer (readbuf
, TYPE_LENGTH (type
), regval
);
670 /* Some sort of integer stored in r3. Use unpack_long since
671 that should handle any required sign extension. */
672 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
673 unpack_long (type
, writebuf
));
675 return RETURN_VALUE_REGISTER_CONVENTION
;
677 if (TYPE_LENGTH (type
) == 16
678 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
679 && TYPE_VECTOR (type
)
680 && tdep
->vector_abi
== POWERPC_VEC_ALTIVEC
)
684 /* Altivec places the return value in "v2". */
685 regcache_cooked_read (regcache
, tdep
->ppc_vr0_regnum
+ 2, readbuf
);
689 /* Altivec places the return value in "v2". */
690 regcache_cooked_write (regcache
, tdep
->ppc_vr0_regnum
+ 2, writebuf
);
692 return RETURN_VALUE_REGISTER_CONVENTION
;
694 if (TYPE_LENGTH (type
) == 16
695 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
696 && TYPE_VECTOR (type
)
697 && tdep
->vector_abi
== POWERPC_VEC_GENERIC
)
699 /* GCC -maltivec -mabi=no-altivec returns vectors in r3/r4/r5/r6.
700 GCC without AltiVec returns them in memory, but it warns about
701 ABI risks in that case; we don't try to support it. */
704 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3,
706 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
708 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 5,
710 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 6,
715 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3,
717 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
719 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 5,
721 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 6,
724 return RETURN_VALUE_REGISTER_CONVENTION
;
726 if (TYPE_LENGTH (type
) == 8
727 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
728 && TYPE_VECTOR (type
)
729 && tdep
->vector_abi
== POWERPC_VEC_SPE
)
731 /* The e500 ABI places return values for the 64-bit DSP types
732 (__ev64_opaque__) in r3. However, in GDB-speak, ev3
733 corresponds to the entire r3 value for e500, whereas GDB's r3
734 only corresponds to the least significant 32-bits. So place
735 the 64-bit DSP type's value in ev3. */
737 regcache_cooked_read (regcache
, tdep
->ppc_ev0_regnum
+ 3, readbuf
);
739 regcache_cooked_write (regcache
, tdep
->ppc_ev0_regnum
+ 3, writebuf
);
740 return RETURN_VALUE_REGISTER_CONVENTION
;
742 if (broken_gcc
&& TYPE_LENGTH (type
) <= 8)
744 /* GCC screwed up for structures or unions whose size is less
745 than or equal to 8 bytes.. Instead of left-aligning, it
746 right-aligns the data into the buffer formed by r3, r4. */
747 gdb_byte regvals
[MAX_REGISTER_SIZE
* 2];
748 int len
= TYPE_LENGTH (type
);
749 int offset
= (2 * tdep
->wordsize
- len
) % tdep
->wordsize
;
753 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3,
754 regvals
+ 0 * tdep
->wordsize
);
755 if (len
> tdep
->wordsize
)
756 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
757 regvals
+ 1 * tdep
->wordsize
);
758 memcpy (readbuf
, regvals
+ offset
, len
);
762 memset (regvals
, 0, sizeof regvals
);
763 memcpy (regvals
+ offset
, writebuf
, len
);
764 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3,
765 regvals
+ 0 * tdep
->wordsize
);
766 if (len
> tdep
->wordsize
)
767 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
768 regvals
+ 1 * tdep
->wordsize
);
771 return RETURN_VALUE_REGISTER_CONVENTION
;
773 if (TYPE_LENGTH (type
) <= 8)
777 /* This matches SVr4 PPC, it does not match GCC. */
778 /* The value is right-padded to 8 bytes and then loaded, as
779 two "words", into r3/r4. */
780 gdb_byte regvals
[MAX_REGISTER_SIZE
* 2];
781 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3,
782 regvals
+ 0 * tdep
->wordsize
);
783 if (TYPE_LENGTH (type
) > tdep
->wordsize
)
784 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
785 regvals
+ 1 * tdep
->wordsize
);
786 memcpy (readbuf
, regvals
, TYPE_LENGTH (type
));
790 /* This matches SVr4 PPC, it does not match GCC. */
791 /* The value is padded out to 8 bytes and then loaded, as
792 two "words" into r3/r4. */
793 gdb_byte regvals
[MAX_REGISTER_SIZE
* 2];
794 memset (regvals
, 0, sizeof regvals
);
795 memcpy (regvals
, writebuf
, TYPE_LENGTH (type
));
796 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3,
797 regvals
+ 0 * tdep
->wordsize
);
798 if (TYPE_LENGTH (type
) > tdep
->wordsize
)
799 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
800 regvals
+ 1 * tdep
->wordsize
);
802 return RETURN_VALUE_REGISTER_CONVENTION
;
804 return RETURN_VALUE_STRUCT_CONVENTION
;
807 enum return_value_convention
808 ppc_sysv_abi_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
,
809 struct regcache
*regcache
, gdb_byte
*readbuf
,
810 const gdb_byte
*writebuf
)
812 return do_ppc_sysv_return_value (gdbarch
, valtype
, regcache
, readbuf
,
816 enum return_value_convention
817 ppc_sysv_abi_broken_return_value (struct gdbarch
*gdbarch
,
818 struct type
*valtype
,
819 struct regcache
*regcache
,
820 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
822 return do_ppc_sysv_return_value (gdbarch
, valtype
, regcache
, readbuf
,
826 /* The helper function for 64-bit SYSV push_dummy_call. Converts the
827 function's code address back into the function's descriptor
830 Find a value for the TOC register. Every symbol should have both
831 ".FN" and "FN" in the minimal symbol table. "FN" points at the
832 FN's descriptor, while ".FN" points at the entry point (which
833 matches FUNC_ADDR). Need to reverse from FUNC_ADDR back to the
834 FN's descriptor address (while at the same time being careful to
835 find "FN" in the same object file as ".FN"). */
838 convert_code_addr_to_desc_addr (CORE_ADDR code_addr
, CORE_ADDR
*desc_addr
)
840 struct obj_section
*dot_fn_section
;
841 struct minimal_symbol
*dot_fn
;
842 struct minimal_symbol
*fn
;
844 /* Find the minimal symbol that corresponds to CODE_ADDR (should
845 have a name of the form ".FN"). */
846 dot_fn
= lookup_minimal_symbol_by_pc (code_addr
);
847 if (dot_fn
== NULL
|| SYMBOL_LINKAGE_NAME (dot_fn
)[0] != '.')
849 /* Get the section that contains CODE_ADDR. Need this for the
850 "objfile" that it contains. */
851 dot_fn_section
= find_pc_section (code_addr
);
852 if (dot_fn_section
== NULL
|| dot_fn_section
->objfile
== NULL
)
854 /* Now find the corresponding "FN" (dropping ".") minimal symbol's
855 address. Only look for the minimal symbol in ".FN"'s object file
856 - avoids problems when two object files (i.e., shared libraries)
857 contain a minimal symbol with the same name. */
858 fn
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (dot_fn
) + 1, NULL
,
859 dot_fn_section
->objfile
);
862 /* Found a descriptor. */
863 (*desc_addr
) = SYMBOL_VALUE_ADDRESS (fn
);
867 /* Pass the arguments in either registers, or in the stack. Using the
870 This implements a dumbed down version of the ABI. It always writes
871 values to memory, GPR and FPR, even when not necessary. Doing this
872 greatly simplifies the logic. */
875 ppc64_sysv_abi_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
876 struct regcache
*regcache
, CORE_ADDR bp_addr
,
877 int nargs
, struct value
**args
, CORE_ADDR sp
,
878 int struct_return
, CORE_ADDR struct_addr
)
880 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
881 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
883 /* See for-loop comment below. */
885 /* Size of the Altivec's vector parameter region, the final value is
886 computed in the for-loop below. */
887 LONGEST vparam_size
= 0;
888 /* Size of the general parameter region, the final value is computed
889 in the for-loop below. */
890 LONGEST gparam_size
= 0;
891 /* Kevin writes ... I don't mind seeing tdep->wordsize used in the
892 calls to align_up(), align_down(), etc. because this makes it
893 easier to reuse this code (in a copy/paste sense) in the future,
894 but it is a 64-bit ABI and asserting that the wordsize is 8 bytes
895 at some point makes it easier to verify that this function is
896 correct without having to do a non-local analysis to figure out
897 the possible values of tdep->wordsize. */
898 gdb_assert (tdep
->wordsize
== 8);
900 /* This function exists to support a calling convention that
901 requires floating-point registers. It shouldn't be used on
902 processors that lack them. */
903 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
905 /* By this stage in the proceedings, SP has been decremented by "red
906 zone size" + "struct return size". Fetch the stack-pointer from
907 before this and use that as the BACK_CHAIN. */
908 regcache_cooked_read_unsigned (regcache
, gdbarch_sp_regnum (gdbarch
),
911 /* Go through the argument list twice.
913 Pass 1: Compute the function call's stack space and register
916 Pass 2: Replay the same computation but this time also write the
917 values out to the target. */
919 for (write_pass
= 0; write_pass
< 2; write_pass
++)
922 /* Next available floating point register for float and double
925 /* Next available general register for non-vector (but possibly
928 /* Next available vector register for vector arguments. */
930 /* The address, at which the next general purpose parameter
931 (integer, struct, float, ...) should be saved. */
933 /* Address, at which the next Altivec vector parameter should be
939 /* During the first pass, GPARAM and VPARAM are more like
940 offsets (start address zero) than addresses. That way
941 the accumulate the total stack space each region
948 /* Decrement the stack pointer making space for the Altivec
949 and general on-stack parameters. Set vparam and gparam
950 to their corresponding regions. */
951 vparam
= align_down (sp
- vparam_size
, 16);
952 gparam
= align_down (vparam
- gparam_size
, 16);
953 /* Add in space for the TOC, link editor double word,
954 compiler double word, LR save area, CR save area. */
955 sp
= align_down (gparam
- 48, 16);
958 /* If the function is returning a `struct', then there is an
959 extra hidden parameter (which will be passed in r3)
960 containing the address of that struct.. In that case we
961 should advance one word and start from r4 register to copy
962 parameters. This also consumes one on-stack parameter slot. */
966 regcache_cooked_write_signed (regcache
,
967 tdep
->ppc_gp0_regnum
+ greg
,
970 gparam
= align_up (gparam
+ tdep
->wordsize
, tdep
->wordsize
);
973 for (argno
= 0; argno
< nargs
; argno
++)
975 struct value
*arg
= args
[argno
];
976 struct type
*type
= check_typedef (value_type (arg
));
977 const bfd_byte
*val
= value_contents (arg
);
979 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& TYPE_LENGTH (type
) <= 8)
981 /* Floats and Doubles go in f1 .. f13. They also
982 consume a left aligned GREG,, and can end up in
986 gdb_byte regval
[MAX_REGISTER_SIZE
];
989 /* Version 1.7 of the 64-bit PowerPC ELF ABI says:
991 "Single precision floating point values are mapped to
992 the first word in a single doubleword."
994 And version 1.9 says:
996 "Single precision floating point values are mapped to
997 the second word in a single doubleword."
999 GDB then writes single precision floating point values
1000 at both words in a doubleword, to support both ABIs. */
1001 if (TYPE_LENGTH (type
) == 4)
1003 memcpy (regval
, val
, 4);
1004 memcpy (regval
+ 4, val
, 4);
1010 /* Write value in the stack's parameter save area. */
1011 write_memory (gparam
, p
, 8);
1015 struct type
*regtype
1016 = register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
1018 convert_typed_floating (val
, type
, regval
, regtype
);
1019 regcache_cooked_write (regcache
,
1020 tdep
->ppc_fp0_regnum
+ freg
,
1024 regcache_cooked_write (regcache
,
1025 tdep
->ppc_gp0_regnum
+ greg
,
1031 /* Always consume parameter stack space. */
1032 gparam
= align_up (gparam
+ 8, tdep
->wordsize
);
1034 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
1035 && TYPE_LENGTH (type
) == 16
1036 && (gdbarch_long_double_format (gdbarch
)
1037 == floatformats_ibm_long_double
))
1039 /* IBM long double stored in two doublewords of the
1040 parameter save area and corresponding registers. */
1043 if (!tdep
->soft_float
&& freg
<= 13)
1045 regcache_cooked_write (regcache
,
1046 tdep
->ppc_fp0_regnum
+ freg
,
1049 regcache_cooked_write (regcache
,
1050 tdep
->ppc_fp0_regnum
+ freg
+ 1,
1055 regcache_cooked_write (regcache
,
1056 tdep
->ppc_gp0_regnum
+ greg
,
1059 regcache_cooked_write (regcache
,
1060 tdep
->ppc_gp0_regnum
+ greg
+ 1,
1063 write_memory (gparam
, val
, TYPE_LENGTH (type
));
1067 gparam
= align_up (gparam
+ TYPE_LENGTH (type
), tdep
->wordsize
);
1069 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
1070 && TYPE_LENGTH (type
) <= 8)
1072 /* 32-bit and 64-bit decimal floats go in f1 .. f13. They can
1073 end up in memory. */
1076 gdb_byte regval
[MAX_REGISTER_SIZE
];
1079 /* 32-bit decimal floats are right aligned in the
1081 if (TYPE_LENGTH (type
) == 4)
1083 memcpy (regval
+ 4, val
, 4);
1089 /* Write value in the stack's parameter save area. */
1090 write_memory (gparam
, p
, 8);
1093 regcache_cooked_write (regcache
,
1094 tdep
->ppc_fp0_regnum
+ freg
, p
);
1099 /* Always consume parameter stack space. */
1100 gparam
= align_up (gparam
+ 8, tdep
->wordsize
);
1102 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
&&
1103 TYPE_LENGTH (type
) == 16)
1105 /* 128-bit decimal floats go in f2 .. f12, always in even/odd
1106 pairs. They can end up in memory, using two doublewords. */
1111 /* Make sure freg is even. */
1113 regcache_cooked_write (regcache
,
1114 tdep
->ppc_fp0_regnum
+ freg
, val
);
1115 regcache_cooked_write (regcache
,
1116 tdep
->ppc_fp0_regnum
+ freg
+ 1, val
+ 8);
1119 write_memory (gparam
, val
, TYPE_LENGTH (type
));
1124 gparam
= align_up (gparam
+ TYPE_LENGTH (type
), tdep
->wordsize
);
1126 else if (TYPE_LENGTH (type
) == 16 && TYPE_VECTOR (type
)
1127 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
1128 && tdep
->ppc_vr0_regnum
>= 0)
1130 /* In the Altivec ABI, vectors go in the vector
1131 registers v2 .. v13, or when that runs out, a vector
1132 annex which goes above all the normal parameters.
1133 NOTE: cagney/2003-09-21: This is a guess based on the
1134 PowerOpen Altivec ABI. */
1138 regcache_cooked_write (regcache
,
1139 tdep
->ppc_vr0_regnum
+ vreg
, val
);
1145 write_memory (vparam
, val
, TYPE_LENGTH (type
));
1146 vparam
= align_up (vparam
+ TYPE_LENGTH (type
), 16);
1149 else if ((TYPE_CODE (type
) == TYPE_CODE_INT
1150 || TYPE_CODE (type
) == TYPE_CODE_ENUM
1151 || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1152 && TYPE_LENGTH (type
) <= 8)
1154 /* Scalars and Pointers get sign[un]extended and go in
1155 gpr3 .. gpr10. They can also end up in memory. */
1158 /* Sign extend the value, then store it unsigned. */
1159 ULONGEST word
= unpack_long (type
, val
);
1160 /* Convert any function code addresses into
1162 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1163 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1165 CORE_ADDR desc
= word
;
1166 convert_code_addr_to_desc_addr (word
, &desc
);
1170 regcache_cooked_write_unsigned (regcache
,
1171 tdep
->ppc_gp0_regnum
+
1173 write_memory_unsigned_integer (gparam
, tdep
->wordsize
,
1177 gparam
= align_up (gparam
+ TYPE_LENGTH (type
), tdep
->wordsize
);
1182 for (byte
= 0; byte
< TYPE_LENGTH (type
);
1183 byte
+= tdep
->wordsize
)
1185 if (write_pass
&& greg
<= 10)
1187 gdb_byte regval
[MAX_REGISTER_SIZE
];
1188 int len
= TYPE_LENGTH (type
) - byte
;
1189 if (len
> tdep
->wordsize
)
1190 len
= tdep
->wordsize
;
1191 memset (regval
, 0, sizeof regval
);
1192 /* The ABI (version 1.9) specifies that values
1193 smaller than one doubleword are right-aligned
1194 and those larger are left-aligned. GCC
1195 versions before 3.4 implemented this
1197 <http://gcc.gnu.org/gcc-3.4/powerpc-abi.html>. */
1199 memcpy (regval
+ tdep
->wordsize
- len
,
1202 memcpy (regval
, val
+ byte
, len
);
1203 regcache_cooked_write (regcache
, greg
, regval
);
1208 /* WARNING: cagney/2003-09-21: Strictly speaking, this
1209 isn't necessary, unfortunately, GCC appears to get
1210 "struct convention" parameter passing wrong putting
1211 odd sized structures in memory instead of in a
1212 register. Work around this by always writing the
1213 value to memory. Fortunately, doing this
1214 simplifies the code. */
1215 write_memory (gparam
, val
, TYPE_LENGTH (type
));
1217 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
1218 && TYPE_NFIELDS (type
) == 1
1219 && TYPE_LENGTH (type
) <= 16)
1221 /* The ABI (version 1.9) specifies that structs
1222 containing a single floating-point value, at any
1223 level of nesting of single-member structs, are
1224 passed in floating-point registers. */
1225 while (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1226 && TYPE_NFIELDS (type
) == 1)
1227 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
1228 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1230 if (TYPE_LENGTH (type
) <= 8)
1234 gdb_byte regval
[MAX_REGISTER_SIZE
];
1235 struct type
*regtype
1236 = register_type (gdbarch
,
1237 tdep
->ppc_fp0_regnum
);
1238 convert_typed_floating (val
, type
, regval
,
1240 regcache_cooked_write (regcache
,
1241 (tdep
->ppc_fp0_regnum
1247 else if (TYPE_LENGTH (type
) == 16
1248 && (gdbarch_long_double_format (gdbarch
)
1249 == floatformats_ibm_long_double
))
1253 regcache_cooked_write (regcache
,
1254 (tdep
->ppc_fp0_regnum
1258 regcache_cooked_write (regcache
,
1259 (tdep
->ppc_fp0_regnum
1267 /* Always consume parameter stack space. */
1268 gparam
= align_up (gparam
+ TYPE_LENGTH (type
), tdep
->wordsize
);
1274 /* Save the true region sizes ready for the second pass. */
1275 vparam_size
= vparam
;
1276 /* Make certain that the general parameter save area is at
1277 least the minimum 8 registers (or doublewords) in size. */
1279 gparam_size
= 8 * tdep
->wordsize
;
1281 gparam_size
= gparam
;
1286 regcache_cooked_write_signed (regcache
, gdbarch_sp_regnum (gdbarch
), sp
);
1288 /* Write the backchain (it occupies WORDSIZED bytes). */
1289 write_memory_signed_integer (sp
, tdep
->wordsize
, back_chain
);
1291 /* Point the inferior function call's return address at the dummy's
1293 regcache_cooked_write_signed (regcache
, tdep
->ppc_lr_regnum
, bp_addr
);
1295 /* Use the func_addr to find the descriptor, and use that to find
1298 CORE_ADDR desc_addr
;
1299 if (convert_code_addr_to_desc_addr (func_addr
, &desc_addr
))
1301 /* The TOC is the second double word in the descriptor. */
1303 read_memory_unsigned_integer (desc_addr
+ tdep
->wordsize
,
1305 regcache_cooked_write_unsigned (regcache
,
1306 tdep
->ppc_gp0_regnum
+ 2, toc
);
1314 /* The 64 bit ABI return value convention.
1316 Return non-zero if the return-value is stored in a register, return
1317 0 if the return-value is instead stored on the stack (a.k.a.,
1318 struct return convention).
1320 For a return-value stored in a register: when WRITEBUF is non-NULL,
1321 copy the buffer to the corresponding register return-value location
1322 location; when READBUF is non-NULL, fill the buffer from the
1323 corresponding register return-value location. */
1324 enum return_value_convention
1325 ppc64_sysv_abi_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
,
1326 struct regcache
*regcache
, gdb_byte
*readbuf
,
1327 const gdb_byte
*writebuf
)
1329 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1331 /* This function exists to support a calling convention that
1332 requires floating-point registers. It shouldn't be used on
1333 processors that lack them. */
1334 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
1336 /* Floats and doubles in F1. */
1337 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
&& TYPE_LENGTH (valtype
) <= 8)
1339 gdb_byte regval
[MAX_REGISTER_SIZE
];
1340 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
1341 if (writebuf
!= NULL
)
1343 convert_typed_floating (writebuf
, valtype
, regval
, regtype
);
1344 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
1346 if (readbuf
!= NULL
)
1348 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
1349 convert_typed_floating (regval
, regtype
, readbuf
, valtype
);
1351 return RETURN_VALUE_REGISTER_CONVENTION
;
1353 if (TYPE_CODE (valtype
) == TYPE_CODE_DECFLOAT
)
1354 return get_decimal_float_return_value (gdbarch
, valtype
, regcache
, readbuf
,
1356 /* Integers in r3. */
1357 if ((TYPE_CODE (valtype
) == TYPE_CODE_INT
1358 || TYPE_CODE (valtype
) == TYPE_CODE_ENUM
)
1359 && TYPE_LENGTH (valtype
) <= 8)
1361 if (writebuf
!= NULL
)
1363 /* Be careful to sign extend the value. */
1364 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
1365 unpack_long (valtype
, writebuf
));
1367 if (readbuf
!= NULL
)
1369 /* Extract the integer from r3. Since this is truncating the
1370 value, there isn't a sign extension problem. */
1372 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
1374 store_unsigned_integer (readbuf
, TYPE_LENGTH (valtype
), regval
);
1376 return RETURN_VALUE_REGISTER_CONVENTION
;
1378 /* All pointers live in r3. */
1379 if (TYPE_CODE (valtype
) == TYPE_CODE_PTR
)
1381 /* All pointers live in r3. */
1382 if (writebuf
!= NULL
)
1383 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3, writebuf
);
1384 if (readbuf
!= NULL
)
1385 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3, readbuf
);
1386 return RETURN_VALUE_REGISTER_CONVENTION
;
1388 /* Array type has more than one use. */
1389 if (TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
1391 /* Small character arrays are returned, right justified, in r3. */
1392 if (TYPE_LENGTH (valtype
) <= 8
1393 && TYPE_CODE (TYPE_TARGET_TYPE (valtype
)) == TYPE_CODE_INT
1394 && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype
)) == 1)
1396 int offset
= (register_size (gdbarch
, tdep
->ppc_gp0_regnum
+ 3)
1397 - TYPE_LENGTH (valtype
));
1398 if (writebuf
!= NULL
)
1399 regcache_cooked_write_part (regcache
, tdep
->ppc_gp0_regnum
+ 3,
1400 offset
, TYPE_LENGTH (valtype
), writebuf
);
1401 if (readbuf
!= NULL
)
1402 regcache_cooked_read_part (regcache
, tdep
->ppc_gp0_regnum
+ 3,
1403 offset
, TYPE_LENGTH (valtype
), readbuf
);
1404 return RETURN_VALUE_REGISTER_CONVENTION
;
1406 /* A VMX vector is returned in v2. */
1407 if (TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
1408 && TYPE_VECTOR (valtype
) && tdep
->ppc_vr0_regnum
>= 0)
1411 regcache_cooked_read (regcache
, tdep
->ppc_vr0_regnum
+ 2, readbuf
);
1413 regcache_cooked_write (regcache
, tdep
->ppc_vr0_regnum
+ 2, writebuf
);
1414 return RETURN_VALUE_REGISTER_CONVENTION
;
1417 /* Big floating point values get stored in adjacent floating
1418 point registers, starting with F1. */
1419 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
1420 && (TYPE_LENGTH (valtype
) == 16 || TYPE_LENGTH (valtype
) == 32))
1422 if (writebuf
|| readbuf
!= NULL
)
1425 for (i
= 0; i
< TYPE_LENGTH (valtype
) / 8; i
++)
1427 if (writebuf
!= NULL
)
1428 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1 + i
,
1429 (const bfd_byte
*) writebuf
+ i
* 8);
1430 if (readbuf
!= NULL
)
1431 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1 + i
,
1432 (bfd_byte
*) readbuf
+ i
* 8);
1435 return RETURN_VALUE_REGISTER_CONVENTION
;
1437 /* Complex values get returned in f1:f2, need to convert. */
1438 if (TYPE_CODE (valtype
) == TYPE_CODE_COMPLEX
1439 && (TYPE_LENGTH (valtype
) == 8 || TYPE_LENGTH (valtype
) == 16))
1441 if (regcache
!= NULL
)
1444 for (i
= 0; i
< 2; i
++)
1446 gdb_byte regval
[MAX_REGISTER_SIZE
];
1447 struct type
*regtype
=
1448 register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
1449 if (writebuf
!= NULL
)
1451 convert_typed_floating ((const bfd_byte
*) writebuf
+
1452 i
* (TYPE_LENGTH (valtype
) / 2),
1453 valtype
, regval
, regtype
);
1454 regcache_cooked_write (regcache
,
1455 tdep
->ppc_fp0_regnum
+ 1 + i
,
1458 if (readbuf
!= NULL
)
1460 regcache_cooked_read (regcache
,
1461 tdep
->ppc_fp0_regnum
+ 1 + i
,
1463 convert_typed_floating (regval
, regtype
,
1464 (bfd_byte
*) readbuf
+
1465 i
* (TYPE_LENGTH (valtype
) / 2),
1470 return RETURN_VALUE_REGISTER_CONVENTION
;
1472 /* Big complex values get stored in f1:f4. */
1473 if (TYPE_CODE (valtype
) == TYPE_CODE_COMPLEX
&& TYPE_LENGTH (valtype
) == 32)
1475 if (regcache
!= NULL
)
1478 for (i
= 0; i
< 4; i
++)
1480 if (writebuf
!= NULL
)
1481 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1 + i
,
1482 (const bfd_byte
*) writebuf
+ i
* 8);
1483 if (readbuf
!= NULL
)
1484 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1 + i
,
1485 (bfd_byte
*) readbuf
+ i
* 8);
1488 return RETURN_VALUE_REGISTER_CONVENTION
;
1490 return RETURN_VALUE_STRUCT_CONVENTION
;
1494 ppc64_sysv_abi_adjust_breakpoint_address (struct gdbarch
*gdbarch
,
1497 /* PPC64 SYSV specifies that the minimal-symbol "FN" should point at
1498 a function-descriptor while the corresponding minimal-symbol
1499 ".FN" should point at the entry point. Consequently, a command
1500 like "break FN" applied to an object file with only minimal
1501 symbols, will insert the breakpoint into the descriptor at "FN"
1502 and not the function at ".FN". Avoid this confusion by adjusting
1503 any attempt to set a descriptor breakpoint into a corresponding
1504 function breakpoint. Note that GDB warns the user when this
1505 adjustment is applied - that's ok as otherwise the user will have
1506 no way of knowing why their breakpoint at "FN" resulted in the
1507 program stopping at ".FN". */
1508 return gdbarch_convert_from_func_ptr_addr (gdbarch
, bpaddr
, ¤t_target
);