projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* ppc-sysv-tdep.c (ppc64_sysv_abi_push_dummy_call): Write 32-bit
[deliverable/binutils-gdb.git] / gdb / ppc-sysv-tdep.c
1 /* Target-dependent code for PowerPC systems using the SVR4 ABI
2 for GDB, the GNU debugger.
3
4 Copyright (C) 2000, 2001, 2002, 2003, 2005, 2007, 2008
5 Free Software Foundation, Inc.
6
7 This file is part of GDB.
8
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.
13
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.
18
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/>. */
21
22 #include "defs.h"
23 #include "gdbcore.h"
24 #include "inferior.h"
25 #include "regcache.h"
26 #include "value.h"
27 #include "gdb_string.h"
28 #include "gdb_assert.h"
29 #include "ppc-tdep.h"
30 #include "target.h"
31 #include "objfiles.h"
32 #include "infcall.h"
33
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.
40
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,
43 starting from r4. */
44
45 CORE_ADDR
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)
50 {
51 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
52 ULONGEST saved_sp;
53 int argspace = 0; /* 0 is an initial wrong guess. */
54 int write_pass;
55
56 gdb_assert (tdep->wordsize == 4);
57
58 regcache_cooked_read_unsigned (regcache, gdbarch_sp_regnum (gdbarch),
59 &saved_sp);
60
61 /* Go through the argument list twice.
62
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
67 address.
68
69 Pass 2: Replay the same computation but this time also write the
70 values out to the target. */
71
72 for (write_pass = 0; write_pass < 2; write_pass++)
73 {
74 int argno;
75 /* Next available floating point register for float and double
76 arguments. */
77 int freg = 1;
78 /* Next available general register for non-float, non-vector
79 arguments. */
80 int greg = 3;
81 /* Next available vector register for vector arguments. */
82 int vreg = 2;
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;
87
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. */
92 if (struct_return)
93 {
94 if (write_pass)
95 regcache_cooked_write_signed (regcache,
96 tdep->ppc_gp0_regnum + greg,
97 struct_addr);
98 greg++;
99 }
100
101 for (argno = 0; argno < nargs; argno++)
102 {
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);
107
108 if (TYPE_CODE (type) == TYPE_CODE_FLT && len <= 8
109 && !tdep->soft_float)
110 {
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. */
114 if (freg <= 8)
115 {
116 if (write_pass)
117 {
118 /* Always store the floating point value using
119 the register's floating-point format. */
120 gdb_byte regval[MAX_REGISTER_SIZE];
121 struct type *regtype
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,
126 regval);
127 }
128 freg++;
129 }
130 else
131 {
132 /* SysV ABI converts floats to doubles before
133 writing them to an 8 byte aligned stack location. */
134 argoffset = align_up (argoffset, 8);
135 if (write_pass)
136 {
137 char memval[8];
138 convert_typed_floating (val, type, memval,
139 builtin_type_ieee_double);
140 write_memory (sp + argoffset, val, len);
141 }
142 argoffset += 8;
143 }
144 }
145 else if (TYPE_CODE (type) == TYPE_CODE_FLT
146 && len == 16
147 && !tdep->soft_float
148 && (gdbarch_long_double_format (gdbarch)
149 == floatformats_ibm_long_double))
150 {
151 /* IBM long double passed in two FP registers if
152 available, otherwise 8-byte aligned stack. */
153 if (freg <= 7)
154 {
155 if (write_pass)
156 {
157 regcache_cooked_write (regcache,
158 tdep->ppc_fp0_regnum + freg,
159 val);
160 regcache_cooked_write (regcache,
161 tdep->ppc_fp0_regnum + freg + 1,
162 val + 8);
163 }
164 freg += 2;
165 }
166 else
167 {
168 argoffset = align_up (argoffset, 8);
169 if (write_pass)
170 write_memory (sp + argoffset, val, len);
171 argoffset += 16;
172 }
173 }
174 else if (len == 8
175 && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
176 || TYPE_CODE (type) == TYPE_CODE_FLT)) /* double */
177 {
178 /* "long long" or soft-float "double" passed in an odd/even
179 register pair with the low addressed word in the odd
180 register and the high addressed word in the even
181 register, or when the registers run out an 8 byte
182 aligned stack location. */
183 if (greg > 9)
184 {
185 /* Just in case GREG was 10. */
186 greg = 11;
187 argoffset = align_up (argoffset, 8);
188 if (write_pass)
189 write_memory (sp + argoffset, val, len);
190 argoffset += 8;
191 }
192 else
193 {
194 /* Must start on an odd register - r3/r4 etc. */
195 if ((greg & 1) == 0)
196 greg++;
197 if (write_pass)
198 {
199 regcache_cooked_write (regcache,
200 tdep->ppc_gp0_regnum + greg + 0,
201 val + 0);
202 regcache_cooked_write (regcache,
203 tdep->ppc_gp0_regnum + greg + 1,
204 val + 4);
205 }
206 greg += 2;
207 }
208 }
209 else if (len == 16 && TYPE_CODE (type) == TYPE_CODE_FLT
210 && (gdbarch_long_double_format (gdbarch)
211 == floatformats_ibm_long_double))
212 {
213 /* Soft-float IBM long double passed in four consecutive
214 registers, or on the stack. The registers are not
215 necessarily odd/even pairs. */
216 if (greg > 7)
217 {
218 greg = 11;
219 argoffset = align_up (argoffset, 8);
220 if (write_pass)
221 write_memory (sp + argoffset, val, len);
222 argoffset += 16;
223 }
224 else
225 {
226 if (write_pass)
227 {
228 regcache_cooked_write (regcache,
229 tdep->ppc_gp0_regnum + greg + 0,
230 val + 0);
231 regcache_cooked_write (regcache,
232 tdep->ppc_gp0_regnum + greg + 1,
233 val + 4);
234 regcache_cooked_write (regcache,
235 tdep->ppc_gp0_regnum + greg + 2,
236 val + 8);
237 regcache_cooked_write (regcache,
238 tdep->ppc_gp0_regnum + greg + 3,
239 val + 12);
240 }
241 greg += 4;
242 }
243 }
244 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && len <= 8
245 && !tdep->soft_float)
246 {
247 /* 32-bit and 64-bit decimal floats go in f1 .. f8. They can
248 end up in memory. */
249
250 if (freg <= 8)
251 {
252 if (write_pass)
253 {
254 gdb_byte regval[MAX_REGISTER_SIZE];
255 const gdb_byte *p;
256
257 /* 32-bit decimal floats are right aligned in the
258 doubleword. */
259 if (TYPE_LENGTH (type) == 4)
260 {
261 memcpy (regval + 4, val, 4);
262 p = regval;
263 }
264 else
265 p = val;
266
267 regcache_cooked_write (regcache,
268 tdep->ppc_fp0_regnum + freg, p);
269 }
270
271 freg++;
272 }
273 else
274 {
275 argoffset = align_up (argoffset, len);
276
277 if (write_pass)
278 /* Write value in the stack's parameter save area. */
279 write_memory (sp + argoffset, val, len);
280
281 argoffset += len;
282 }
283 }
284 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && len == 16
285 && !tdep->soft_float)
286 {
287 /* 128-bit decimal floats go in f2 .. f7, always in even/odd
288 pairs. They can end up in memory, using two doublewords. */
289
290 if (freg <= 6)
291 {
292 /* Make sure freg is even. */
293 freg += freg & 1;
294
295 if (write_pass)
296 {
297 regcache_cooked_write (regcache,
298 tdep->ppc_fp0_regnum + freg, val);
299 regcache_cooked_write (regcache,
300 tdep->ppc_fp0_regnum + freg + 1, val + 8);
301 }
302 }
303 else
304 {
305 argoffset = align_up (argoffset, 8);
306
307 if (write_pass)
308 write_memory (sp + argoffset, val, 16);
309
310 argoffset += 16;
311 }
312
313 /* If a 128-bit decimal float goes to the stack because only f7
314 and f8 are free (thus there's no even/odd register pair
315 available), these registers should be marked as occupied.
316 Hence we increase freg even when writing to memory. */
317 freg += 2;
318 }
319 else if (len == 16
320 && TYPE_CODE (type) == TYPE_CODE_ARRAY
321 && TYPE_VECTOR (type)
322 && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
323 {
324 /* Vector parameter passed in an Altivec register, or
325 when that runs out, 16 byte aligned stack location. */
326 if (vreg <= 13)
327 {
328 if (write_pass)
329 regcache_cooked_write (regcache,
330 tdep->ppc_vr0_regnum + vreg, val);
331 vreg++;
332 }
333 else
334 {
335 argoffset = align_up (argoffset, 16);
336 if (write_pass)
337 write_memory (sp + argoffset, val, 16);
338 argoffset += 16;
339 }
340 }
341 else if (len == 8
342 && TYPE_CODE (type) == TYPE_CODE_ARRAY
343 && TYPE_VECTOR (type)
344 && tdep->vector_abi == POWERPC_VEC_SPE)
345 {
346 /* Vector parameter passed in an e500 register, or when
347 that runs out, 8 byte aligned stack location. Note
348 that since e500 vector and general purpose registers
349 both map onto the same underlying register set, a
350 "greg" and not a "vreg" is consumed here. A cooked
351 write stores the value in the correct locations
352 within the raw register cache. */
353 if (greg <= 10)
354 {
355 if (write_pass)
356 regcache_cooked_write (regcache,
357 tdep->ppc_ev0_regnum + greg, val);
358 greg++;
359 }
360 else
361 {
362 argoffset = align_up (argoffset, 8);
363 if (write_pass)
364 write_memory (sp + argoffset, val, 8);
365 argoffset += 8;
366 }
367 }
368 else
369 {
370 /* Reduce the parameter down to something that fits in a
371 "word". */
372 gdb_byte word[MAX_REGISTER_SIZE];
373 memset (word, 0, MAX_REGISTER_SIZE);
374 if (len > tdep->wordsize
375 || TYPE_CODE (type) == TYPE_CODE_STRUCT
376 || TYPE_CODE (type) == TYPE_CODE_UNION)
377 {
378 /* Structs and large values are put in an
379 aligned stack slot ... */
380 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
381 && TYPE_VECTOR (type)
382 && len >= 16)
383 structoffset = align_up (structoffset, 16);
384 else
385 structoffset = align_up (structoffset, 8);
386
387 if (write_pass)
388 write_memory (sp + structoffset, val, len);
389 /* ... and then a "word" pointing to that address is
390 passed as the parameter. */
391 store_unsigned_integer (word, tdep->wordsize,
392 sp + structoffset);
393 structoffset += len;
394 }
395 else if (TYPE_CODE (type) == TYPE_CODE_INT)
396 /* Sign or zero extend the "int" into a "word". */
397 store_unsigned_integer (word, tdep->wordsize,
398 unpack_long (type, val));
399 else
400 /* Always goes in the low address. */
401 memcpy (word, val, len);
402 /* Store that "word" in a register, or on the stack.
403 The words have "4" byte alignment. */
404 if (greg <= 10)
405 {
406 if (write_pass)
407 regcache_cooked_write (regcache,
408 tdep->ppc_gp0_regnum + greg, word);
409 greg++;
410 }
411 else
412 {
413 argoffset = align_up (argoffset, tdep->wordsize);
414 if (write_pass)
415 write_memory (sp + argoffset, word, tdep->wordsize);
416 argoffset += tdep->wordsize;
417 }
418 }
419 }
420
421 /* Compute the actual stack space requirements. */
422 if (!write_pass)
423 {
424 /* Remember the amount of space needed by the arguments. */
425 argspace = argoffset;
426 /* Allocate space for both the arguments and the structures. */
427 sp -= (argoffset + structoffset);
428 /* Ensure that the stack is still 16 byte aligned. */
429 sp = align_down (sp, 16);
430 }
431
432 /* The psABI says that "A caller of a function that takes a
433 variable argument list shall set condition register bit 6 to
434 1 if it passes one or more arguments in the floating-point
435 registers. It is strongly recommended that the caller set the
436 bit to 0 otherwise..." Doing this for normal functions too
437 shouldn't hurt. */
438 if (write_pass)
439 {
440 ULONGEST cr;
441
442 regcache_cooked_read_unsigned (regcache, tdep->ppc_cr_regnum, &cr);
443 if (freg > 1)
444 cr |= 0x02000000;
445 else
446 cr &= ~0x02000000;
447 regcache_cooked_write_unsigned (regcache, tdep->ppc_cr_regnum, cr);
448 }
449 }
450
451 /* Update %sp. */
452 regcache_cooked_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
453
454 /* Write the backchain (it occupies WORDSIZED bytes). */
455 write_memory_signed_integer (sp, tdep->wordsize, saved_sp);
456
457 /* Point the inferior function call's return address at the dummy's
458 breakpoint. */
459 regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
460
461 return sp;
462 }
463
464 /* Handle the return-value conventions for Decimal Floating Point values
465 in both ppc32 and ppc64, which are the same. */
466 static int
467 get_decimal_float_return_value (struct gdbarch *gdbarch, struct type *valtype,
468 struct regcache *regcache, gdb_byte *readbuf,
469 const gdb_byte *writebuf)
470 {
471 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
472
473 gdb_assert (TYPE_CODE (valtype) == TYPE_CODE_DECFLOAT);
474
475 /* 32-bit and 64-bit decimal floats in f1. */
476 if (TYPE_LENGTH (valtype) <= 8)
477 {
478 if (writebuf != NULL)
479 {
480 gdb_byte regval[MAX_REGISTER_SIZE];
481 const gdb_byte *p;
482
483 /* 32-bit decimal float is right aligned in the doubleword. */
484 if (TYPE_LENGTH (valtype) == 4)
485 {
486 memcpy (regval + 4, writebuf, 4);
487 p = regval;
488 }
489 else
490 p = writebuf;
491
492 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, p);
493 }
494 if (readbuf != NULL)
495 {
496 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, readbuf);
497
498 /* Left align 32-bit decimal float. */
499 if (TYPE_LENGTH (valtype) == 4)
500 memcpy (readbuf, readbuf + 4, 4);
501 }
502 }
503 /* 128-bit decimal floats in f2,f3. */
504 else if (TYPE_LENGTH (valtype) == 16)
505 {
506 if (writebuf != NULL || readbuf != NULL)
507 {
508 int i;
509
510 for (i = 0; i < 2; i++)
511 {
512 if (writebuf != NULL)
513 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 2 + i,
514 writebuf + i * 8);
515 if (readbuf != NULL)
516 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 2 + i,
517 readbuf + i * 8);
518 }
519 }
520 }
521 else
522 /* Can't happen. */
523 internal_error (__FILE__, __LINE__, "Unknown decimal float size.");
524
525 return RETURN_VALUE_REGISTER_CONVENTION;
526 }
527
528 /* Handle the return-value conventions specified by the SysV 32-bit
529 PowerPC ABI (including all the supplements):
530
531 no floating-point: floating-point values returned using 32-bit
532 general-purpose registers.
533
534 Altivec: 128-bit vectors returned using vector registers.
535
536 e500: 64-bit vectors returned using the full full 64 bit EV
537 register, floating-point values returned using 32-bit
538 general-purpose registers.
539
540 GCC (broken): Small struct values right (instead of left) aligned
541 when returned in general-purpose registers. */
542
543 static enum return_value_convention
544 do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type,
545 struct regcache *regcache, gdb_byte *readbuf,
546 const gdb_byte *writebuf, int broken_gcc)
547 {
548 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
549 gdb_assert (tdep->wordsize == 4);
550 if (TYPE_CODE (type) == TYPE_CODE_FLT
551 && TYPE_LENGTH (type) <= 8
552 && !tdep->soft_float)
553 {
554 if (readbuf)
555 {
556 /* Floats and doubles stored in "f1". Convert the value to
557 the required type. */
558 gdb_byte regval[MAX_REGISTER_SIZE];
559 struct type *regtype = register_type (gdbarch,
560 tdep->ppc_fp0_regnum + 1);
561 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
562 convert_typed_floating (regval, regtype, readbuf, type);
563 }
564 if (writebuf)
565 {
566 /* Floats and doubles stored in "f1". Convert the value to
567 the register's "double" type. */
568 gdb_byte regval[MAX_REGISTER_SIZE];
569 struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
570 convert_typed_floating (writebuf, type, regval, regtype);
571 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
572 }
573 return RETURN_VALUE_REGISTER_CONVENTION;
574 }
575 if (TYPE_CODE (type) == TYPE_CODE_FLT
576 && TYPE_LENGTH (type) == 16
577 && !tdep->soft_float
578 && (gdbarch_long_double_format (gdbarch) == floatformats_ibm_long_double))
579 {
580 /* IBM long double stored in f1 and f2. */
581 if (readbuf)
582 {
583 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, readbuf);
584 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 2,
585 readbuf + 8);
586 }
587 if (writebuf)
588 {
589 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, writebuf);
590 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 2,
591 writebuf + 8);
592 }
593 return RETURN_VALUE_REGISTER_CONVENTION;
594 }
595 if (TYPE_CODE (type) == TYPE_CODE_FLT
596 && TYPE_LENGTH (type) == 16
597 && (gdbarch_long_double_format (gdbarch) == floatformats_ibm_long_double))
598 {
599 /* Soft-float IBM long double stored in r3, r4, r5, r6. */
600 if (readbuf)
601 {
602 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, readbuf);
603 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
604 readbuf + 4);
605 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 5,
606 readbuf + 8);
607 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 6,
608 readbuf + 12);
609 }
610 if (writebuf)
611 {
612 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
613 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
614 writebuf + 4);
615 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 5,
616 writebuf + 8);
617 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 6,
618 writebuf + 12);
619 }
620 return RETURN_VALUE_REGISTER_CONVENTION;
621 }
622 if ((TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) == 8)
623 || (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8))
624 {
625 if (readbuf)
626 {
627 /* A long long, or a double stored in the 32 bit r3/r4. */
628 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
629 readbuf + 0);
630 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
631 readbuf + 4);
632 }
633 if (writebuf)
634 {
635 /* A long long, or a double stored in the 32 bit r3/r4. */
636 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
637 writebuf + 0);
638 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
639 writebuf + 4);
640 }
641 return RETURN_VALUE_REGISTER_CONVENTION;
642 }
643 if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && !tdep->soft_float)
644 return get_decimal_float_return_value (gdbarch, type, regcache, readbuf,
645 writebuf);
646 else if ((TYPE_CODE (type) == TYPE_CODE_INT
647 || TYPE_CODE (type) == TYPE_CODE_CHAR
648 || TYPE_CODE (type) == TYPE_CODE_BOOL
649 || TYPE_CODE (type) == TYPE_CODE_PTR
650 || TYPE_CODE (type) == TYPE_CODE_REF
651 || TYPE_CODE (type) == TYPE_CODE_ENUM)
652 && TYPE_LENGTH (type) <= tdep->wordsize)
653 {
654 if (readbuf)
655 {
656 /* Some sort of integer stored in r3. Since TYPE isn't
657 bigger than the register, sign extension isn't a problem
658 - just do everything unsigned. */
659 ULONGEST regval;
660 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
661 &regval);
662 store_unsigned_integer (readbuf, TYPE_LENGTH (type), regval);
663 }
664 if (writebuf)
665 {
666 /* Some sort of integer stored in r3. Use unpack_long since
667 that should handle any required sign extension. */
668 regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
669 unpack_long (type, writebuf));
670 }
671 return RETURN_VALUE_REGISTER_CONVENTION;
672 }
673 if (TYPE_LENGTH (type) == 16
674 && TYPE_CODE (type) == TYPE_CODE_ARRAY
675 && TYPE_VECTOR (type)
676 && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
677 {
678 if (readbuf)
679 {
680 /* Altivec places the return value in "v2". */
681 regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
682 }
683 if (writebuf)
684 {
685 /* Altivec places the return value in "v2". */
686 regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
687 }
688 return RETURN_VALUE_REGISTER_CONVENTION;
689 }
690 if (TYPE_LENGTH (type) == 16
691 && TYPE_CODE (type) == TYPE_CODE_ARRAY
692 && TYPE_VECTOR (type)
693 && tdep->vector_abi == POWERPC_VEC_GENERIC)
694 {
695 /* GCC -maltivec -mabi=no-altivec returns vectors in r3/r4/r5/r6.
696 GCC without AltiVec returns them in memory, but it warns about
697 ABI risks in that case; we don't try to support it. */
698 if (readbuf)
699 {
700 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
701 readbuf + 0);
702 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
703 readbuf + 4);
704 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 5,
705 readbuf + 8);
706 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 6,
707 readbuf + 12);
708 }
709 if (writebuf)
710 {
711 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
712 writebuf + 0);
713 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
714 writebuf + 4);
715 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 5,
716 writebuf + 8);
717 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 6,
718 writebuf + 12);
719 }
720 return RETURN_VALUE_REGISTER_CONVENTION;
721 }
722 if (TYPE_LENGTH (type) == 8
723 && TYPE_CODE (type) == TYPE_CODE_ARRAY
724 && TYPE_VECTOR (type)
725 && tdep->vector_abi == POWERPC_VEC_SPE)
726 {
727 /* The e500 ABI places return values for the 64-bit DSP types
728 (__ev64_opaque__) in r3. However, in GDB-speak, ev3
729 corresponds to the entire r3 value for e500, whereas GDB's r3
730 only corresponds to the least significant 32-bits. So place
731 the 64-bit DSP type's value in ev3. */
732 if (readbuf)
733 regcache_cooked_read (regcache, tdep->ppc_ev0_regnum + 3, readbuf);
734 if (writebuf)
735 regcache_cooked_write (regcache, tdep->ppc_ev0_regnum + 3, writebuf);
736 return RETURN_VALUE_REGISTER_CONVENTION;
737 }
738 if (broken_gcc && TYPE_LENGTH (type) <= 8)
739 {
740 /* GCC screwed up for structures or unions whose size is less
741 than or equal to 8 bytes.. Instead of left-aligning, it
742 right-aligns the data into the buffer formed by r3, r4. */
743 gdb_byte regvals[MAX_REGISTER_SIZE * 2];
744 int len = TYPE_LENGTH (type);
745 int offset = (2 * tdep->wordsize - len) % tdep->wordsize;
746
747 if (readbuf)
748 {
749 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
750 regvals + 0 * tdep->wordsize);
751 if (len > tdep->wordsize)
752 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
753 regvals + 1 * tdep->wordsize);
754 memcpy (readbuf, regvals + offset, len);
755 }
756 if (writebuf)
757 {
758 memset (regvals, 0, sizeof regvals);
759 memcpy (regvals + offset, writebuf, len);
760 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
761 regvals + 0 * tdep->wordsize);
762 if (len > tdep->wordsize)
763 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
764 regvals + 1 * tdep->wordsize);
765 }
766
767 return RETURN_VALUE_REGISTER_CONVENTION;
768 }
769 if (TYPE_LENGTH (type) <= 8)
770 {
771 if (readbuf)
772 {
773 /* This matches SVr4 PPC, it does not match GCC. */
774 /* The value is right-padded to 8 bytes and then loaded, as
775 two "words", into r3/r4. */
776 gdb_byte regvals[MAX_REGISTER_SIZE * 2];
777 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
778 regvals + 0 * tdep->wordsize);
779 if (TYPE_LENGTH (type) > tdep->wordsize)
780 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
781 regvals + 1 * tdep->wordsize);
782 memcpy (readbuf, regvals, TYPE_LENGTH (type));
783 }
784 if (writebuf)
785 {
786 /* This matches SVr4 PPC, it does not match GCC. */
787 /* The value is padded out to 8 bytes and then loaded, as
788 two "words" into r3/r4. */
789 gdb_byte regvals[MAX_REGISTER_SIZE * 2];
790 memset (regvals, 0, sizeof regvals);
791 memcpy (regvals, writebuf, TYPE_LENGTH (type));
792 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
793 regvals + 0 * tdep->wordsize);
794 if (TYPE_LENGTH (type) > tdep->wordsize)
795 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
796 regvals + 1 * tdep->wordsize);
797 }
798 return RETURN_VALUE_REGISTER_CONVENTION;
799 }
800 return RETURN_VALUE_STRUCT_CONVENTION;
801 }
802
803 enum return_value_convention
804 ppc_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
805 struct regcache *regcache, gdb_byte *readbuf,
806 const gdb_byte *writebuf)
807 {
808 return do_ppc_sysv_return_value (gdbarch, valtype, regcache, readbuf,
809 writebuf, 0);
810 }
811
812 enum return_value_convention
813 ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch,
814 struct type *valtype,
815 struct regcache *regcache,
816 gdb_byte *readbuf, const gdb_byte *writebuf)
817 {
818 return do_ppc_sysv_return_value (gdbarch, valtype, regcache, readbuf,
819 writebuf, 1);
820 }
821
822 /* The helper function for 64-bit SYSV push_dummy_call. Converts the
823 function's code address back into the function's descriptor
824 address.
825
826 Find a value for the TOC register. Every symbol should have both
827 ".FN" and "FN" in the minimal symbol table. "FN" points at the
828 FN's descriptor, while ".FN" points at the entry point (which
829 matches FUNC_ADDR). Need to reverse from FUNC_ADDR back to the
830 FN's descriptor address (while at the same time being careful to
831 find "FN" in the same object file as ".FN"). */
832
833 static int
834 convert_code_addr_to_desc_addr (CORE_ADDR code_addr, CORE_ADDR *desc_addr)
835 {
836 struct obj_section *dot_fn_section;
837 struct minimal_symbol *dot_fn;
838 struct minimal_symbol *fn;
839 CORE_ADDR toc;
840 /* Find the minimal symbol that corresponds to CODE_ADDR (should
841 have a name of the form ".FN"). */
842 dot_fn = lookup_minimal_symbol_by_pc (code_addr);
843 if (dot_fn == NULL || SYMBOL_LINKAGE_NAME (dot_fn)[0] != '.')
844 return 0;
845 /* Get the section that contains CODE_ADDR. Need this for the
846 "objfile" that it contains. */
847 dot_fn_section = find_pc_section (code_addr);
848 if (dot_fn_section == NULL || dot_fn_section->objfile == NULL)
849 return 0;
850 /* Now find the corresponding "FN" (dropping ".") minimal symbol's
851 address. Only look for the minimal symbol in ".FN"'s object file
852 - avoids problems when two object files (i.e., shared libraries)
853 contain a minimal symbol with the same name. */
854 fn = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (dot_fn) + 1, NULL,
855 dot_fn_section->objfile);
856 if (fn == NULL)
857 return 0;
858 /* Found a descriptor. */
859 (*desc_addr) = SYMBOL_VALUE_ADDRESS (fn);
860 return 1;
861 }
862
863 /* Pass the arguments in either registers, or in the stack. Using the
864 ppc 64 bit SysV ABI.
865
866 This implements a dumbed down version of the ABI. It always writes
867 values to memory, GPR and FPR, even when not necessary. Doing this
868 greatly simplifies the logic. */
869
870 CORE_ADDR
871 ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
872 struct regcache *regcache, CORE_ADDR bp_addr,
873 int nargs, struct value **args, CORE_ADDR sp,
874 int struct_return, CORE_ADDR struct_addr)
875 {
876 CORE_ADDR func_addr = find_function_addr (function, NULL);
877 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
878 ULONGEST back_chain;
879 /* See for-loop comment below. */
880 int write_pass;
881 /* Size of the Altivec's vector parameter region, the final value is
882 computed in the for-loop below. */
883 LONGEST vparam_size = 0;
884 /* Size of the general parameter region, the final value is computed
885 in the for-loop below. */
886 LONGEST gparam_size = 0;
887 /* Kevin writes ... I don't mind seeing tdep->wordsize used in the
888 calls to align_up(), align_down(), etc. because this makes it
889 easier to reuse this code (in a copy/paste sense) in the future,
890 but it is a 64-bit ABI and asserting that the wordsize is 8 bytes
891 at some point makes it easier to verify that this function is
892 correct without having to do a non-local analysis to figure out
893 the possible values of tdep->wordsize. */
894 gdb_assert (tdep->wordsize == 8);
895
896 /* This function exists to support a calling convention that
897 requires floating-point registers. It shouldn't be used on
898 processors that lack them. */
899 gdb_assert (ppc_floating_point_unit_p (gdbarch));
900
901 /* By this stage in the proceedings, SP has been decremented by "red
902 zone size" + "struct return size". Fetch the stack-pointer from
903 before this and use that as the BACK_CHAIN. */
904 regcache_cooked_read_unsigned (regcache, gdbarch_sp_regnum (gdbarch),
905 &back_chain);
906
907 /* Go through the argument list twice.
908
909 Pass 1: Compute the function call's stack space and register
910 requirements.
911
912 Pass 2: Replay the same computation but this time also write the
913 values out to the target. */
914
915 for (write_pass = 0; write_pass < 2; write_pass++)
916 {
917 int argno;
918 /* Next available floating point register for float and double
919 arguments. */
920 int freg = 1;
921 /* Next available general register for non-vector (but possibly
922 float) arguments. */
923 int greg = 3;
924 /* Next available vector register for vector arguments. */
925 int vreg = 2;
926 /* The address, at which the next general purpose parameter
927 (integer, struct, float, ...) should be saved. */
928 CORE_ADDR gparam;
929 /* Address, at which the next Altivec vector parameter should be
930 saved. */
931 CORE_ADDR vparam;
932
933 if (!write_pass)
934 {
935 /* During the first pass, GPARAM and VPARAM are more like
936 offsets (start address zero) than addresses. That way
937 the accumulate the total stack space each region
938 requires. */
939 gparam = 0;
940 vparam = 0;
941 }
942 else
943 {
944 /* Decrement the stack pointer making space for the Altivec
945 and general on-stack parameters. Set vparam and gparam
946 to their corresponding regions. */
947 vparam = align_down (sp - vparam_size, 16);
948 gparam = align_down (vparam - gparam_size, 16);
949 /* Add in space for the TOC, link editor double word,
950 compiler double word, LR save area, CR save area. */
951 sp = align_down (gparam - 48, 16);
952 }
953
954 /* If the function is returning a `struct', then there is an
955 extra hidden parameter (which will be passed in r3)
956 containing the address of that struct.. In that case we
957 should advance one word and start from r4 register to copy
958 parameters. This also consumes one on-stack parameter slot. */
959 if (struct_return)
960 {
961 if (write_pass)
962 regcache_cooked_write_signed (regcache,
963 tdep->ppc_gp0_regnum + greg,
964 struct_addr);
965 greg++;
966 gparam = align_up (gparam + tdep->wordsize, tdep->wordsize);
967 }
968
969 for (argno = 0; argno < nargs; argno++)
970 {
971 struct value *arg = args[argno];
972 struct type *type = check_typedef (value_type (arg));
973 const bfd_byte *val = value_contents (arg);
974
975 if (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) <= 8)
976 {
977 /* Floats and Doubles go in f1 .. f13. They also
978 consume a left aligned GREG,, and can end up in
979 memory. */
980 if (write_pass)
981 {
982 gdb_byte regval[MAX_REGISTER_SIZE];
983 const gdb_byte *p;
984
985 /* Version 1.7 of the 64-bit PowerPC ELF ABI says:
986
987 "Single precision floating point values are mapped to
988 the first word in a single doubleword."
989
990 And version 1.9 says:
991
992 "Single precision floating point values are mapped to
993 the second word in a single doubleword."
994
995 GDB then writes single precision floating point values
996 at both words in a doubleword, to support both ABIs. */
997 if (TYPE_LENGTH (type) == 4)
998 {
999 memcpy (regval, val, 4);
1000 memcpy (regval + 4, val, 4);
1001 p = regval;
1002 }
1003 else
1004 p = val;
1005
1006 /* Write value in the stack's parameter save area. */
1007 write_memory (gparam, p, 8);
1008
1009 if (freg <= 13)
1010 {
1011 struct type *regtype
1012 = register_type (gdbarch, tdep->ppc_fp0_regnum);
1013
1014 convert_typed_floating (val, type, regval, regtype);
1015 regcache_cooked_write (regcache,
1016 tdep->ppc_fp0_regnum + freg,
1017 regval);
1018 }
1019 if (greg <= 10)
1020 regcache_cooked_write (regcache,
1021 tdep->ppc_gp0_regnum + greg,
1022 regval);
1023 }
1024
1025 freg++;
1026 greg++;
1027 /* Always consume parameter stack space. */
1028 gparam = align_up (gparam + 8, tdep->wordsize);
1029 }
1030 else if (TYPE_CODE (type) == TYPE_CODE_FLT
1031 && TYPE_LENGTH (type) == 16
1032 && (gdbarch_long_double_format (gdbarch)
1033 == floatformats_ibm_long_double))
1034 {
1035 /* IBM long double stored in two doublewords of the
1036 parameter save area and corresponding registers. */
1037 if (write_pass)
1038 {
1039 if (!tdep->soft_float && freg <= 13)
1040 {
1041 regcache_cooked_write (regcache,
1042 tdep->ppc_fp0_regnum + freg,
1043 val);
1044 if (freg <= 12)
1045 regcache_cooked_write (regcache,
1046 tdep->ppc_fp0_regnum + freg + 1,
1047 val + 8);
1048 }
1049 if (greg <= 10)
1050 {
1051 regcache_cooked_write (regcache,
1052 tdep->ppc_gp0_regnum + greg,
1053 val);
1054 if (greg <= 9)
1055 regcache_cooked_write (regcache,
1056 tdep->ppc_gp0_regnum + greg + 1,
1057 val + 8);
1058 }
1059 write_memory (gparam, val, TYPE_LENGTH (type));
1060 }
1061 freg += 2;
1062 greg += 2;
1063 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1064 }
1065 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT
1066 && TYPE_LENGTH (type) <= 8)
1067 {
1068 /* 32-bit and 64-bit decimal floats go in f1 .. f13. They can
1069 end up in memory. */
1070 if (write_pass)
1071 {
1072 gdb_byte regval[MAX_REGISTER_SIZE];
1073 const gdb_byte *p;
1074
1075 /* 32-bit decimal floats are right aligned in the
1076 doubleword. */
1077 if (TYPE_LENGTH (type) == 4)
1078 {
1079 memcpy (regval + 4, val, 4);
1080 p = regval;
1081 }
1082 else
1083 p = val;
1084
1085 /* Write value in the stack's parameter save area. */
1086 write_memory (gparam, p, 8);
1087
1088 if (freg <= 13)
1089 regcache_cooked_write (regcache,
1090 tdep->ppc_fp0_regnum + freg, p);
1091 }
1092
1093 freg++;
1094 greg++;
1095 /* Always consume parameter stack space. */
1096 gparam = align_up (gparam + 8, tdep->wordsize);
1097 }
1098 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT &&
1099 TYPE_LENGTH (type) == 16)
1100 {
1101 /* 128-bit decimal floats go in f2 .. f12, always in even/odd
1102 pairs. They can end up in memory, using two doublewords. */
1103 if (write_pass)
1104 {
1105 if (freg <= 12)
1106 {
1107 /* Make sure freg is even. */
1108 freg += freg & 1;
1109 regcache_cooked_write (regcache,
1110 tdep->ppc_fp0_regnum + freg, val);
1111 regcache_cooked_write (regcache,
1112 tdep->ppc_fp0_regnum + freg + 1, val + 8);
1113 }
1114
1115 write_memory (gparam, val, TYPE_LENGTH (type));
1116 }
1117
1118 freg += 2;
1119 greg += 2;
1120 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1121 }
1122 else if (TYPE_LENGTH (type) == 16 && TYPE_VECTOR (type)
1123 && TYPE_CODE (type) == TYPE_CODE_ARRAY
1124 && tdep->ppc_vr0_regnum >= 0)
1125 {
1126 /* In the Altivec ABI, vectors go in the vector
1127 registers v2 .. v13, or when that runs out, a vector
1128 annex which goes above all the normal parameters.
1129 NOTE: cagney/2003-09-21: This is a guess based on the
1130 PowerOpen Altivec ABI. */
1131 if (vreg <= 13)
1132 {
1133 if (write_pass)
1134 regcache_cooked_write (regcache,
1135 tdep->ppc_vr0_regnum + vreg, val);
1136 vreg++;
1137 }
1138 else
1139 {
1140 if (write_pass)
1141 write_memory (vparam, val, TYPE_LENGTH (type));
1142 vparam = align_up (vparam + TYPE_LENGTH (type), 16);
1143 }
1144 }
1145 else if ((TYPE_CODE (type) == TYPE_CODE_INT
1146 || TYPE_CODE (type) == TYPE_CODE_ENUM
1147 || TYPE_CODE (type) == TYPE_CODE_PTR)
1148 && TYPE_LENGTH (type) <= 8)
1149 {
1150 /* Scalars and Pointers get sign[un]extended and go in
1151 gpr3 .. gpr10. They can also end up in memory. */
1152 if (write_pass)
1153 {
1154 /* Sign extend the value, then store it unsigned. */
1155 ULONGEST word = unpack_long (type, val);
1156 /* Convert any function code addresses into
1157 descriptors. */
1158 if (TYPE_CODE (type) == TYPE_CODE_PTR
1159 && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1160 {
1161 CORE_ADDR desc = word;
1162 convert_code_addr_to_desc_addr (word, &desc);
1163 word = desc;
1164 }
1165 if (greg <= 10)
1166 regcache_cooked_write_unsigned (regcache,
1167 tdep->ppc_gp0_regnum +
1168 greg, word);
1169 write_memory_unsigned_integer (gparam, tdep->wordsize,
1170 word);
1171 }
1172 greg++;
1173 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1174 }
1175 else
1176 {
1177 int byte;
1178 for (byte = 0; byte < TYPE_LENGTH (type);
1179 byte += tdep->wordsize)
1180 {
1181 if (write_pass && greg <= 10)
1182 {
1183 gdb_byte regval[MAX_REGISTER_SIZE];
1184 int len = TYPE_LENGTH (type) - byte;
1185 if (len > tdep->wordsize)
1186 len = tdep->wordsize;
1187 memset (regval, 0, sizeof regval);
1188 /* The ABI (version 1.9) specifies that values
1189 smaller than one doubleword are right-aligned
1190 and those larger are left-aligned. GCC
1191 versions before 3.4 implemented this
1192 incorrectly; see
1193 <http://gcc.gnu.org/gcc-3.4/powerpc-abi.html>. */
1194 if (byte == 0)
1195 memcpy (regval + tdep->wordsize - len,
1196 val + byte, len);
1197 else
1198 memcpy (regval, val + byte, len);
1199 regcache_cooked_write (regcache, greg, regval);
1200 }
1201 greg++;
1202 }
1203 if (write_pass)
1204 /* WARNING: cagney/2003-09-21: Strictly speaking, this
1205 isn't necessary, unfortunately, GCC appears to get
1206 "struct convention" parameter passing wrong putting
1207 odd sized structures in memory instead of in a
1208 register. Work around this by always writing the
1209 value to memory. Fortunately, doing this
1210 simplifies the code. */
1211 write_memory (gparam, val, TYPE_LENGTH (type));
1212 if (freg <= 13
1213 && TYPE_CODE (type) == TYPE_CODE_STRUCT
1214 && TYPE_NFIELDS (type) == 1
1215 && TYPE_LENGTH (type) <= 16)
1216 {
1217 /* The ABI (version 1.9) specifies that structs
1218 containing a single floating-point value, at any
1219 level of nesting of single-member structs, are
1220 passed in floating-point registers. */
1221 while (TYPE_CODE (type) == TYPE_CODE_STRUCT
1222 && TYPE_NFIELDS (type) == 1)
1223 type = check_typedef (TYPE_FIELD_TYPE (type, 0));
1224 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1225 {
1226 if (TYPE_LENGTH (type) <= 8)
1227 {
1228 if (write_pass)
1229 {
1230 gdb_byte regval[MAX_REGISTER_SIZE];
1231 struct type *regtype
1232 = register_type (gdbarch,
1233 tdep->ppc_fp0_regnum);
1234 convert_typed_floating (val, type, regval,
1235 regtype);
1236 regcache_cooked_write (regcache,
1237 (tdep->ppc_fp0_regnum
1238 + freg),
1239 regval);
1240 }
1241 freg++;
1242 }
1243 else if (TYPE_LENGTH (type) == 16
1244 && (gdbarch_long_double_format (gdbarch)
1245 == floatformats_ibm_long_double))
1246 {
1247 if (write_pass)
1248 {
1249 regcache_cooked_write (regcache,
1250 (tdep->ppc_fp0_regnum
1251 + freg),
1252 val);
1253 if (freg <= 12)
1254 regcache_cooked_write (regcache,
1255 (tdep->ppc_fp0_regnum
1256 + freg + 1),
1257 val + 8);
1258 }
1259 freg += 2;
1260 }
1261 }
1262 }
1263 /* Always consume parameter stack space. */
1264 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1265 }
1266 }
1267
1268 if (!write_pass)
1269 {
1270 /* Save the true region sizes ready for the second pass. */
1271 vparam_size = vparam;
1272 /* Make certain that the general parameter save area is at
1273 least the minimum 8 registers (or doublewords) in size. */
1274 if (greg < 8)
1275 gparam_size = 8 * tdep->wordsize;
1276 else
1277 gparam_size = gparam;
1278 }
1279 }
1280
1281 /* Update %sp. */
1282 regcache_cooked_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
1283
1284 /* Write the backchain (it occupies WORDSIZED bytes). */
1285 write_memory_signed_integer (sp, tdep->wordsize, back_chain);
1286
1287 /* Point the inferior function call's return address at the dummy's
1288 breakpoint. */
1289 regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
1290
1291 /* Use the func_addr to find the descriptor, and use that to find
1292 the TOC. */
1293 {
1294 CORE_ADDR desc_addr;
1295 if (convert_code_addr_to_desc_addr (func_addr, &desc_addr))
1296 {
1297 /* The TOC is the second double word in the descriptor. */
1298 CORE_ADDR toc =
1299 read_memory_unsigned_integer (desc_addr + tdep->wordsize,
1300 tdep->wordsize);
1301 regcache_cooked_write_unsigned (regcache,
1302 tdep->ppc_gp0_regnum + 2, toc);
1303 }
1304 }
1305
1306 return sp;
1307 }
1308
1309
1310 /* The 64 bit ABI return value convention.
1311
1312 Return non-zero if the return-value is stored in a register, return
1313 0 if the return-value is instead stored on the stack (a.k.a.,
1314 struct return convention).
1315
1316 For a return-value stored in a register: when WRITEBUF is non-NULL,
1317 copy the buffer to the corresponding register return-value location
1318 location; when READBUF is non-NULL, fill the buffer from the
1319 corresponding register return-value location. */
1320 enum return_value_convention
1321 ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
1322 struct regcache *regcache, gdb_byte *readbuf,
1323 const gdb_byte *writebuf)
1324 {
1325 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1326
1327 /* This function exists to support a calling convention that
1328 requires floating-point registers. It shouldn't be used on
1329 processors that lack them. */
1330 gdb_assert (ppc_floating_point_unit_p (gdbarch));
1331
1332 /* Floats and doubles in F1. */
1333 if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
1334 {
1335 gdb_byte regval[MAX_REGISTER_SIZE];
1336 struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
1337 if (writebuf != NULL)
1338 {
1339 convert_typed_floating (writebuf, valtype, regval, regtype);
1340 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
1341 }
1342 if (readbuf != NULL)
1343 {
1344 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
1345 convert_typed_floating (regval, regtype, readbuf, valtype);
1346 }
1347 return RETURN_VALUE_REGISTER_CONVENTION;
1348 }
1349 if (TYPE_CODE (valtype) == TYPE_CODE_DECFLOAT)
1350 return get_decimal_float_return_value (gdbarch, valtype, regcache, readbuf,
1351 writebuf);
1352 /* Integers in r3. */
1353 if ((TYPE_CODE (valtype) == TYPE_CODE_INT
1354 || TYPE_CODE (valtype) == TYPE_CODE_ENUM)
1355 && TYPE_LENGTH (valtype) <= 8)
1356 {
1357 if (writebuf != NULL)
1358 {
1359 /* Be careful to sign extend the value. */
1360 regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
1361 unpack_long (valtype, writebuf));
1362 }
1363 if (readbuf != NULL)
1364 {
1365 /* Extract the integer from r3. Since this is truncating the
1366 value, there isn't a sign extension problem. */
1367 ULONGEST regval;
1368 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
1369 &regval);
1370 store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), regval);
1371 }
1372 return RETURN_VALUE_REGISTER_CONVENTION;
1373 }
1374 /* All pointers live in r3. */
1375 if (TYPE_CODE (valtype) == TYPE_CODE_PTR)
1376 {
1377 /* All pointers live in r3. */
1378 if (writebuf != NULL)
1379 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
1380 if (readbuf != NULL)
1381 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, readbuf);
1382 return RETURN_VALUE_REGISTER_CONVENTION;
1383 }
1384 /* Array type has more than one use. */
1385 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
1386 {
1387 /* Small character arrays are returned, right justified, in r3. */
1388 if (TYPE_LENGTH (valtype) <= 8
1389 && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
1390 && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
1391 {
1392 int offset = (register_size (gdbarch, tdep->ppc_gp0_regnum + 3)
1393 - TYPE_LENGTH (valtype));
1394 if (writebuf != NULL)
1395 regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
1396 offset, TYPE_LENGTH (valtype), writebuf);
1397 if (readbuf != NULL)
1398 regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
1399 offset, TYPE_LENGTH (valtype), readbuf);
1400 return RETURN_VALUE_REGISTER_CONVENTION;
1401 }
1402 /* A VMX vector is returned in v2. */
1403 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
1404 && TYPE_VECTOR (valtype) && tdep->ppc_vr0_regnum >= 0)
1405 {
1406 if (readbuf)
1407 regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
1408 if (writebuf)
1409 regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
1410 return RETURN_VALUE_REGISTER_CONVENTION;
1411 }
1412 }
1413 /* Big floating point values get stored in adjacent floating
1414 point registers, starting with F1. */
1415 if (TYPE_CODE (valtype) == TYPE_CODE_FLT
1416 && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32))
1417 {
1418 if (writebuf || readbuf != NULL)
1419 {
1420 int i;
1421 for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
1422 {
1423 if (writebuf != NULL)
1424 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i,
1425 (const bfd_byte *) writebuf + i * 8);
1426 if (readbuf != NULL)
1427 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i,
1428 (bfd_byte *) readbuf + i * 8);
1429 }
1430 }
1431 return RETURN_VALUE_REGISTER_CONVENTION;
1432 }
1433 /* Complex values get returned in f1:f2, need to convert. */
1434 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX
1435 && (TYPE_LENGTH (valtype) == 8 || TYPE_LENGTH (valtype) == 16))
1436 {
1437 if (regcache != NULL)
1438 {
1439 int i;
1440 for (i = 0; i < 2; i++)
1441 {
1442 gdb_byte regval[MAX_REGISTER_SIZE];
1443 struct type *regtype =
1444 register_type (gdbarch, tdep->ppc_fp0_regnum);
1445 if (writebuf != NULL)
1446 {
1447 convert_typed_floating ((const bfd_byte *) writebuf +
1448 i * (TYPE_LENGTH (valtype) / 2),
1449 valtype, regval, regtype);
1450 regcache_cooked_write (regcache,
1451 tdep->ppc_fp0_regnum + 1 + i,
1452 regval);
1453 }
1454 if (readbuf != NULL)
1455 {
1456 regcache_cooked_read (regcache,
1457 tdep->ppc_fp0_regnum + 1 + i,
1458 regval);
1459 convert_typed_floating (regval, regtype,
1460 (bfd_byte *) readbuf +
1461 i * (TYPE_LENGTH (valtype) / 2),
1462 valtype);
1463 }
1464 }
1465 }
1466 return RETURN_VALUE_REGISTER_CONVENTION;
1467 }
1468 /* Big complex values get stored in f1:f4. */
1469 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32)
1470 {
1471 if (regcache != NULL)
1472 {
1473 int i;
1474 for (i = 0; i < 4; i++)
1475 {
1476 if (writebuf != NULL)
1477 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i,
1478 (const bfd_byte *) writebuf + i * 8);
1479 if (readbuf != NULL)
1480 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i,
1481 (bfd_byte *) readbuf + i * 8);
1482 }
1483 }
1484 return RETURN_VALUE_REGISTER_CONVENTION;
1485 }
1486 return RETURN_VALUE_STRUCT_CONVENTION;
1487 }
1488
1489 CORE_ADDR
1490 ppc64_sysv_abi_adjust_breakpoint_address (struct gdbarch *gdbarch,
1491 CORE_ADDR bpaddr)
1492 {
1493 /* PPC64 SYSV specifies that the minimal-symbol "FN" should point at
1494 a function-descriptor while the corresponding minimal-symbol
1495 ".FN" should point at the entry point. Consequently, a command
1496 like "break FN" applied to an object file with only minimal
1497 symbols, will insert the breakpoint into the descriptor at "FN"
1498 and not the function at ".FN". Avoid this confusion by adjusting
1499 any attempt to set a descriptor breakpoint into a corresponding
1500 function breakpoint. Note that GDB warns the user when this
1501 adjustment is applied - that's ok as otherwise the user will have
1502 no way of knowing why their breakpoint at "FN" resulted in the
1503 program stopping at ".FN". */
1504 return gdbarch_convert_from_func_ptr_addr (gdbarch, bpaddr, &current_target);
1505 }
GDB Binutils - Deliverables
This page took 0.082072 seconds and 4 git commands to generate.