projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
gdb/ChangeLog
[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-2013 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
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 3 of the License, or
11 (at your option) any later version.
12
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.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 #include "defs.h"
22 #include "gdbcore.h"
23 #include "inferior.h"
24 #include "regcache.h"
25 #include "value.h"
26 #include "gdb_string.h"
27 #include "gdb_assert.h"
28 #include "ppc-tdep.h"
29 #include "target.h"
30 #include "objfiles.h"
31 #include "infcall.h"
32 #include "dwarf2.h"
33
34
35 /* Check whether FTPYE is a (pointer to) function type that should use
36 the OpenCL vector ABI. */
37
38 static int
39 ppc_sysv_use_opencl_abi (struct type *ftype)
40 {
41 ftype = check_typedef (ftype);
42
43 if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
44 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
45
46 return (TYPE_CODE (ftype) == TYPE_CODE_FUNC
47 && TYPE_CALLING_CONVENTION (ftype) == DW_CC_GDB_IBM_OpenCL);
48 }
49
50 /* Pass the arguments in either registers, or in the stack. Using the
51 ppc sysv ABI, the first eight words of the argument list (that might
52 be less than eight parameters if some parameters occupy more than one
53 word) are passed in r3..r10 registers. float and double parameters are
54 passed in fpr's, in addition to that. Rest of the parameters if any
55 are passed in user stack.
56
57 If the function is returning a structure, then the return address is passed
58 in r3, then the first 7 words of the parametes can be passed in registers,
59 starting from r4. */
60
61 CORE_ADDR
62 ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
63 struct regcache *regcache, CORE_ADDR bp_addr,
64 int nargs, struct value **args, CORE_ADDR sp,
65 int struct_return, CORE_ADDR struct_addr)
66 {
67 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
68 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
69 int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function));
70 ULONGEST saved_sp;
71 int argspace = 0; /* 0 is an initial wrong guess. */
72 int write_pass;
73
74 gdb_assert (tdep->wordsize == 4);
75
76 regcache_cooked_read_unsigned (regcache, gdbarch_sp_regnum (gdbarch),
77 &saved_sp);
78
79 /* Go through the argument list twice.
80
81 Pass 1: Figure out how much new stack space is required for
82 arguments and pushed values. Unlike the PowerOpen ABI, the SysV
83 ABI doesn't reserve any extra space for parameters which are put
84 in registers, but does always push structures and then pass their
85 address.
86
87 Pass 2: Replay the same computation but this time also write the
88 values out to the target. */
89
90 for (write_pass = 0; write_pass < 2; write_pass++)
91 {
92 int argno;
93 /* Next available floating point register for float and double
94 arguments. */
95 int freg = 1;
96 /* Next available general register for non-float, non-vector
97 arguments. */
98 int greg = 3;
99 /* Next available vector register for vector arguments. */
100 int vreg = 2;
101 /* Arguments start above the "LR save word" and "Back chain". */
102 int argoffset = 2 * tdep->wordsize;
103 /* Structures start after the arguments. */
104 int structoffset = argoffset + argspace;
105
106 /* If the function is returning a `struct', then the first word
107 (which will be passed in r3) is used for struct return
108 address. In that case we should advance one word and start
109 from r4 register to copy parameters. */
110 if (struct_return)
111 {
112 if (write_pass)
113 regcache_cooked_write_signed (regcache,
114 tdep->ppc_gp0_regnum + greg,
115 struct_addr);
116 greg++;
117 }
118
119 for (argno = 0; argno < nargs; argno++)
120 {
121 struct value *arg = args[argno];
122 struct type *type = check_typedef (value_type (arg));
123 int len = TYPE_LENGTH (type);
124 const bfd_byte *val = value_contents (arg);
125
126 if (TYPE_CODE (type) == TYPE_CODE_FLT && len <= 8
127 && !tdep->soft_float)
128 {
129 /* Floating point value converted to "double" then
130 passed in an FP register, when the registers run out,
131 8 byte aligned stack is used. */
132 if (freg <= 8)
133 {
134 if (write_pass)
135 {
136 /* Always store the floating point value using
137 the register's floating-point format. */
138 gdb_byte regval[MAX_REGISTER_SIZE];
139 struct type *regtype
140 = register_type (gdbarch, tdep->ppc_fp0_regnum + freg);
141 convert_typed_floating (val, type, regval, regtype);
142 regcache_cooked_write (regcache,
143 tdep->ppc_fp0_regnum + freg,
144 regval);
145 }
146 freg++;
147 }
148 else
149 {
150 /* The SysV ABI tells us to convert floats to
151 doubles before writing them to an 8 byte aligned
152 stack location. Unfortunately GCC does not do
153 that, and stores floats into 4 byte aligned
154 locations without converting them to doubles.
155 Since there is no know compiler that actually
156 follows the ABI here, we implement the GCC
157 convention. */
158
159 /* Align to 4 bytes or 8 bytes depending on the type of
160 the argument (float or double). */
161 argoffset = align_up (argoffset, len);
162 if (write_pass)
163 write_memory (sp + argoffset, val, len);
164 argoffset += len;
165 }
166 }
167 else if (TYPE_CODE (type) == TYPE_CODE_FLT
168 && len == 16
169 && !tdep->soft_float
170 && (gdbarch_long_double_format (gdbarch)
171 == floatformats_ibm_long_double))
172 {
173 /* IBM long double passed in two FP registers if
174 available, otherwise 8-byte aligned stack. */
175 if (freg <= 7)
176 {
177 if (write_pass)
178 {
179 regcache_cooked_write (regcache,
180 tdep->ppc_fp0_regnum + freg,
181 val);
182 regcache_cooked_write (regcache,
183 tdep->ppc_fp0_regnum + freg + 1,
184 val + 8);
185 }
186 freg += 2;
187 }
188 else
189 {
190 argoffset = align_up (argoffset, 8);
191 if (write_pass)
192 write_memory (sp + argoffset, val, len);
193 argoffset += 16;
194 }
195 }
196 else if (len == 8
197 && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
198 || TYPE_CODE (type) == TYPE_CODE_FLT /* double */
199 || (TYPE_CODE (type) == TYPE_CODE_DECFLOAT
200 && tdep->soft_float)))
201 {
202 /* "long long" or soft-float "double" or "_Decimal64"
203 passed in an odd/even register pair with the low
204 addressed word in the odd register and the high
205 addressed word in the even register, or when the
206 registers run out an 8 byte aligned stack
207 location. */
208 if (greg > 9)
209 {
210 /* Just in case GREG was 10. */
211 greg = 11;
212 argoffset = align_up (argoffset, 8);
213 if (write_pass)
214 write_memory (sp + argoffset, val, len);
215 argoffset += 8;
216 }
217 else
218 {
219 /* Must start on an odd register - r3/r4 etc. */
220 if ((greg & 1) == 0)
221 greg++;
222 if (write_pass)
223 {
224 regcache_cooked_write (regcache,
225 tdep->ppc_gp0_regnum + greg + 0,
226 val + 0);
227 regcache_cooked_write (regcache,
228 tdep->ppc_gp0_regnum + greg + 1,
229 val + 4);
230 }
231 greg += 2;
232 }
233 }
234 else if (len == 16
235 && ((TYPE_CODE (type) == TYPE_CODE_FLT
236 && (gdbarch_long_double_format (gdbarch)
237 == floatformats_ibm_long_double))
238 || (TYPE_CODE (type) == TYPE_CODE_DECFLOAT
239 && tdep->soft_float)))
240 {
241 /* Soft-float IBM long double or _Decimal128 passed in
242 four consecutive registers, or on the stack. The
243 registers are not necessarily odd/even pairs. */
244 if (greg > 7)
245 {
246 greg = 11;
247 argoffset = align_up (argoffset, 8);
248 if (write_pass)
249 write_memory (sp + argoffset, val, len);
250 argoffset += 16;
251 }
252 else
253 {
254 if (write_pass)
255 {
256 regcache_cooked_write (regcache,
257 tdep->ppc_gp0_regnum + greg + 0,
258 val + 0);
259 regcache_cooked_write (regcache,
260 tdep->ppc_gp0_regnum + greg + 1,
261 val + 4);
262 regcache_cooked_write (regcache,
263 tdep->ppc_gp0_regnum + greg + 2,
264 val + 8);
265 regcache_cooked_write (regcache,
266 tdep->ppc_gp0_regnum + greg + 3,
267 val + 12);
268 }
269 greg += 4;
270 }
271 }
272 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && len <= 8
273 && !tdep->soft_float)
274 {
275 /* 32-bit and 64-bit decimal floats go in f1 .. f8. They can
276 end up in memory. */
277
278 if (freg <= 8)
279 {
280 if (write_pass)
281 {
282 gdb_byte regval[MAX_REGISTER_SIZE];
283 const gdb_byte *p;
284
285 /* 32-bit decimal floats are right aligned in the
286 doubleword. */
287 if (TYPE_LENGTH (type) == 4)
288 {
289 memcpy (regval + 4, val, 4);
290 p = regval;
291 }
292 else
293 p = val;
294
295 regcache_cooked_write (regcache,
296 tdep->ppc_fp0_regnum + freg, p);
297 }
298
299 freg++;
300 }
301 else
302 {
303 argoffset = align_up (argoffset, len);
304
305 if (write_pass)
306 /* Write value in the stack's parameter save area. */
307 write_memory (sp + argoffset, val, len);
308
309 argoffset += len;
310 }
311 }
312 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && len == 16
313 && !tdep->soft_float)
314 {
315 /* 128-bit decimal floats go in f2 .. f7, always in even/odd
316 pairs. They can end up in memory, using two doublewords. */
317
318 if (freg <= 6)
319 {
320 /* Make sure freg is even. */
321 freg += freg & 1;
322
323 if (write_pass)
324 {
325 regcache_cooked_write (regcache,
326 tdep->ppc_fp0_regnum + freg, val);
327 regcache_cooked_write (regcache,
328 tdep->ppc_fp0_regnum + freg + 1, val + 8);
329 }
330 }
331 else
332 {
333 argoffset = align_up (argoffset, 8);
334
335 if (write_pass)
336 write_memory (sp + argoffset, val, 16);
337
338 argoffset += 16;
339 }
340
341 /* If a 128-bit decimal float goes to the stack because only f7
342 and f8 are free (thus there's no even/odd register pair
343 available), these registers should be marked as occupied.
344 Hence we increase freg even when writing to memory. */
345 freg += 2;
346 }
347 else if (len < 16
348 && TYPE_CODE (type) == TYPE_CODE_ARRAY
349 && TYPE_VECTOR (type)
350 && opencl_abi)
351 {
352 /* OpenCL vectors shorter than 16 bytes are passed as if
353 a series of independent scalars. */
354 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
355 int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
356
357 for (i = 0; i < nelt; i++)
358 {
359 const gdb_byte *elval = val + i * TYPE_LENGTH (eltype);
360
361 if (TYPE_CODE (eltype) == TYPE_CODE_FLT && !tdep->soft_float)
362 {
363 if (freg <= 8)
364 {
365 if (write_pass)
366 {
367 int regnum = tdep->ppc_fp0_regnum + freg;
368 gdb_byte regval[MAX_REGISTER_SIZE];
369 struct type *regtype
370 = register_type (gdbarch, regnum);
371 convert_typed_floating (elval, eltype,
372 regval, regtype);
373 regcache_cooked_write (regcache, regnum, regval);
374 }
375 freg++;
376 }
377 else
378 {
379 argoffset = align_up (argoffset, len);
380 if (write_pass)
381 write_memory (sp + argoffset, val, len);
382 argoffset += len;
383 }
384 }
385 else if (TYPE_LENGTH (eltype) == 8)
386 {
387 if (greg > 9)
388 {
389 /* Just in case GREG was 10. */
390 greg = 11;
391 argoffset = align_up (argoffset, 8);
392 if (write_pass)
393 write_memory (sp + argoffset, elval,
394 TYPE_LENGTH (eltype));
395 argoffset += 8;
396 }
397 else
398 {
399 /* Must start on an odd register - r3/r4 etc. */
400 if ((greg & 1) == 0)
401 greg++;
402 if (write_pass)
403 {
404 int regnum = tdep->ppc_gp0_regnum + greg;
405 regcache_cooked_write (regcache,
406 regnum + 0, elval + 0);
407 regcache_cooked_write (regcache,
408 regnum + 1, elval + 4);
409 }
410 greg += 2;
411 }
412 }
413 else
414 {
415 gdb_byte word[MAX_REGISTER_SIZE];
416 store_unsigned_integer (word, tdep->wordsize, byte_order,
417 unpack_long (eltype, elval));
418
419 if (greg <= 10)
420 {
421 if (write_pass)
422 regcache_cooked_write (regcache,
423 tdep->ppc_gp0_regnum + greg,
424 word);
425 greg++;
426 }
427 else
428 {
429 argoffset = align_up (argoffset, tdep->wordsize);
430 if (write_pass)
431 write_memory (sp + argoffset, word, tdep->wordsize);
432 argoffset += tdep->wordsize;
433 }
434 }
435 }
436 }
437 else if (len >= 16
438 && TYPE_CODE (type) == TYPE_CODE_ARRAY
439 && TYPE_VECTOR (type)
440 && opencl_abi)
441 {
442 /* OpenCL vectors 16 bytes or longer are passed as if
443 a series of AltiVec vectors. */
444 int i;
445
446 for (i = 0; i < len / 16; i++)
447 {
448 const gdb_byte *elval = val + i * 16;
449
450 if (vreg <= 13)
451 {
452 if (write_pass)
453 regcache_cooked_write (regcache,
454 tdep->ppc_vr0_regnum + vreg,
455 elval);
456 vreg++;
457 }
458 else
459 {
460 argoffset = align_up (argoffset, 16);
461 if (write_pass)
462 write_memory (sp + argoffset, elval, 16);
463 argoffset += 16;
464 }
465 }
466 }
467 else if (len == 16
468 && TYPE_CODE (type) == TYPE_CODE_ARRAY
469 && TYPE_VECTOR (type)
470 && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
471 {
472 /* Vector parameter passed in an Altivec register, or
473 when that runs out, 16 byte aligned stack location. */
474 if (vreg <= 13)
475 {
476 if (write_pass)
477 regcache_cooked_write (regcache,
478 tdep->ppc_vr0_regnum + vreg, val);
479 vreg++;
480 }
481 else
482 {
483 argoffset = align_up (argoffset, 16);
484 if (write_pass)
485 write_memory (sp + argoffset, val, 16);
486 argoffset += 16;
487 }
488 }
489 else if (len == 8
490 && TYPE_CODE (type) == TYPE_CODE_ARRAY
491 && TYPE_VECTOR (type)
492 && tdep->vector_abi == POWERPC_VEC_SPE)
493 {
494 /* Vector parameter passed in an e500 register, or when
495 that runs out, 8 byte aligned stack location. Note
496 that since e500 vector and general purpose registers
497 both map onto the same underlying register set, a
498 "greg" and not a "vreg" is consumed here. A cooked
499 write stores the value in the correct locations
500 within the raw register cache. */
501 if (greg <= 10)
502 {
503 if (write_pass)
504 regcache_cooked_write (regcache,
505 tdep->ppc_ev0_regnum + greg, val);
506 greg++;
507 }
508 else
509 {
510 argoffset = align_up (argoffset, 8);
511 if (write_pass)
512 write_memory (sp + argoffset, val, 8);
513 argoffset += 8;
514 }
515 }
516 else
517 {
518 /* Reduce the parameter down to something that fits in a
519 "word". */
520 gdb_byte word[MAX_REGISTER_SIZE];
521 memset (word, 0, MAX_REGISTER_SIZE);
522 if (len > tdep->wordsize
523 || TYPE_CODE (type) == TYPE_CODE_STRUCT
524 || TYPE_CODE (type) == TYPE_CODE_UNION)
525 {
526 /* Structs and large values are put in an
527 aligned stack slot ... */
528 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
529 && TYPE_VECTOR (type)
530 && len >= 16)
531 structoffset = align_up (structoffset, 16);
532 else
533 structoffset = align_up (structoffset, 8);
534
535 if (write_pass)
536 write_memory (sp + structoffset, val, len);
537 /* ... and then a "word" pointing to that address is
538 passed as the parameter. */
539 store_unsigned_integer (word, tdep->wordsize, byte_order,
540 sp + structoffset);
541 structoffset += len;
542 }
543 else if (TYPE_CODE (type) == TYPE_CODE_INT)
544 /* Sign or zero extend the "int" into a "word". */
545 store_unsigned_integer (word, tdep->wordsize, byte_order,
546 unpack_long (type, val));
547 else
548 /* Always goes in the low address. */
549 memcpy (word, val, len);
550 /* Store that "word" in a register, or on the stack.
551 The words have "4" byte alignment. */
552 if (greg <= 10)
553 {
554 if (write_pass)
555 regcache_cooked_write (regcache,
556 tdep->ppc_gp0_regnum + greg, word);
557 greg++;
558 }
559 else
560 {
561 argoffset = align_up (argoffset, tdep->wordsize);
562 if (write_pass)
563 write_memory (sp + argoffset, word, tdep->wordsize);
564 argoffset += tdep->wordsize;
565 }
566 }
567 }
568
569 /* Compute the actual stack space requirements. */
570 if (!write_pass)
571 {
572 /* Remember the amount of space needed by the arguments. */
573 argspace = argoffset;
574 /* Allocate space for both the arguments and the structures. */
575 sp -= (argoffset + structoffset);
576 /* Ensure that the stack is still 16 byte aligned. */
577 sp = align_down (sp, 16);
578 }
579
580 /* The psABI says that "A caller of a function that takes a
581 variable argument list shall set condition register bit 6 to
582 1 if it passes one or more arguments in the floating-point
583 registers. It is strongly recommended that the caller set the
584 bit to 0 otherwise..." Doing this for normal functions too
585 shouldn't hurt. */
586 if (write_pass)
587 {
588 ULONGEST cr;
589
590 regcache_cooked_read_unsigned (regcache, tdep->ppc_cr_regnum, &cr);
591 if (freg > 1)
592 cr |= 0x02000000;
593 else
594 cr &= ~0x02000000;
595 regcache_cooked_write_unsigned (regcache, tdep->ppc_cr_regnum, cr);
596 }
597 }
598
599 /* Update %sp. */
600 regcache_cooked_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
601
602 /* Write the backchain (it occupies WORDSIZED bytes). */
603 write_memory_signed_integer (sp, tdep->wordsize, byte_order, saved_sp);
604
605 /* Point the inferior function call's return address at the dummy's
606 breakpoint. */
607 regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
608
609 return sp;
610 }
611
612 /* Handle the return-value conventions for Decimal Floating Point values
613 in both ppc32 and ppc64, which are the same. */
614 static int
615 get_decimal_float_return_value (struct gdbarch *gdbarch, struct type *valtype,
616 struct regcache *regcache, gdb_byte *readbuf,
617 const gdb_byte *writebuf)
618 {
619 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
620
621 gdb_assert (TYPE_CODE (valtype) == TYPE_CODE_DECFLOAT);
622
623 /* 32-bit and 64-bit decimal floats in f1. */
624 if (TYPE_LENGTH (valtype) <= 8)
625 {
626 if (writebuf != NULL)
627 {
628 gdb_byte regval[MAX_REGISTER_SIZE];
629 const gdb_byte *p;
630
631 /* 32-bit decimal float is right aligned in the doubleword. */
632 if (TYPE_LENGTH (valtype) == 4)
633 {
634 memcpy (regval + 4, writebuf, 4);
635 p = regval;
636 }
637 else
638 p = writebuf;
639
640 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, p);
641 }
642 if (readbuf != NULL)
643 {
644 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, readbuf);
645
646 /* Left align 32-bit decimal float. */
647 if (TYPE_LENGTH (valtype) == 4)
648 memcpy (readbuf, readbuf + 4, 4);
649 }
650 }
651 /* 128-bit decimal floats in f2,f3. */
652 else if (TYPE_LENGTH (valtype) == 16)
653 {
654 if (writebuf != NULL || readbuf != NULL)
655 {
656 int i;
657
658 for (i = 0; i < 2; i++)
659 {
660 if (writebuf != NULL)
661 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 2 + i,
662 writebuf + i * 8);
663 if (readbuf != NULL)
664 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 2 + i,
665 readbuf + i * 8);
666 }
667 }
668 }
669 else
670 /* Can't happen. */
671 internal_error (__FILE__, __LINE__, _("Unknown decimal float size."));
672
673 return RETURN_VALUE_REGISTER_CONVENTION;
674 }
675
676 /* Handle the return-value conventions specified by the SysV 32-bit
677 PowerPC ABI (including all the supplements):
678
679 no floating-point: floating-point values returned using 32-bit
680 general-purpose registers.
681
682 Altivec: 128-bit vectors returned using vector registers.
683
684 e500: 64-bit vectors returned using the full full 64 bit EV
685 register, floating-point values returned using 32-bit
686 general-purpose registers.
687
688 GCC (broken): Small struct values right (instead of left) aligned
689 when returned in general-purpose registers. */
690
691 static enum return_value_convention
692 do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
693 struct type *type, struct regcache *regcache,
694 gdb_byte *readbuf, const gdb_byte *writebuf,
695 int broken_gcc)
696 {
697 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
698 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
699 int opencl_abi = func_type? ppc_sysv_use_opencl_abi (func_type) : 0;
700
701 gdb_assert (tdep->wordsize == 4);
702
703 if (TYPE_CODE (type) == TYPE_CODE_FLT
704 && TYPE_LENGTH (type) <= 8
705 && !tdep->soft_float)
706 {
707 if (readbuf)
708 {
709 /* Floats and doubles stored in "f1". Convert the value to
710 the required type. */
711 gdb_byte regval[MAX_REGISTER_SIZE];
712 struct type *regtype = register_type (gdbarch,
713 tdep->ppc_fp0_regnum + 1);
714 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
715 convert_typed_floating (regval, regtype, readbuf, type);
716 }
717 if (writebuf)
718 {
719 /* Floats and doubles stored in "f1". Convert the value to
720 the register's "double" type. */
721 gdb_byte regval[MAX_REGISTER_SIZE];
722 struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
723 convert_typed_floating (writebuf, type, regval, regtype);
724 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
725 }
726 return RETURN_VALUE_REGISTER_CONVENTION;
727 }
728 if (TYPE_CODE (type) == TYPE_CODE_FLT
729 && TYPE_LENGTH (type) == 16
730 && !tdep->soft_float
731 && (gdbarch_long_double_format (gdbarch)
732 == floatformats_ibm_long_double))
733 {
734 /* IBM long double stored in f1 and f2. */
735 if (readbuf)
736 {
737 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, readbuf);
738 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 2,
739 readbuf + 8);
740 }
741 if (writebuf)
742 {
743 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, writebuf);
744 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 2,
745 writebuf + 8);
746 }
747 return RETURN_VALUE_REGISTER_CONVENTION;
748 }
749 if (TYPE_LENGTH (type) == 16
750 && ((TYPE_CODE (type) == TYPE_CODE_FLT
751 && (gdbarch_long_double_format (gdbarch)
752 == floatformats_ibm_long_double))
753 || (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && tdep->soft_float)))
754 {
755 /* Soft-float IBM long double or _Decimal128 stored in r3, r4,
756 r5, r6. */
757 if (readbuf)
758 {
759 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, readbuf);
760 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
761 readbuf + 4);
762 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 5,
763 readbuf + 8);
764 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 6,
765 readbuf + 12);
766 }
767 if (writebuf)
768 {
769 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
770 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
771 writebuf + 4);
772 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 5,
773 writebuf + 8);
774 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 6,
775 writebuf + 12);
776 }
777 return RETURN_VALUE_REGISTER_CONVENTION;
778 }
779 if ((TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) == 8)
780 || (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8)
781 || (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && TYPE_LENGTH (type) == 8
782 && tdep->soft_float))
783 {
784 if (readbuf)
785 {
786 /* A long long, double or _Decimal64 stored in the 32 bit
787 r3/r4. */
788 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
789 readbuf + 0);
790 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
791 readbuf + 4);
792 }
793 if (writebuf)
794 {
795 /* A long long, double or _Decimal64 stored in the 32 bit
796 r3/r4. */
797 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
798 writebuf + 0);
799 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
800 writebuf + 4);
801 }
802 return RETURN_VALUE_REGISTER_CONVENTION;
803 }
804 if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && !tdep->soft_float)
805 return get_decimal_float_return_value (gdbarch, type, regcache, readbuf,
806 writebuf);
807 else if ((TYPE_CODE (type) == TYPE_CODE_INT
808 || TYPE_CODE (type) == TYPE_CODE_CHAR
809 || TYPE_CODE (type) == TYPE_CODE_BOOL
810 || TYPE_CODE (type) == TYPE_CODE_PTR
811 || TYPE_CODE (type) == TYPE_CODE_REF
812 || TYPE_CODE (type) == TYPE_CODE_ENUM)
813 && TYPE_LENGTH (type) <= tdep->wordsize)
814 {
815 if (readbuf)
816 {
817 /* Some sort of integer stored in r3. Since TYPE isn't
818 bigger than the register, sign extension isn't a problem
819 - just do everything unsigned. */
820 ULONGEST regval;
821 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
822 &regval);
823 store_unsigned_integer (readbuf, TYPE_LENGTH (type), byte_order,
824 regval);
825 }
826 if (writebuf)
827 {
828 /* Some sort of integer stored in r3. Use unpack_long since
829 that should handle any required sign extension. */
830 regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
831 unpack_long (type, writebuf));
832 }
833 return RETURN_VALUE_REGISTER_CONVENTION;
834 }
835 /* OpenCL vectors < 16 bytes are returned as distinct
836 scalars in f1..f2 or r3..r10. */
837 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
838 && TYPE_VECTOR (type)
839 && TYPE_LENGTH (type) < 16
840 && opencl_abi)
841 {
842 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
843 int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
844
845 for (i = 0; i < nelt; i++)
846 {
847 int offset = i * TYPE_LENGTH (eltype);
848
849 if (TYPE_CODE (eltype) == TYPE_CODE_FLT)
850 {
851 int regnum = tdep->ppc_fp0_regnum + 1 + i;
852 gdb_byte regval[MAX_REGISTER_SIZE];
853 struct type *regtype = register_type (gdbarch, regnum);
854
855 if (writebuf != NULL)
856 {
857 convert_typed_floating (writebuf + offset, eltype,
858 regval, regtype);
859 regcache_cooked_write (regcache, regnum, regval);
860 }
861 if (readbuf != NULL)
862 {
863 regcache_cooked_read (regcache, regnum, regval);
864 convert_typed_floating (regval, regtype,
865 readbuf + offset, eltype);
866 }
867 }
868 else
869 {
870 int regnum = tdep->ppc_gp0_regnum + 3 + i;
871 ULONGEST regval;
872
873 if (writebuf != NULL)
874 {
875 regval = unpack_long (eltype, writebuf + offset);
876 regcache_cooked_write_unsigned (regcache, regnum, regval);
877 }
878 if (readbuf != NULL)
879 {
880 regcache_cooked_read_unsigned (regcache, regnum, &regval);
881 store_unsigned_integer (readbuf + offset,
882 TYPE_LENGTH (eltype), byte_order,
883 regval);
884 }
885 }
886 }
887
888 return RETURN_VALUE_REGISTER_CONVENTION;
889 }
890 /* OpenCL vectors >= 16 bytes are returned in v2..v9. */
891 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
892 && TYPE_VECTOR (type)
893 && TYPE_LENGTH (type) >= 16
894 && opencl_abi)
895 {
896 int n_regs = TYPE_LENGTH (type) / 16;
897 int i;
898
899 for (i = 0; i < n_regs; i++)
900 {
901 int offset = i * 16;
902 int regnum = tdep->ppc_vr0_regnum + 2 + i;
903
904 if (writebuf != NULL)
905 regcache_cooked_write (regcache, regnum, writebuf + offset);
906 if (readbuf != NULL)
907 regcache_cooked_read (regcache, regnum, readbuf + offset);
908 }
909
910 return RETURN_VALUE_REGISTER_CONVENTION;
911 }
912 if (TYPE_LENGTH (type) == 16
913 && TYPE_CODE (type) == TYPE_CODE_ARRAY
914 && TYPE_VECTOR (type)
915 && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
916 {
917 if (readbuf)
918 {
919 /* Altivec places the return value in "v2". */
920 regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
921 }
922 if (writebuf)
923 {
924 /* Altivec places the return value in "v2". */
925 regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
926 }
927 return RETURN_VALUE_REGISTER_CONVENTION;
928 }
929 if (TYPE_LENGTH (type) == 16
930 && TYPE_CODE (type) == TYPE_CODE_ARRAY
931 && TYPE_VECTOR (type)
932 && tdep->vector_abi == POWERPC_VEC_GENERIC)
933 {
934 /* GCC -maltivec -mabi=no-altivec returns vectors in r3/r4/r5/r6.
935 GCC without AltiVec returns them in memory, but it warns about
936 ABI risks in that case; we don't try to support it. */
937 if (readbuf)
938 {
939 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
940 readbuf + 0);
941 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
942 readbuf + 4);
943 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 5,
944 readbuf + 8);
945 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 6,
946 readbuf + 12);
947 }
948 if (writebuf)
949 {
950 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
951 writebuf + 0);
952 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
953 writebuf + 4);
954 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 5,
955 writebuf + 8);
956 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 6,
957 writebuf + 12);
958 }
959 return RETURN_VALUE_REGISTER_CONVENTION;
960 }
961 if (TYPE_LENGTH (type) == 8
962 && TYPE_CODE (type) == TYPE_CODE_ARRAY
963 && TYPE_VECTOR (type)
964 && tdep->vector_abi == POWERPC_VEC_SPE)
965 {
966 /* The e500 ABI places return values for the 64-bit DSP types
967 (__ev64_opaque__) in r3. However, in GDB-speak, ev3
968 corresponds to the entire r3 value for e500, whereas GDB's r3
969 only corresponds to the least significant 32-bits. So place
970 the 64-bit DSP type's value in ev3. */
971 if (readbuf)
972 regcache_cooked_read (regcache, tdep->ppc_ev0_regnum + 3, readbuf);
973 if (writebuf)
974 regcache_cooked_write (regcache, tdep->ppc_ev0_regnum + 3, writebuf);
975 return RETURN_VALUE_REGISTER_CONVENTION;
976 }
977 if (broken_gcc && TYPE_LENGTH (type) <= 8)
978 {
979 /* GCC screwed up for structures or unions whose size is less
980 than or equal to 8 bytes.. Instead of left-aligning, it
981 right-aligns the data into the buffer formed by r3, r4. */
982 gdb_byte regvals[MAX_REGISTER_SIZE * 2];
983 int len = TYPE_LENGTH (type);
984 int offset = (2 * tdep->wordsize - len) % tdep->wordsize;
985
986 if (readbuf)
987 {
988 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
989 regvals + 0 * tdep->wordsize);
990 if (len > tdep->wordsize)
991 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
992 regvals + 1 * tdep->wordsize);
993 memcpy (readbuf, regvals + offset, len);
994 }
995 if (writebuf)
996 {
997 memset (regvals, 0, sizeof regvals);
998 memcpy (regvals + offset, writebuf, len);
999 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
1000 regvals + 0 * tdep->wordsize);
1001 if (len > tdep->wordsize)
1002 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
1003 regvals + 1 * tdep->wordsize);
1004 }
1005
1006 return RETURN_VALUE_REGISTER_CONVENTION;
1007 }
1008 if (TYPE_LENGTH (type) <= 8)
1009 {
1010 if (readbuf)
1011 {
1012 /* This matches SVr4 PPC, it does not match GCC. */
1013 /* The value is right-padded to 8 bytes and then loaded, as
1014 two "words", into r3/r4. */
1015 gdb_byte regvals[MAX_REGISTER_SIZE * 2];
1016 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
1017 regvals + 0 * tdep->wordsize);
1018 if (TYPE_LENGTH (type) > tdep->wordsize)
1019 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
1020 regvals + 1 * tdep->wordsize);
1021 memcpy (readbuf, regvals, TYPE_LENGTH (type));
1022 }
1023 if (writebuf)
1024 {
1025 /* This matches SVr4 PPC, it does not match GCC. */
1026 /* The value is padded out to 8 bytes and then loaded, as
1027 two "words" into r3/r4. */
1028 gdb_byte regvals[MAX_REGISTER_SIZE * 2];
1029 memset (regvals, 0, sizeof regvals);
1030 memcpy (regvals, writebuf, TYPE_LENGTH (type));
1031 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
1032 regvals + 0 * tdep->wordsize);
1033 if (TYPE_LENGTH (type) > tdep->wordsize)
1034 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
1035 regvals + 1 * tdep->wordsize);
1036 }
1037 return RETURN_VALUE_REGISTER_CONVENTION;
1038 }
1039 return RETURN_VALUE_STRUCT_CONVENTION;
1040 }
1041
1042 enum return_value_convention
1043 ppc_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
1044 struct type *valtype, struct regcache *regcache,
1045 gdb_byte *readbuf, const gdb_byte *writebuf)
1046 {
1047 return do_ppc_sysv_return_value (gdbarch,
1048 function ? value_type (function) : NULL,
1049 valtype, regcache, readbuf, writebuf, 0);
1050 }
1051
1052 enum return_value_convention
1053 ppc_sysv_abi_broken_return_value (struct gdbarch *gdbarch,
1054 struct value *function,
1055 struct type *valtype,
1056 struct regcache *regcache,
1057 gdb_byte *readbuf, const gdb_byte *writebuf)
1058 {
1059 return do_ppc_sysv_return_value (gdbarch,
1060 function ? value_type (function) : NULL,
1061 valtype, regcache, readbuf, writebuf, 1);
1062 }
1063
1064 /* The helper function for 64-bit SYSV push_dummy_call. Converts the
1065 function's code address back into the function's descriptor
1066 address.
1067
1068 Find a value for the TOC register. Every symbol should have both
1069 ".FN" and "FN" in the minimal symbol table. "FN" points at the
1070 FN's descriptor, while ".FN" points at the entry point (which
1071 matches FUNC_ADDR). Need to reverse from FUNC_ADDR back to the
1072 FN's descriptor address (while at the same time being careful to
1073 find "FN" in the same object file as ".FN"). */
1074
1075 static int
1076 convert_code_addr_to_desc_addr (CORE_ADDR code_addr, CORE_ADDR *desc_addr)
1077 {
1078 struct obj_section *dot_fn_section;
1079 struct minimal_symbol *dot_fn;
1080 struct minimal_symbol *fn;
1081 /* Find the minimal symbol that corresponds to CODE_ADDR (should
1082 have a name of the form ".FN"). */
1083 dot_fn = lookup_minimal_symbol_by_pc (code_addr);
1084 if (dot_fn == NULL || SYMBOL_LINKAGE_NAME (dot_fn)[0] != '.')
1085 return 0;
1086 /* Get the section that contains CODE_ADDR. Need this for the
1087 "objfile" that it contains. */
1088 dot_fn_section = find_pc_section (code_addr);
1089 if (dot_fn_section == NULL || dot_fn_section->objfile == NULL)
1090 return 0;
1091 /* Now find the corresponding "FN" (dropping ".") minimal symbol's
1092 address. Only look for the minimal symbol in ".FN"'s object file
1093 - avoids problems when two object files (i.e., shared libraries)
1094 contain a minimal symbol with the same name. */
1095 fn = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (dot_fn) + 1, NULL,
1096 dot_fn_section->objfile);
1097 if (fn == NULL)
1098 return 0;
1099 /* Found a descriptor. */
1100 (*desc_addr) = SYMBOL_VALUE_ADDRESS (fn);
1101 return 1;
1102 }
1103
1104 /* Push a float in either registers, or in the stack. Using the ppc 64 bit
1105 SysV ABI.
1106
1107 This implements a dumbed down version of the ABI. It always writes
1108 values to memory, GPR and FPR, even when not necessary. Doing this
1109 greatly simplifies the logic. */
1110
1111 static void
1112 ppc64_sysv_abi_push_float (struct gdbarch *gdbarch, struct regcache *regcache,
1113 struct gdbarch_tdep *tdep, struct type *type,
1114 const bfd_byte *val, int freg, int greg,
1115 CORE_ADDR gparam)
1116 {
1117 gdb_byte regval[MAX_REGISTER_SIZE];
1118 const gdb_byte *p;
1119
1120 if (TYPE_LENGTH (type) <= 8)
1121 {
1122 /* Version 1.7 of the 64-bit PowerPC ELF ABI says:
1123
1124 "Single precision floating point values are mapped to
1125 the first word in a single doubleword."
1126
1127 And version 1.9 says:
1128
1129 "Single precision floating point values are mapped to
1130 the second word in a single doubleword."
1131
1132 GDB then writes single precision floating point values
1133 at both words in a doubleword, to support both ABIs. */
1134 if (TYPE_LENGTH (type) == 4)
1135 {
1136 memcpy (regval, val, 4);
1137 memcpy (regval + 4, val, 4);
1138 p = regval;
1139 }
1140 else
1141 p = val;
1142
1143 /* Write value in the stack's parameter save area. */
1144 write_memory (gparam, p, 8);
1145
1146 /* Floats and Doubles go in f1 .. f13. They also consume a left aligned
1147 GREG, and can end up in memory. */
1148 if (freg <= 13)
1149 {
1150 struct type *regtype;
1151
1152 regtype = register_type (gdbarch, tdep->ppc_fp0_regnum + freg);
1153 convert_typed_floating (val, type, regval, regtype);
1154 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + freg, regval);
1155 }
1156 if (greg <= 10)
1157 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + greg, regval);
1158 }
1159 else
1160 {
1161 /* IBM long double stored in two doublewords of the
1162 parameter save area and corresponding registers. */
1163 if (!tdep->soft_float && freg <= 13)
1164 {
1165 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + freg, val);
1166 if (freg <= 12)
1167 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + freg + 1,
1168 val + 8);
1169 }
1170 if (greg <= 10)
1171 {
1172 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + greg, val);
1173 if (greg <= 9)
1174 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + greg + 1,
1175 val + 8);
1176 }
1177 write_memory (gparam, val, TYPE_LENGTH (type));
1178 }
1179 }
1180
1181 /* Pass the arguments in either registers, or in the stack. Using the
1182 ppc 64 bit SysV ABI.
1183
1184 This implements a dumbed down version of the ABI. It always writes
1185 values to memory, GPR and FPR, even when not necessary. Doing this
1186 greatly simplifies the logic. */
1187
1188 CORE_ADDR
1189 ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
1190 struct value *function,
1191 struct regcache *regcache, CORE_ADDR bp_addr,
1192 int nargs, struct value **args, CORE_ADDR sp,
1193 int struct_return, CORE_ADDR struct_addr)
1194 {
1195 CORE_ADDR func_addr = find_function_addr (function, NULL);
1196 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1197 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1198 int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function));
1199 ULONGEST back_chain;
1200 /* See for-loop comment below. */
1201 int write_pass;
1202 /* Size of the by-reference parameter copy region, the final value is
1203 computed in the for-loop below. */
1204 LONGEST refparam_size = 0;
1205 /* Size of the general parameter region, the final value is computed
1206 in the for-loop below. */
1207 LONGEST gparam_size = 0;
1208 /* Kevin writes ... I don't mind seeing tdep->wordsize used in the
1209 calls to align_up(), align_down(), etc. because this makes it
1210 easier to reuse this code (in a copy/paste sense) in the future,
1211 but it is a 64-bit ABI and asserting that the wordsize is 8 bytes
1212 at some point makes it easier to verify that this function is
1213 correct without having to do a non-local analysis to figure out
1214 the possible values of tdep->wordsize. */
1215 gdb_assert (tdep->wordsize == 8);
1216
1217 /* This function exists to support a calling convention that
1218 requires floating-point registers. It shouldn't be used on
1219 processors that lack them. */
1220 gdb_assert (ppc_floating_point_unit_p (gdbarch));
1221
1222 /* By this stage in the proceedings, SP has been decremented by "red
1223 zone size" + "struct return size". Fetch the stack-pointer from
1224 before this and use that as the BACK_CHAIN. */
1225 regcache_cooked_read_unsigned (regcache, gdbarch_sp_regnum (gdbarch),
1226 &back_chain);
1227
1228 /* Go through the argument list twice.
1229
1230 Pass 1: Compute the function call's stack space and register
1231 requirements.
1232
1233 Pass 2: Replay the same computation but this time also write the
1234 values out to the target. */
1235
1236 for (write_pass = 0; write_pass < 2; write_pass++)
1237 {
1238 int argno;
1239 /* Next available floating point register for float and double
1240 arguments. */
1241 int freg = 1;
1242 /* Next available general register for non-vector (but possibly
1243 float) arguments. */
1244 int greg = 3;
1245 /* Next available vector register for vector arguments. */
1246 int vreg = 2;
1247 /* The address, at which the next general purpose parameter
1248 (integer, struct, float, vector, ...) should be saved. */
1249 CORE_ADDR gparam;
1250 /* The address, at which the next by-reference parameter
1251 (non-Altivec vector, variably-sized type) should be saved. */
1252 CORE_ADDR refparam;
1253
1254 if (!write_pass)
1255 {
1256 /* During the first pass, GPARAM and REFPARAM are more like
1257 offsets (start address zero) than addresses. That way
1258 they accumulate the total stack space each region
1259 requires. */
1260 gparam = 0;
1261 refparam = 0;
1262 }
1263 else
1264 {
1265 /* Decrement the stack pointer making space for the Altivec
1266 and general on-stack parameters. Set refparam and gparam
1267 to their corresponding regions. */
1268 refparam = align_down (sp - refparam_size, 16);
1269 gparam = align_down (refparam - gparam_size, 16);
1270 /* Add in space for the TOC, link editor double word,
1271 compiler double word, LR save area, CR save area. */
1272 sp = align_down (gparam - 48, 16);
1273 }
1274
1275 /* If the function is returning a `struct', then there is an
1276 extra hidden parameter (which will be passed in r3)
1277 containing the address of that struct.. In that case we
1278 should advance one word and start from r4 register to copy
1279 parameters. This also consumes one on-stack parameter slot. */
1280 if (struct_return)
1281 {
1282 if (write_pass)
1283 regcache_cooked_write_signed (regcache,
1284 tdep->ppc_gp0_regnum + greg,
1285 struct_addr);
1286 greg++;
1287 gparam = align_up (gparam + tdep->wordsize, tdep->wordsize);
1288 }
1289
1290 for (argno = 0; argno < nargs; argno++)
1291 {
1292 struct value *arg = args[argno];
1293 struct type *type = check_typedef (value_type (arg));
1294 const bfd_byte *val = value_contents (arg);
1295
1296 if (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) <= 8)
1297 {
1298 if (write_pass)
1299 ppc64_sysv_abi_push_float (gdbarch, regcache, tdep, type,
1300 val, freg, greg, gparam);
1301
1302 freg++;
1303 greg++;
1304 /* Always consume parameter stack space. */
1305 gparam = align_up (gparam + 8, tdep->wordsize);
1306 }
1307 else if (TYPE_CODE (type) == TYPE_CODE_FLT
1308 && TYPE_LENGTH (type) == 16
1309 && (gdbarch_long_double_format (gdbarch)
1310 == floatformats_ibm_long_double))
1311 {
1312 if (write_pass)
1313 ppc64_sysv_abi_push_float (gdbarch, regcache, tdep, type,
1314 val, freg, greg, gparam);
1315 freg += 2;
1316 greg += 2;
1317 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1318 }
1319 else if (TYPE_CODE (type) == TYPE_CODE_COMPLEX
1320 && (TYPE_LENGTH (type) == 8 || TYPE_LENGTH (type) == 16))
1321 {
1322 int i;
1323
1324 for (i = 0; i < 2; i++)
1325 {
1326 if (write_pass)
1327 {
1328 struct type *target_type;
1329
1330 target_type = check_typedef (TYPE_TARGET_TYPE (type));
1331 ppc64_sysv_abi_push_float (gdbarch, regcache, tdep,
1332 target_type, val + i *
1333 TYPE_LENGTH (target_type),
1334 freg, greg, gparam);
1335 }
1336 freg++;
1337 greg++;
1338 /* Always consume parameter stack space. */
1339 gparam = align_up (gparam + 8, tdep->wordsize);
1340 }
1341 }
1342 else if (TYPE_CODE (type) == TYPE_CODE_COMPLEX
1343 && TYPE_LENGTH (type) == 32
1344 && (gdbarch_long_double_format (gdbarch)
1345 == floatformats_ibm_long_double))
1346 {
1347 int i;
1348
1349 for (i = 0; i < 2; i++)
1350 {
1351 struct type *target_type;
1352
1353 target_type = check_typedef (TYPE_TARGET_TYPE (type));
1354 if (write_pass)
1355 ppc64_sysv_abi_push_float (gdbarch, regcache, tdep,
1356 target_type, val + i *
1357 TYPE_LENGTH (target_type),
1358 freg, greg, gparam);
1359 freg += 2;
1360 greg += 2;
1361 gparam = align_up (gparam + TYPE_LENGTH (target_type),
1362 tdep->wordsize);
1363 }
1364 }
1365 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT
1366 && TYPE_LENGTH (type) <= 8)
1367 {
1368 /* 32-bit and 64-bit decimal floats go in f1 .. f13. They can
1369 end up in memory. */
1370 if (write_pass)
1371 {
1372 gdb_byte regval[MAX_REGISTER_SIZE];
1373 const gdb_byte *p;
1374
1375 /* 32-bit decimal floats are right aligned in the
1376 doubleword. */
1377 if (TYPE_LENGTH (type) == 4)
1378 {
1379 memcpy (regval + 4, val, 4);
1380 p = regval;
1381 }
1382 else
1383 p = val;
1384
1385 /* Write value in the stack's parameter save area. */
1386 write_memory (gparam, p, 8);
1387
1388 if (freg <= 13)
1389 regcache_cooked_write (regcache,
1390 tdep->ppc_fp0_regnum + freg, p);
1391 }
1392
1393 freg++;
1394 greg++;
1395 /* Always consume parameter stack space. */
1396 gparam = align_up (gparam + 8, tdep->wordsize);
1397 }
1398 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT &&
1399 TYPE_LENGTH (type) == 16)
1400 {
1401 /* 128-bit decimal floats go in f2 .. f12, always in even/odd
1402 pairs. They can end up in memory, using two doublewords. */
1403 if (write_pass)
1404 {
1405 if (freg <= 12)
1406 {
1407 /* Make sure freg is even. */
1408 freg += freg & 1;
1409 regcache_cooked_write (regcache,
1410 tdep->ppc_fp0_regnum + freg, val);
1411 regcache_cooked_write (regcache,
1412 tdep->ppc_fp0_regnum + freg + 1, val + 8);
1413 }
1414
1415 write_memory (gparam, val, TYPE_LENGTH (type));
1416 }
1417
1418 freg += 2;
1419 greg += 2;
1420 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1421 }
1422 else if (TYPE_LENGTH (type) < 16
1423 && TYPE_CODE (type) == TYPE_CODE_ARRAY
1424 && TYPE_VECTOR (type)
1425 && opencl_abi)
1426 {
1427 /* OpenCL vectors shorter than 16 bytes are passed as if
1428 a series of independent scalars. */
1429 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1430 int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
1431
1432 for (i = 0; i < nelt; i++)
1433 {
1434 const gdb_byte *elval = val + i * TYPE_LENGTH (eltype);
1435
1436 if (TYPE_CODE (eltype) == TYPE_CODE_FLT)
1437 {
1438 if (write_pass)
1439 {
1440 gdb_byte regval[MAX_REGISTER_SIZE];
1441 const gdb_byte *p;
1442
1443 if (TYPE_LENGTH (eltype) == 4)
1444 {
1445 memcpy (regval, elval, 4);
1446 memcpy (regval + 4, elval, 4);
1447 p = regval;
1448 }
1449 else
1450 p = elval;
1451
1452 write_memory (gparam, p, 8);
1453
1454 if (freg <= 13)
1455 {
1456 int regnum = tdep->ppc_fp0_regnum + freg;
1457 struct type *regtype
1458 = register_type (gdbarch, regnum);
1459
1460 convert_typed_floating (elval, eltype,
1461 regval, regtype);
1462 regcache_cooked_write (regcache, regnum, regval);
1463 }
1464
1465 if (greg <= 10)
1466 regcache_cooked_write (regcache,
1467 tdep->ppc_gp0_regnum + greg,
1468 regval);
1469 }
1470
1471 freg++;
1472 greg++;
1473 gparam = align_up (gparam + 8, tdep->wordsize);
1474 }
1475 else
1476 {
1477 if (write_pass)
1478 {
1479 ULONGEST word = unpack_long (eltype, elval);
1480 if (greg <= 10)
1481 regcache_cooked_write_unsigned
1482 (regcache, tdep->ppc_gp0_regnum + greg, word);
1483
1484 write_memory_unsigned_integer
1485 (gparam, tdep->wordsize, byte_order, word);
1486 }
1487
1488 greg++;
1489 gparam = align_up (gparam + TYPE_LENGTH (eltype),
1490 tdep->wordsize);
1491 }
1492 }
1493 }
1494 else if (TYPE_LENGTH (type) >= 16
1495 && TYPE_CODE (type) == TYPE_CODE_ARRAY
1496 && TYPE_VECTOR (type)
1497 && opencl_abi)
1498 {
1499 /* OpenCL vectors 16 bytes or longer are passed as if
1500 a series of AltiVec vectors. */
1501 int i;
1502
1503 for (i = 0; i < TYPE_LENGTH (type) / 16; i++)
1504 {
1505 const gdb_byte *elval = val + i * 16;
1506
1507 gparam = align_up (gparam, 16);
1508 greg += greg & 1;
1509
1510 if (write_pass)
1511 {
1512 if (vreg <= 13)
1513 regcache_cooked_write (regcache,
1514 tdep->ppc_vr0_regnum + vreg,
1515 elval);
1516
1517 write_memory (gparam, elval, 16);
1518 }
1519
1520 greg += 2;
1521 vreg++;
1522 gparam += 16;
1523 }
1524 }
1525 else if (TYPE_LENGTH (type) == 16 && TYPE_VECTOR (type)
1526 && TYPE_CODE (type) == TYPE_CODE_ARRAY
1527 && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
1528 {
1529 /* In the Altivec ABI, vectors go in the vector registers
1530 v2 .. v13, as well as the parameter area -- always at
1531 16-byte aligned addresses. */
1532
1533 gparam = align_up (gparam, 16);
1534 greg += greg & 1;
1535
1536 if (write_pass)
1537 {
1538 if (vreg <= 13)
1539 regcache_cooked_write (regcache,
1540 tdep->ppc_vr0_regnum + vreg, val);
1541
1542 write_memory (gparam, val, TYPE_LENGTH (type));
1543 }
1544
1545 greg += 2;
1546 vreg++;
1547 gparam += 16;
1548 }
1549 else if (TYPE_LENGTH (type) >= 16 && TYPE_VECTOR (type)
1550 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
1551 {
1552 /* Non-Altivec vectors are passed by reference. */
1553
1554 /* Copy value onto the stack ... */
1555 refparam = align_up (refparam, 16);
1556 if (write_pass)
1557 write_memory (refparam, val, TYPE_LENGTH (type));
1558
1559 /* ... and pass a pointer to the copy as parameter. */
1560 if (write_pass)
1561 {
1562 if (greg <= 10)
1563 regcache_cooked_write_unsigned (regcache,
1564 tdep->ppc_gp0_regnum +
1565 greg, refparam);
1566 write_memory_unsigned_integer (gparam, tdep->wordsize,
1567 byte_order, refparam);
1568 }
1569 greg++;
1570 gparam = align_up (gparam + tdep->wordsize, tdep->wordsize);
1571 refparam = align_up (refparam + TYPE_LENGTH (type), tdep->wordsize);
1572 }
1573 else if ((TYPE_CODE (type) == TYPE_CODE_INT
1574 || TYPE_CODE (type) == TYPE_CODE_ENUM
1575 || TYPE_CODE (type) == TYPE_CODE_BOOL
1576 || TYPE_CODE (type) == TYPE_CODE_CHAR
1577 || TYPE_CODE (type) == TYPE_CODE_PTR
1578 || TYPE_CODE (type) == TYPE_CODE_REF)
1579 && TYPE_LENGTH (type) <= 8)
1580 {
1581 /* Scalars and Pointers get sign[un]extended and go in
1582 gpr3 .. gpr10. They can also end up in memory. */
1583 if (write_pass)
1584 {
1585 /* Sign extend the value, then store it unsigned. */
1586 ULONGEST word = unpack_long (type, val);
1587 /* Convert any function code addresses into
1588 descriptors. */
1589 if (TYPE_CODE (type) == TYPE_CODE_PTR
1590 || TYPE_CODE (type) == TYPE_CODE_REF)
1591 {
1592 struct type *target_type;
1593 target_type = check_typedef (TYPE_TARGET_TYPE (type));
1594
1595 if (TYPE_CODE (target_type) == TYPE_CODE_FUNC
1596 || TYPE_CODE (target_type) == TYPE_CODE_METHOD)
1597 {
1598 CORE_ADDR desc = word;
1599 convert_code_addr_to_desc_addr (word, &desc);
1600 word = desc;
1601 }
1602 }
1603 if (greg <= 10)
1604 regcache_cooked_write_unsigned (regcache,
1605 tdep->ppc_gp0_regnum +
1606 greg, word);
1607 write_memory_unsigned_integer (gparam, tdep->wordsize,
1608 byte_order, word);
1609 }
1610 greg++;
1611 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1612 }
1613 else
1614 {
1615 int byte;
1616 for (byte = 0; byte < TYPE_LENGTH (type);
1617 byte += tdep->wordsize)
1618 {
1619 if (write_pass && greg <= 10)
1620 {
1621 gdb_byte regval[MAX_REGISTER_SIZE];
1622 int len = TYPE_LENGTH (type) - byte;
1623 if (len > tdep->wordsize)
1624 len = tdep->wordsize;
1625 memset (regval, 0, sizeof regval);
1626 /* The ABI (version 1.9) specifies that values
1627 smaller than one doubleword are right-aligned
1628 and those larger are left-aligned. GCC
1629 versions before 3.4 implemented this
1630 incorrectly; see
1631 <http://gcc.gnu.org/gcc-3.4/powerpc-abi.html>. */
1632 if (byte == 0)
1633 memcpy (regval + tdep->wordsize - len,
1634 val + byte, len);
1635 else
1636 memcpy (regval, val + byte, len);
1637 regcache_cooked_write (regcache, greg, regval);
1638 }
1639 greg++;
1640 }
1641 if (write_pass)
1642 {
1643 /* WARNING: cagney/2003-09-21: Strictly speaking, this
1644 isn't necessary, unfortunately, GCC appears to get
1645 "struct convention" parameter passing wrong putting
1646 odd sized structures in memory instead of in a
1647 register. Work around this by always writing the
1648 value to memory. Fortunately, doing this
1649 simplifies the code. */
1650 int len = TYPE_LENGTH (type);
1651 if (len < tdep->wordsize)
1652 write_memory (gparam + tdep->wordsize - len, val, len);
1653 else
1654 write_memory (gparam, val, len);
1655 }
1656 if (freg <= 13
1657 && TYPE_CODE (type) == TYPE_CODE_STRUCT
1658 && TYPE_NFIELDS (type) == 1
1659 && TYPE_LENGTH (type) <= 16)
1660 {
1661 /* The ABI (version 1.9) specifies that structs
1662 containing a single floating-point value, at any
1663 level of nesting of single-member structs, are
1664 passed in floating-point registers. */
1665 while (TYPE_CODE (type) == TYPE_CODE_STRUCT
1666 && TYPE_NFIELDS (type) == 1)
1667 type = check_typedef (TYPE_FIELD_TYPE (type, 0));
1668 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1669 {
1670 if (TYPE_LENGTH (type) <= 8)
1671 {
1672 if (write_pass)
1673 {
1674 gdb_byte regval[MAX_REGISTER_SIZE];
1675 struct type *regtype
1676 = register_type (gdbarch,
1677 tdep->ppc_fp0_regnum);
1678 convert_typed_floating (val, type, regval,
1679 regtype);
1680 regcache_cooked_write (regcache,
1681 (tdep->ppc_fp0_regnum
1682 + freg),
1683 regval);
1684 }
1685 freg++;
1686 }
1687 else if (TYPE_LENGTH (type) == 16
1688 && (gdbarch_long_double_format (gdbarch)
1689 == floatformats_ibm_long_double))
1690 {
1691 if (write_pass)
1692 {
1693 regcache_cooked_write (regcache,
1694 (tdep->ppc_fp0_regnum
1695 + freg),
1696 val);
1697 if (freg <= 12)
1698 regcache_cooked_write (regcache,
1699 (tdep->ppc_fp0_regnum
1700 + freg + 1),
1701 val + 8);
1702 }
1703 freg += 2;
1704 }
1705 }
1706 }
1707 /* Always consume parameter stack space. */
1708 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1709 }
1710 }
1711
1712 if (!write_pass)
1713 {
1714 /* Save the true region sizes ready for the second pass. */
1715 refparam_size = refparam;
1716 /* Make certain that the general parameter save area is at
1717 least the minimum 8 registers (or doublewords) in size. */
1718 if (greg < 8)
1719 gparam_size = 8 * tdep->wordsize;
1720 else
1721 gparam_size = gparam;
1722 }
1723 }
1724
1725 /* Update %sp. */
1726 regcache_cooked_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
1727
1728 /* Write the backchain (it occupies WORDSIZED bytes). */
1729 write_memory_signed_integer (sp, tdep->wordsize, byte_order, back_chain);
1730
1731 /* Point the inferior function call's return address at the dummy's
1732 breakpoint. */
1733 regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
1734
1735 /* Use the func_addr to find the descriptor, and use that to find
1736 the TOC. If we're calling via a function pointer, the pointer
1737 itself identifies the descriptor. */
1738 {
1739 struct type *ftype = check_typedef (value_type (function));
1740 CORE_ADDR desc_addr = value_as_address (function);
1741
1742 if (TYPE_CODE (ftype) == TYPE_CODE_PTR
1743 || convert_code_addr_to_desc_addr (func_addr, &desc_addr))
1744 {
1745 /* The TOC is the second double word in the descriptor. */
1746 CORE_ADDR toc =
1747 read_memory_unsigned_integer (desc_addr + tdep->wordsize,
1748 tdep->wordsize, byte_order);
1749 regcache_cooked_write_unsigned (regcache,
1750 tdep->ppc_gp0_regnum + 2, toc);
1751 }
1752 }
1753
1754 return sp;
1755 }
1756
1757
1758 /* The 64 bit ABI return value convention.
1759
1760 Return non-zero if the return-value is stored in a register, return
1761 0 if the return-value is instead stored on the stack (a.k.a.,
1762 struct return convention).
1763
1764 For a return-value stored in a register: when WRITEBUF is non-NULL,
1765 copy the buffer to the corresponding register return-value location
1766 location; when READBUF is non-NULL, fill the buffer from the
1767 corresponding register return-value location. */
1768 enum return_value_convention
1769 ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
1770 struct type *valtype, struct regcache *regcache,
1771 gdb_byte *readbuf, const gdb_byte *writebuf)
1772 {
1773 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1774 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1775 struct type *func_type = function ? value_type (function) : NULL;
1776 int opencl_abi = func_type? ppc_sysv_use_opencl_abi (func_type) : 0;
1777
1778 /* This function exists to support a calling convention that
1779 requires floating-point registers. It shouldn't be used on
1780 processors that lack them. */
1781 gdb_assert (ppc_floating_point_unit_p (gdbarch));
1782
1783 /* Floats and doubles in F1. */
1784 if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
1785 {
1786 gdb_byte regval[MAX_REGISTER_SIZE];
1787 struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
1788 if (writebuf != NULL)
1789 {
1790 convert_typed_floating (writebuf, valtype, regval, regtype);
1791 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
1792 }
1793 if (readbuf != NULL)
1794 {
1795 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
1796 convert_typed_floating (regval, regtype, readbuf, valtype);
1797 }
1798 return RETURN_VALUE_REGISTER_CONVENTION;
1799 }
1800 if (TYPE_CODE (valtype) == TYPE_CODE_DECFLOAT)
1801 return get_decimal_float_return_value (gdbarch, valtype, regcache, readbuf,
1802 writebuf);
1803 /* Integers in r3. */
1804 if ((TYPE_CODE (valtype) == TYPE_CODE_INT
1805 || TYPE_CODE (valtype) == TYPE_CODE_ENUM
1806 || TYPE_CODE (valtype) == TYPE_CODE_CHAR
1807 || TYPE_CODE (valtype) == TYPE_CODE_BOOL)
1808 && TYPE_LENGTH (valtype) <= 8)
1809 {
1810 if (writebuf != NULL)
1811 {
1812 /* Be careful to sign extend the value. */
1813 regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
1814 unpack_long (valtype, writebuf));
1815 }
1816 if (readbuf != NULL)
1817 {
1818 /* Extract the integer from r3. Since this is truncating the
1819 value, there isn't a sign extension problem. */
1820 ULONGEST regval;
1821 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
1822 &regval);
1823 store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
1824 regval);
1825 }
1826 return RETURN_VALUE_REGISTER_CONVENTION;
1827 }
1828 /* All pointers live in r3. */
1829 if (TYPE_CODE (valtype) == TYPE_CODE_PTR
1830 || TYPE_CODE (valtype) == TYPE_CODE_REF)
1831 {
1832 /* All pointers live in r3. */
1833 if (writebuf != NULL)
1834 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
1835 if (readbuf != NULL)
1836 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, readbuf);
1837 return RETURN_VALUE_REGISTER_CONVENTION;
1838 }
1839 /* OpenCL vectors < 16 bytes are returned as distinct
1840 scalars in f1..f2 or r3..r10. */
1841 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
1842 && TYPE_VECTOR (valtype)
1843 && TYPE_LENGTH (valtype) < 16
1844 && opencl_abi)
1845 {
1846 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (valtype));
1847 int i, nelt = TYPE_LENGTH (valtype) / TYPE_LENGTH (eltype);
1848
1849 for (i = 0; i < nelt; i++)
1850 {
1851 int offset = i * TYPE_LENGTH (eltype);
1852
1853 if (TYPE_CODE (eltype) == TYPE_CODE_FLT)
1854 {
1855 int regnum = tdep->ppc_fp0_regnum + 1 + i;
1856 gdb_byte regval[MAX_REGISTER_SIZE];
1857 struct type *regtype = register_type (gdbarch, regnum);
1858
1859 if (writebuf != NULL)
1860 {
1861 convert_typed_floating (writebuf + offset, eltype,
1862 regval, regtype);
1863 regcache_cooked_write (regcache, regnum, regval);
1864 }
1865 if (readbuf != NULL)
1866 {
1867 regcache_cooked_read (regcache, regnum, regval);
1868 convert_typed_floating (regval, regtype,
1869 readbuf + offset, eltype);
1870 }
1871 }
1872 else
1873 {
1874 int regnum = tdep->ppc_gp0_regnum + 3 + i;
1875 ULONGEST regval;
1876
1877 if (writebuf != NULL)
1878 {
1879 regval = unpack_long (eltype, writebuf + offset);
1880 regcache_cooked_write_unsigned (regcache, regnum, regval);
1881 }
1882 if (readbuf != NULL)
1883 {
1884 regcache_cooked_read_unsigned (regcache, regnum, &regval);
1885 store_unsigned_integer (readbuf + offset,
1886 TYPE_LENGTH (eltype), byte_order,
1887 regval);
1888 }
1889 }
1890 }
1891
1892 return RETURN_VALUE_REGISTER_CONVENTION;
1893 }
1894 /* OpenCL vectors >= 16 bytes are returned in v2..v9. */
1895 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
1896 && TYPE_VECTOR (valtype)
1897 && TYPE_LENGTH (valtype) >= 16
1898 && opencl_abi)
1899 {
1900 int n_regs = TYPE_LENGTH (valtype) / 16;
1901 int i;
1902
1903 for (i = 0; i < n_regs; i++)
1904 {
1905 int offset = i * 16;
1906 int regnum = tdep->ppc_vr0_regnum + 2 + i;
1907
1908 if (writebuf != NULL)
1909 regcache_cooked_write (regcache, regnum, writebuf + offset);
1910 if (readbuf != NULL)
1911 regcache_cooked_read (regcache, regnum, readbuf + offset);
1912 }
1913
1914 return RETURN_VALUE_REGISTER_CONVENTION;
1915 }
1916 /* Array type has more than one use. */
1917 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
1918 {
1919 /* Small character arrays are returned, right justified, in r3. */
1920 if (TYPE_LENGTH (valtype) <= 8
1921 && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
1922 && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
1923 {
1924 int offset = (register_size (gdbarch, tdep->ppc_gp0_regnum + 3)
1925 - TYPE_LENGTH (valtype));
1926 if (writebuf != NULL)
1927 regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
1928 offset, TYPE_LENGTH (valtype), writebuf);
1929 if (readbuf != NULL)
1930 regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
1931 offset, TYPE_LENGTH (valtype), readbuf);
1932 return RETURN_VALUE_REGISTER_CONVENTION;
1933 }
1934 /* A VMX vector is returned in v2. */
1935 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
1936 && TYPE_VECTOR (valtype)
1937 && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
1938 {
1939 if (readbuf)
1940 regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
1941 if (writebuf)
1942 regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2,
1943 writebuf);
1944 return RETURN_VALUE_REGISTER_CONVENTION;
1945 }
1946 }
1947 /* Big floating point values get stored in adjacent floating
1948 point registers, starting with F1. */
1949 if (TYPE_CODE (valtype) == TYPE_CODE_FLT
1950 && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32))
1951 {
1952 if (writebuf || readbuf != NULL)
1953 {
1954 int i;
1955 for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
1956 {
1957 if (writebuf != NULL)
1958 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i,
1959 (const bfd_byte *) writebuf + i * 8);
1960 if (readbuf != NULL)
1961 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i,
1962 (bfd_byte *) readbuf + i * 8);
1963 }
1964 }
1965 return RETURN_VALUE_REGISTER_CONVENTION;
1966 }
1967 /* Complex values get returned in f1:f2, need to convert. */
1968 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX
1969 && (TYPE_LENGTH (valtype) == 8 || TYPE_LENGTH (valtype) == 16))
1970 {
1971 if (regcache != NULL)
1972 {
1973 int i;
1974 for (i = 0; i < 2; i++)
1975 {
1976 gdb_byte regval[MAX_REGISTER_SIZE];
1977 struct type *regtype =
1978 register_type (gdbarch, tdep->ppc_fp0_regnum);
1979 struct type *target_type;
1980 target_type = check_typedef (TYPE_TARGET_TYPE (valtype));
1981 if (writebuf != NULL)
1982 {
1983 convert_typed_floating ((const bfd_byte *) writebuf +
1984 i * TYPE_LENGTH (target_type),
1985 target_type, regval, regtype);
1986 regcache_cooked_write (regcache,
1987 tdep->ppc_fp0_regnum + 1 + i,
1988 regval);
1989 }
1990 if (readbuf != NULL)
1991 {
1992 regcache_cooked_read (regcache,
1993 tdep->ppc_fp0_regnum + 1 + i,
1994 regval);
1995 convert_typed_floating (regval, regtype,
1996 (bfd_byte *) readbuf +
1997 i * TYPE_LENGTH (target_type),
1998 target_type);
1999 }
2000 }
2001 }
2002 return RETURN_VALUE_REGISTER_CONVENTION;
2003 }
2004 /* Big complex values get stored in f1:f4. */
2005 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32)
2006 {
2007 if (regcache != NULL)
2008 {
2009 int i;
2010 for (i = 0; i < 4; i++)
2011 {
2012 if (writebuf != NULL)
2013 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i,
2014 (const bfd_byte *) writebuf + i * 8);
2015 if (readbuf != NULL)
2016 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i,
2017 (bfd_byte *) readbuf + i * 8);
2018 }
2019 }
2020 return RETURN_VALUE_REGISTER_CONVENTION;
2021 }
2022 return RETURN_VALUE_STRUCT_CONVENTION;
2023 }
2024
GDB Binutils - Deliverables
This page took 0.071156 seconds and 5 git commands to generate.