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