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"
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 /* Structures 8 bytes or less long are returned in the r3 & r4
309 registers, according to the SYSV ABI. */
311 ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
313 if ((TYPE_LENGTH (value_type) == 16 || TYPE_LENGTH (value_type) == 8)
314 && TYPE_VECTOR (value_type))
317 return (TYPE_LENGTH (value_type) > 8);
321 /* The 64 bit ABI retun value convention.
323 Return non-zero if the return-value is stored in a register, return
324 0 if the return-value is instead stored on the stack (a.k.a.,
325 struct return convention).
327 For a return-value stored in a register: when INVAL is non-NULL,
328 copy the buffer to the corresponding register return-value location
329 location; when OUTVAL is non-NULL, fill the buffer from the
330 corresponding register return-value location. */
332 /* Potential ways that a function can return a value of a given type. */
333 enum return_value_convention
335 /* Where the return value has been squeezed into one or more
337 RETURN_VALUE_REGISTER_CONVENTION,
338 /* Commonly known as the "struct return convention". The caller
339 passes an additional hidden first parameter to the caller. That
340 parameter contains the address at which the value being returned
341 should be stored. While typically, and historically, used for
342 large structs, this is convention is applied to values of many
344 RETURN_VALUE_STRUCT_CONVENTION
347 static enum return_value_convention
348 ppc64_sysv_abi_return_value (struct type *valtype, struct regcache *regcache,
349 const void *inval, void *outval)
351 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
352 /* Floats and doubles in F1. */
353 if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
355 char regval[MAX_REGISTER_SIZE];
356 struct type *regtype = register_type (current_gdbarch, FP0_REGNUM);
359 convert_typed_floating (inval, valtype, regval, regtype);
360 regcache_cooked_write (regcache, FP0_REGNUM + 1, regval);
364 regcache_cooked_read (regcache, FP0_REGNUM + 1, regval);
365 convert_typed_floating (regval, regtype, outval, valtype);
367 return RETURN_VALUE_REGISTER_CONVENTION;
369 if (TYPE_CODE (valtype) == TYPE_CODE_INT && TYPE_LENGTH (valtype) <= 8)
371 /* Integers in r3. */
374 /* Be careful to sign extend the value. */
375 regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
376 unpack_long (valtype, inval));
380 /* Extract the integer from r3. Since this is truncating the
381 value, there isn't a sign extension problem. */
383 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
385 store_unsigned_integer (outval, TYPE_LENGTH (valtype), regval);
387 return RETURN_VALUE_REGISTER_CONVENTION;
389 /* All pointers live in r3. */
390 if (TYPE_CODE (valtype) == TYPE_CODE_PTR)
392 /* All pointers live in r3. */
394 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, inval);
396 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, outval);
397 return RETURN_VALUE_REGISTER_CONVENTION;
399 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
400 && TYPE_LENGTH (valtype) <= 8
401 && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
402 && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
404 /* Small character arrays are returned, right justified, in r3. */
405 int offset = (register_size (current_gdbarch, tdep->ppc_gp0_regnum + 3)
406 - TYPE_LENGTH (valtype));
408 regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
409 offset, TYPE_LENGTH (valtype), inval);
411 regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
412 offset, TYPE_LENGTH (valtype), outval);
413 return RETURN_VALUE_REGISTER_CONVENTION;
415 /* Big floating point values get stored in adjacent floating
417 if (TYPE_CODE (valtype) == TYPE_CODE_FLT
418 && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32))
420 if (inval || outval != NULL)
423 for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
426 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
427 (const bfd_byte *) inval + i * 8);
429 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
430 (bfd_byte *) outval + i * 8);
433 return RETURN_VALUE_REGISTER_CONVENTION;
435 /* Complex values get returned in f1:f2, need to convert. */
436 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX
437 && (TYPE_LENGTH (valtype) == 8 || TYPE_LENGTH (valtype) == 16))
439 if (regcache != NULL)
442 for (i = 0; i < 2; i++)
444 char regval[MAX_REGISTER_SIZE];
445 struct type *regtype =
446 register_type (current_gdbarch, FP0_REGNUM);
449 convert_typed_floating ((const bfd_byte *) inval +
450 i * (TYPE_LENGTH (valtype) / 2),
451 valtype, regval, regtype);
452 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
457 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regval);
458 convert_typed_floating (regval, regtype,
459 (bfd_byte *) outval +
460 i * (TYPE_LENGTH (valtype) / 2),
465 return RETURN_VALUE_REGISTER_CONVENTION;
467 /* Big complex values get stored in f1:f4. */
468 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32)
470 if (regcache != NULL)
473 for (i = 0; i < 4; i++)
476 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
477 (const bfd_byte *) inval + i * 8);
479 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
480 (bfd_byte *) outval + i * 8);
483 return RETURN_VALUE_REGISTER_CONVENTION;
485 return RETURN_VALUE_STRUCT_CONVENTION;
489 ppc64_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
491 return (ppc64_sysv_abi_return_value (value_type, NULL, NULL, NULL)
492 == RETURN_VALUE_STRUCT_CONVENTION);
496 ppc64_sysv_abi_extract_return_value (struct type *valtype,
497 struct regcache *regbuf, void *valbuf)
499 if (ppc64_sysv_abi_return_value (valtype, regbuf, NULL, valbuf)
500 != RETURN_VALUE_REGISTER_CONVENTION)
501 error ("Function return value unknown");
505 ppc64_sysv_abi_store_return_value (struct type *valtype,
506 struct regcache *regbuf,
509 if (!ppc64_sysv_abi_return_value (valtype, regbuf, valbuf, NULL))
510 error ("Function return value location unknown");