1 /* Target-dependent code for PowerPC systems using the SVR4 ABI
2 for GDB, the GNU debugger.
4 Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
28 #include "gdb_string.h"
29 #include "gdb_assert.h"
32 /* Pass the arguments in either registers, or in the stack. Using the
33 ppc sysv ABI, the first eight words of the argument list (that might
34 be less than eight parameters if some parameters occupy more than one
35 word) are passed in r3..r10 registers. float and double parameters are
36 passed in fpr's, in addition to that. Rest of the parameters if any
37 are passed in user stack.
39 If the function is returning a structure, then the return address is passed
40 in r3, then the first 7 words of the parametes can be passed in registers,
44 ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
45 struct regcache *regcache, CORE_ADDR bp_addr,
46 int nargs, struct value **args, CORE_ADDR sp,
47 int struct_return, CORE_ADDR struct_addr)
49 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
50 const CORE_ADDR saved_sp = read_sp ();
51 int argspace = 0; /* 0 is an initial wrong guess. */
54 /* Go through the argument list twice.
56 Pass 1: Figure out how much new stack space is required for
57 arguments and pushed values. Unlike the PowerOpen ABI, the SysV
58 ABI doesn't reserve any extra space for parameters which are put
59 in registers, but does always push structures and then pass their
62 Pass 2: Replay the same computation but this time also write the
63 values out to the target. */
65 for (write_pass = 0; write_pass < 2; write_pass++)
68 /* Next available floating point register for float and double
71 /* Next available general register for non-float, non-vector
74 /* Next available vector register for vector arguments. */
76 /* Arguments start above the "LR save word" and "Back chain". */
77 int argoffset = 2 * tdep->wordsize;
78 /* Structures start after the arguments. */
79 int structoffset = argoffset + argspace;
81 /* If the function is returning a `struct', then the first word
82 (which will be passed in r3) is used for struct return
83 address. In that case we should advance one word and start
84 from r4 register to copy parameters. */
88 regcache_cooked_write_signed (regcache,
89 tdep->ppc_gp0_regnum + greg,
94 for (argno = 0; argno < nargs; argno++)
96 struct value *arg = args[argno];
97 struct type *type = check_typedef (VALUE_TYPE (arg));
98 int len = TYPE_LENGTH (type);
99 char *val = VALUE_CONTENTS (arg);
101 if (TYPE_CODE (type) == TYPE_CODE_FLT
102 && ppc_floating_point_unit_p (current_gdbarch) && len <= 8)
104 /* Floating point value converted to "double" then
105 passed in an FP register, when the registers run out,
106 8 byte aligned stack is used. */
111 /* Always store the floating point value using
112 the register's floating-point format. */
113 char regval[MAX_REGISTER_SIZE];
115 = register_type (gdbarch, FP0_REGNUM + freg);
116 convert_typed_floating (val, type, regval, regtype);
117 regcache_cooked_write (regcache, FP0_REGNUM + freg,
124 /* SysV ABI converts floats to doubles before
125 writing them to an 8 byte aligned stack location. */
126 argoffset = align_up (argoffset, 8);
130 struct type *memtype;
131 switch (TARGET_BYTE_ORDER)
134 memtype = builtin_type_ieee_double_big;
136 case BFD_ENDIAN_LITTLE:
137 memtype = builtin_type_ieee_double_little;
140 internal_error (__FILE__, __LINE__, "bad switch");
142 convert_typed_floating (val, type, memval, memtype);
143 write_memory (sp + argoffset, val, len);
148 else if (len == 8 && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
149 || (!ppc_floating_point_unit_p (current_gdbarch) && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */
151 /* "long long" or "double" passed in an odd/even
152 register pair with the low addressed word in the odd
153 register and the high addressed word in the even
154 register, or when the registers run out an 8 byte
155 aligned stack location. */
158 /* Just in case GREG was 10. */
160 argoffset = align_up (argoffset, 8);
162 write_memory (sp + argoffset, val, len);
165 else if (tdep->wordsize == 8)
168 regcache_cooked_write (regcache,
169 tdep->ppc_gp0_regnum + greg, val);
174 /* Must start on an odd register - r3/r4 etc. */
179 regcache_cooked_write (regcache,
180 tdep->ppc_gp0_regnum + greg + 0,
182 regcache_cooked_write (regcache,
183 tdep->ppc_gp0_regnum + greg + 1,
190 && TYPE_CODE (type) == TYPE_CODE_ARRAY
191 && TYPE_VECTOR (type) && tdep->ppc_vr0_regnum >= 0)
193 /* Vector parameter passed in an Altivec register, or
194 when that runs out, 16 byte aligned stack location. */
198 regcache_cooked_write (current_regcache,
199 tdep->ppc_vr0_regnum + vreg, val);
204 argoffset = align_up (argoffset, 16);
206 write_memory (sp + argoffset, val, 16);
211 && TYPE_CODE (type) == TYPE_CODE_ARRAY
212 && TYPE_VECTOR (type) && tdep->ppc_ev0_regnum >= 0)
214 /* Vector parameter passed in an e500 register, or when
215 that runs out, 8 byte aligned stack location. Note
216 that since e500 vector and general purpose registers
217 both map onto the same underlying register set, a
218 "greg" and not a "vreg" is consumed here. A cooked
219 write stores the value in the correct locations
220 within the raw register cache. */
224 regcache_cooked_write (current_regcache,
225 tdep->ppc_ev0_regnum + greg, val);
230 argoffset = align_up (argoffset, 8);
232 write_memory (sp + argoffset, val, 8);
238 /* Reduce the parameter down to something that fits in a
240 char word[MAX_REGISTER_SIZE];
241 memset (word, 0, MAX_REGISTER_SIZE);
242 if (len > tdep->wordsize
243 || TYPE_CODE (type) == TYPE_CODE_STRUCT
244 || TYPE_CODE (type) == TYPE_CODE_UNION)
246 /* Structs and large values are put on an 8 byte
248 structoffset = align_up (structoffset, 8);
250 write_memory (sp + structoffset, val, len);
251 /* ... and then a "word" pointing to that address is
252 passed as the parameter. */
253 store_unsigned_integer (word, tdep->wordsize,
257 else if (TYPE_CODE (type) == TYPE_CODE_INT)
258 /* Sign or zero extend the "int" into a "word". */
259 store_unsigned_integer (word, tdep->wordsize,
260 unpack_long (type, val));
262 /* Always goes in the low address. */
263 memcpy (word, val, len);
264 /* Store that "word" in a register, or on the stack.
265 The words have "4" byte alignment. */
269 regcache_cooked_write (regcache,
270 tdep->ppc_gp0_regnum + greg, word);
275 argoffset = align_up (argoffset, tdep->wordsize);
277 write_memory (sp + argoffset, word, tdep->wordsize);
278 argoffset += tdep->wordsize;
283 /* Compute the actual stack space requirements. */
286 /* Remember the amount of space needed by the arguments. */
287 argspace = argoffset;
288 /* Allocate space for both the arguments and the structures. */
289 sp -= (argoffset + structoffset);
290 /* Ensure that the stack is still 16 byte aligned. */
291 sp = align_down (sp, 16);
296 regcache_cooked_write_signed (regcache, SP_REGNUM, sp);
298 /* Write the backchain (it occupies WORDSIZED bytes). */
299 write_memory_signed_integer (sp, tdep->wordsize, saved_sp);
301 /* Point the inferior function call's return address at the dummy's
303 regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
308 /* Potential ways that a function can return a value of a given type. */
309 enum return_value_convention
311 /* Where the return value has been squeezed into one or more
313 RETURN_VALUE_REGISTER_CONVENTION,
314 /* Commonly known as the "struct return convention". The caller
315 passes an additional hidden first parameter to the caller. That
316 parameter contains the address at which the value being returned
317 should be stored. While typically, and historically, used for
318 large structs, this is convention is applied to values of many
320 RETURN_VALUE_STRUCT_CONVENTION
323 /* Handle the return-value conventions specified by the SysV 32-bit
324 PowerPC ABI (including all the supplements):
326 no floating-point: floating-point values returned using 32-bit
327 general-purpose registers.
329 Altivec: 128-bit vectors returned using vector registers.
331 e500: 64-bit vectors returned using the full full 64 bit EV
332 register, floating-point values returned using 32-bit
333 general-purpose registers.
335 GCC (broken): Small struct values right (instead of left) aligned
336 when returned in general-purpose registers. */
338 static enum return_value_convention
339 do_ppc_sysv_return_value (struct type *type, struct regcache *regcache,
340 const void *inval, void *outval, int broken_gcc)
342 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
343 gdb_assert (tdep->wordsize == 4);
344 if (TYPE_CODE (type) == TYPE_CODE_FLT
345 && TYPE_LENGTH (type) <= 8
346 && ppc_floating_point_unit_p (current_gdbarch))
350 /* Floats and doubles stored in "f1". Convert the value to
351 the required type. */
352 char regval[MAX_REGISTER_SIZE];
353 struct type *regtype = register_type (current_gdbarch,
355 regcache_cooked_read (regcache, FP0_REGNUM + 1, regval);
356 convert_typed_floating (regval, regtype, outval, type);
360 /* Floats and doubles stored in "f1". Convert the value to
361 the register's "double" type. */
362 char regval[MAX_REGISTER_SIZE];
363 struct type *regtype = register_type (current_gdbarch, FP0_REGNUM);
364 convert_typed_floating (inval, type, regval, regtype);
365 regcache_cooked_write (regcache, FP0_REGNUM + 1, regval);
367 return RETURN_VALUE_REGISTER_CONVENTION;
369 if ((TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) == 8)
370 || (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8))
374 /* A long long, or a double stored in the 32 bit r3/r4. */
375 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
376 (bfd_byte *) outval + 0);
377 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
378 (bfd_byte *) outval + 4);
382 /* A long long, or a double stored in the 32 bit r3/r4. */
383 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
384 (bfd_byte *) inval + 0);
385 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
386 (bfd_byte *) inval + 4);
388 return RETURN_VALUE_REGISTER_CONVENTION;
390 if (TYPE_CODE (type) == TYPE_CODE_INT
391 && TYPE_LENGTH (type) <= tdep->wordsize)
395 /* Some sort of integer stored in r3. Since TYPE isn't
396 bigger than the register, sign extension isn't a problem
397 - just do everything unsigned. */
399 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
401 store_unsigned_integer (outval, TYPE_LENGTH (type), regval);
405 /* Some sort of integer stored in r3. Use unpack_long since
406 that should handle any required sign extension. */
407 regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
408 unpack_long (type, inval));
410 return RETURN_VALUE_REGISTER_CONVENTION;
412 if (TYPE_LENGTH (type) == 16
413 && TYPE_CODE (type) == TYPE_CODE_ARRAY
414 && TYPE_VECTOR (type) && tdep->ppc_vr0_regnum >= 0)
418 /* Altivec places the return value in "v2". */
419 regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, outval);
423 /* Altivec places the return value in "v2". */
424 regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, inval);
426 return RETURN_VALUE_REGISTER_CONVENTION;
428 if (TYPE_LENGTH (type) == 8
429 && TYPE_CODE (type) == TYPE_CODE_ARRAY
430 && TYPE_VECTOR (type) && tdep->ppc_ev0_regnum >= 0)
432 /* The e500 ABI places return values for the 64-bit DSP types
433 (__ev64_opaque__) in r3. However, in GDB-speak, ev3
434 corresponds to the entire r3 value for e500, whereas GDB's r3
435 only corresponds to the least significant 32-bits. So place
436 the 64-bit DSP type's value in ev3. */
438 regcache_cooked_read (regcache, tdep->ppc_ev0_regnum + 3, outval);
440 regcache_cooked_write (regcache, tdep->ppc_ev0_regnum + 3, inval);
441 return RETURN_VALUE_REGISTER_CONVENTION;
443 if (broken_gcc && TYPE_LENGTH (type) <= 8)
447 /* GCC screwed up. The last register isn't "left" aligned.
448 Need to extract the least significant part of each
449 register and then store that. */
450 /* Transfer any full words. */
455 int len = TYPE_LENGTH (type) - word * tdep->wordsize;
458 if (len > tdep->wordsize)
459 len = tdep->wordsize;
460 regcache_cooked_read_unsigned (regcache,
461 tdep->ppc_gp0_regnum + 3 + word,
463 store_unsigned_integer (((bfd_byte *) outval
464 + word * tdep->wordsize), len, reg);
470 /* GCC screwed up. The last register isn't "left" aligned.
471 Need to extract the least significant part of each
472 register and then store that. */
473 /* Transfer any full words. */
478 int len = TYPE_LENGTH (type) - word * tdep->wordsize;
481 if (len > tdep->wordsize)
482 len = tdep->wordsize;
483 reg = extract_unsigned_integer (((bfd_byte *) inval
484 + word * tdep->wordsize), len);
485 regcache_cooked_write_unsigned (regcache,
486 tdep->ppc_gp0_regnum + 3 + word,
491 return RETURN_VALUE_REGISTER_CONVENTION;
493 if (TYPE_LENGTH (type) <= 8)
497 /* This matches SVr4 PPC, it does not match GCC. */
498 /* The value is right-padded to 8 bytes and then loaded, as
499 two "words", into r3/r4. */
500 char regvals[MAX_REGISTER_SIZE * 2];
501 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
502 regvals + 0 * tdep->wordsize);
503 if (TYPE_LENGTH (type) > tdep->wordsize)
504 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
505 regvals + 1 * tdep->wordsize);
506 memcpy (outval, regvals, TYPE_LENGTH (type));
510 /* This matches SVr4 PPC, it does not match GCC. */
511 /* The value is padded out to 8 bytes and then loaded, as
512 two "words" into r3/r4. */
513 char regvals[MAX_REGISTER_SIZE * 2];
514 memset (regvals, 0, sizeof regvals);
515 memcpy (regvals, inval, TYPE_LENGTH (type));
516 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
517 regvals + 0 * tdep->wordsize);
518 if (TYPE_LENGTH (type) > tdep->wordsize)
519 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
520 regvals + 1 * tdep->wordsize);
522 return RETURN_VALUE_REGISTER_CONVENTION;
524 return RETURN_VALUE_STRUCT_CONVENTION;
528 ppc_sysv_abi_extract_return_value (struct type *type,
529 struct regcache *regcache, void *valbuf)
531 do_ppc_sysv_return_value (type, regcache, NULL, valbuf, 0);
535 ppc_sysv_abi_broken_extract_return_value (struct type *type,
536 struct regcache *regcache,
539 do_ppc_sysv_return_value (type, regcache, NULL, valbuf, 1);
543 ppc_sysv_abi_store_return_value (struct type *type, struct regcache *regcache,
546 do_ppc_sysv_return_value (type, regcache, valbuf, NULL, 0);
550 ppc_sysv_abi_broken_store_return_value (struct type *type,
551 struct regcache *regcache,
554 do_ppc_sysv_return_value (type, regcache, valbuf, NULL, 1);
557 /* Structures 8 bytes or less long are returned in the r3 & r4
558 registers, according to the SYSV ABI. */
560 ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
562 return (do_ppc_sysv_return_value (value_type, NULL, NULL, NULL, 0)
563 == RETURN_VALUE_STRUCT_CONVENTION);
566 /* Pass the arguments in either registers, or in the stack. Using the
569 This implements a dumbed down version of the ABI. It always writes
570 values to memory, GPR and FPR, even when not necessary. Doing this
571 greatly simplifies the logic. */
574 ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
575 struct regcache *regcache, CORE_ADDR bp_addr,
576 int nargs, struct value **args, CORE_ADDR sp,
577 int struct_return, CORE_ADDR struct_addr)
579 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
580 /* By this stage in the proceedings, SP has been decremented by "red
581 zone size" + "struct return size". Fetch the stack-pointer from
582 before this and use that as the BACK_CHAIN. */
583 const CORE_ADDR back_chain = read_sp ();
584 /* See for-loop comment below. */
586 /* Size of the Altivec's vector parameter region, the final value is
587 computed in the for-loop below. */
588 LONGEST vparam_size = 0;
589 /* Size of the general parameter region, the final value is computed
590 in the for-loop below. */
591 LONGEST gparam_size = 0;
592 /* Kevin writes ... I don't mind seeing tdep->wordsize used in the
593 calls to align_up(), align_down(), etc. because this makes it
594 easier to reuse this code (in a copy/paste sense) in the future,
595 but it is a 64-bit ABI and asserting that the wordsize is 8 bytes
596 at some point makes it easier to verify that this function is
597 correct without having to do a non-local analysis to figure out
598 the possible values of tdep->wordsize. */
599 gdb_assert (tdep->wordsize == 8);
601 /* Go through the argument list twice.
603 Pass 1: Compute the function call's stack space and register
606 Pass 2: Replay the same computation but this time also write the
607 values out to the target. */
609 for (write_pass = 0; write_pass < 2; write_pass++)
612 /* Next available floating point register for float and double
615 /* Next available general register for non-vector (but possibly
618 /* Next available vector register for vector arguments. */
620 /* The address, at which the next general purpose parameter
621 (integer, struct, float, ...) should be saved. */
623 /* Address, at which the next Altivec vector parameter should be
629 /* During the first pass, GPARAM and VPARAM are more like
630 offsets (start address zero) than addresses. That way
631 the accumulate the total stack space each region
638 /* Decrement the stack pointer making space for the Altivec
639 and general on-stack parameters. Set vparam and gparam
640 to their corresponding regions. */
641 vparam = align_down (sp - vparam_size, 16);
642 gparam = align_down (vparam - gparam_size, 16);
643 /* Add in space for the TOC, link editor double word,
644 compiler double word, LR save area, CR save area. */
645 sp = align_down (gparam - 48, 16);
648 /* If the function is returning a `struct', then there is an
649 extra hidden parameter (which will be passed in r3)
650 containing the address of that struct.. In that case we
651 should advance one word and start from r4 register to copy
652 parameters. This also consumes one on-stack parameter slot. */
656 regcache_cooked_write_signed (regcache,
657 tdep->ppc_gp0_regnum + greg,
660 gparam = align_up (gparam + tdep->wordsize, tdep->wordsize);
663 for (argno = 0; argno < nargs; argno++)
665 struct value *arg = args[argno];
666 struct type *type = check_typedef (VALUE_TYPE (arg));
667 char *val = VALUE_CONTENTS (arg);
668 if (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) <= 8)
670 /* Floats and Doubles go in f1 .. f13. They also
671 consume a left aligned GREG,, and can end up in
675 if (ppc_floating_point_unit_p (current_gdbarch)
678 char regval[MAX_REGISTER_SIZE];
679 struct type *regtype = register_type (gdbarch,
681 convert_typed_floating (val, type, regval, regtype);
682 regcache_cooked_write (regcache, FP0_REGNUM + freg,
687 /* The ABI states "Single precision floating
688 point values are mapped to the first word in
689 a single doubleword" and "... floating point
690 values mapped to the first eight doublewords
691 of the parameter save area are also passed in
694 This code interprets that to mean: store it,
695 left aligned, in the general register. */
696 char regval[MAX_REGISTER_SIZE];
697 memset (regval, 0, sizeof regval);
698 memcpy (regval, val, TYPE_LENGTH (type));
699 regcache_cooked_write (regcache,
700 tdep->ppc_gp0_regnum + greg,
703 write_memory (gparam, val, TYPE_LENGTH (type));
705 /* Always consume parameter stack space. */
708 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
710 else if (TYPE_LENGTH (type) == 16 && TYPE_VECTOR (type)
711 && TYPE_CODE (type) == TYPE_CODE_ARRAY
712 && tdep->ppc_vr0_regnum >= 0)
714 /* In the Altivec ABI, vectors go in the vector
715 registers v2 .. v13, or when that runs out, a vector
716 annex which goes above all the normal parameters.
717 NOTE: cagney/2003-09-21: This is a guess based on the
718 PowerOpen Altivec ABI. */
722 regcache_cooked_write (regcache,
723 tdep->ppc_vr0_regnum + vreg, val);
729 write_memory (vparam, val, TYPE_LENGTH (type));
730 vparam = align_up (vparam + TYPE_LENGTH (type), 16);
733 else if ((TYPE_CODE (type) == TYPE_CODE_INT
734 || TYPE_CODE (type) == TYPE_CODE_ENUM)
735 && TYPE_LENGTH (type) <= 8)
737 /* Scalars get sign[un]extended and go in gpr3 .. gpr10.
738 They can also end up in memory. */
741 /* Sign extend the value, then store it unsigned. */
742 ULONGEST word = unpack_long (type, val);
744 regcache_cooked_write_unsigned (regcache,
745 tdep->ppc_gp0_regnum +
747 write_memory_unsigned_integer (gparam, tdep->wordsize,
751 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
756 for (byte = 0; byte < TYPE_LENGTH (type);
757 byte += tdep->wordsize)
759 if (write_pass && greg <= 10)
761 char regval[MAX_REGISTER_SIZE];
762 int len = TYPE_LENGTH (type) - byte;
763 if (len > tdep->wordsize)
764 len = tdep->wordsize;
765 memset (regval, 0, sizeof regval);
766 /* WARNING: cagney/2003-09-21: As best I can
767 tell, the ABI specifies that the value should
768 be left aligned. Unfortunately, GCC doesn't
769 do this - it instead right aligns even sized
770 values and puts odd sized values on the
771 stack. Work around that by putting both a
772 left and right aligned value into the
773 register (hopefully no one notices :-^).
775 /* Left aligned (8 byte values such as pointers
777 memcpy (regval, val + byte, len);
778 /* Right aligned (but only if even). */
779 if (len == 1 || len == 2 || len == 4)
780 memcpy (regval + tdep->wordsize - len,
782 regcache_cooked_write (regcache, greg, regval);
787 /* WARNING: cagney/2003-09-21: Strictly speaking, this
788 isn't necessary, unfortunately, GCC appears to get
789 "struct convention" parameter passing wrong putting
790 odd sized structures in memory instead of in a
791 register. Work around this by always writing the
792 value to memory. Fortunately, doing this
793 simplifies the code. */
794 write_memory (gparam, val, TYPE_LENGTH (type));
795 /* Always consume parameter stack space. */
796 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
802 /* Save the true region sizes ready for the second pass. */
803 vparam_size = vparam;
804 /* Make certain that the general parameter save area is at
805 least the minimum 8 registers (or doublewords) in size. */
807 gparam_size = 8 * tdep->wordsize;
809 gparam_size = gparam;
814 regcache_cooked_write_signed (regcache, SP_REGNUM, sp);
816 /* Write the backchain (it occupies WORDSIZED bytes). */
817 write_memory_signed_integer (sp, tdep->wordsize, back_chain);
819 /* Point the inferior function call's return address at the dummy's
821 regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
823 /* Find a value for the TOC register. Every symbol should have both
824 ".FN" and "FN" in the minimal symbol table. "FN" points at the
825 FN's descriptor, while ".FN" points at the entry point (which
826 matches FUNC_ADDR). Need to reverse from FUNC_ADDR back to the
827 FN's descriptor address. */
829 /* Find the minimal symbol that corresponds to FUNC_ADDR (should
830 have the name ".FN"). */
831 struct minimal_symbol *dot_fn = lookup_minimal_symbol_by_pc (func_addr);
832 if (dot_fn != NULL && SYMBOL_LINKAGE_NAME (dot_fn)[0] == '.')
834 /* Now find the corresponding "FN" (dropping ".") minimal
836 struct minimal_symbol *fn =
837 lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (dot_fn) + 1, NULL,
841 /* Got the address of that descriptor. The TOC is the
842 second double word. */
844 read_memory_unsigned_integer (SYMBOL_VALUE_ADDRESS (fn) +
845 tdep->wordsize, tdep->wordsize);
846 regcache_cooked_write_unsigned (regcache,
847 tdep->ppc_gp0_regnum + 2, toc);
856 /* The 64 bit ABI retun value convention.
858 Return non-zero if the return-value is stored in a register, return
859 0 if the return-value is instead stored on the stack (a.k.a.,
860 struct return convention).
862 For a return-value stored in a register: when INVAL is non-NULL,
863 copy the buffer to the corresponding register return-value location
864 location; when OUTVAL is non-NULL, fill the buffer from the
865 corresponding register return-value location. */
866 static enum return_value_convention
867 ppc64_sysv_abi_return_value (struct type *valtype, struct regcache *regcache,
868 const void *inval, void *outval)
870 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
871 /* Floats and doubles in F1. */
872 if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
874 char regval[MAX_REGISTER_SIZE];
875 struct type *regtype = register_type (current_gdbarch, FP0_REGNUM);
878 convert_typed_floating (inval, valtype, regval, regtype);
879 regcache_cooked_write (regcache, FP0_REGNUM + 1, regval);
883 regcache_cooked_read (regcache, FP0_REGNUM + 1, regval);
884 convert_typed_floating (regval, regtype, outval, valtype);
886 return RETURN_VALUE_REGISTER_CONVENTION;
888 if (TYPE_CODE (valtype) == TYPE_CODE_INT && TYPE_LENGTH (valtype) <= 8)
890 /* Integers in r3. */
893 /* Be careful to sign extend the value. */
894 regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
895 unpack_long (valtype, inval));
899 /* Extract the integer from r3. Since this is truncating the
900 value, there isn't a sign extension problem. */
902 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
904 store_unsigned_integer (outval, TYPE_LENGTH (valtype), regval);
906 return RETURN_VALUE_REGISTER_CONVENTION;
908 /* All pointers live in r3. */
909 if (TYPE_CODE (valtype) == TYPE_CODE_PTR)
911 /* All pointers live in r3. */
913 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, inval);
915 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, outval);
916 return RETURN_VALUE_REGISTER_CONVENTION;
918 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
919 && TYPE_LENGTH (valtype) <= 8
920 && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
921 && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
923 /* Small character arrays are returned, right justified, in r3. */
924 int offset = (register_size (current_gdbarch, tdep->ppc_gp0_regnum + 3)
925 - TYPE_LENGTH (valtype));
927 regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
928 offset, TYPE_LENGTH (valtype), inval);
930 regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
931 offset, TYPE_LENGTH (valtype), outval);
932 return RETURN_VALUE_REGISTER_CONVENTION;
934 /* Big floating point values get stored in adjacent floating
936 if (TYPE_CODE (valtype) == TYPE_CODE_FLT
937 && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32))
939 if (inval || outval != NULL)
942 for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
945 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
946 (const bfd_byte *) inval + i * 8);
948 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
949 (bfd_byte *) outval + i * 8);
952 return RETURN_VALUE_REGISTER_CONVENTION;
954 /* Complex values get returned in f1:f2, need to convert. */
955 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX
956 && (TYPE_LENGTH (valtype) == 8 || TYPE_LENGTH (valtype) == 16))
958 if (regcache != NULL)
961 for (i = 0; i < 2; i++)
963 char regval[MAX_REGISTER_SIZE];
964 struct type *regtype =
965 register_type (current_gdbarch, FP0_REGNUM);
968 convert_typed_floating ((const bfd_byte *) inval +
969 i * (TYPE_LENGTH (valtype) / 2),
970 valtype, regval, regtype);
971 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
976 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regval);
977 convert_typed_floating (regval, regtype,
978 (bfd_byte *) outval +
979 i * (TYPE_LENGTH (valtype) / 2),
984 return RETURN_VALUE_REGISTER_CONVENTION;
986 /* Big complex values get stored in f1:f4. */
987 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32)
989 if (regcache != NULL)
992 for (i = 0; i < 4; i++)
995 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
996 (const bfd_byte *) inval + i * 8);
998 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
999 (bfd_byte *) outval + i * 8);
1002 return RETURN_VALUE_REGISTER_CONVENTION;
1004 return RETURN_VALUE_STRUCT_CONVENTION;
1008 ppc64_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
1010 return (ppc64_sysv_abi_return_value (value_type, NULL, NULL, NULL)
1011 == RETURN_VALUE_STRUCT_CONVENTION);
1015 ppc64_sysv_abi_extract_return_value (struct type *valtype,
1016 struct regcache *regbuf, void *valbuf)
1018 if (ppc64_sysv_abi_return_value (valtype, regbuf, NULL, valbuf)
1019 != RETURN_VALUE_REGISTER_CONVENTION)
1020 error ("Function return value unknown");
1024 ppc64_sysv_abi_store_return_value (struct type *valtype,
1025 struct regcache *regbuf,
1028 if (!ppc64_sysv_abi_return_value (valtype, regbuf, valbuf, NULL))
1029 error ("Function return value location unknown");