projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update years in copyright notice for the GDB files.
[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 /* Pass the arguments in either registers, or in the stack. Using the
1105 ppc 64 bit 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 CORE_ADDR
1112 ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
1113 struct value *function,
1114 struct regcache *regcache, CORE_ADDR bp_addr,
1115 int nargs, struct value **args, CORE_ADDR sp,
1116 int struct_return, CORE_ADDR struct_addr)
1117 {
1118 CORE_ADDR func_addr = find_function_addr (function, NULL);
1119 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1120 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1121 int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function));
1122 ULONGEST back_chain;
1123 /* See for-loop comment below. */
1124 int write_pass;
1125 /* Size of the by-reference parameter copy region, the final value is
1126 computed in the for-loop below. */
1127 LONGEST refparam_size = 0;
1128 /* Size of the general parameter region, the final value is computed
1129 in the for-loop below. */
1130 LONGEST gparam_size = 0;
1131 /* Kevin writes ... I don't mind seeing tdep->wordsize used in the
1132 calls to align_up(), align_down(), etc. because this makes it
1133 easier to reuse this code (in a copy/paste sense) in the future,
1134 but it is a 64-bit ABI and asserting that the wordsize is 8 bytes
1135 at some point makes it easier to verify that this function is
1136 correct without having to do a non-local analysis to figure out
1137 the possible values of tdep->wordsize. */
1138 gdb_assert (tdep->wordsize == 8);
1139
1140 /* This function exists to support a calling convention that
1141 requires floating-point registers. It shouldn't be used on
1142 processors that lack them. */
1143 gdb_assert (ppc_floating_point_unit_p (gdbarch));
1144
1145 /* By this stage in the proceedings, SP has been decremented by "red
1146 zone size" + "struct return size". Fetch the stack-pointer from
1147 before this and use that as the BACK_CHAIN. */
1148 regcache_cooked_read_unsigned (regcache, gdbarch_sp_regnum (gdbarch),
1149 &back_chain);
1150
1151 /* Go through the argument list twice.
1152
1153 Pass 1: Compute the function call's stack space and register
1154 requirements.
1155
1156 Pass 2: Replay the same computation but this time also write the
1157 values out to the target. */
1158
1159 for (write_pass = 0; write_pass < 2; write_pass++)
1160 {
1161 int argno;
1162 /* Next available floating point register for float and double
1163 arguments. */
1164 int freg = 1;
1165 /* Next available general register for non-vector (but possibly
1166 float) arguments. */
1167 int greg = 3;
1168 /* Next available vector register for vector arguments. */
1169 int vreg = 2;
1170 /* The address, at which the next general purpose parameter
1171 (integer, struct, float, vector, ...) should be saved. */
1172 CORE_ADDR gparam;
1173 /* The address, at which the next by-reference parameter
1174 (non-Altivec vector, variably-sized type) should be saved. */
1175 CORE_ADDR refparam;
1176
1177 if (!write_pass)
1178 {
1179 /* During the first pass, GPARAM and REFPARAM are more like
1180 offsets (start address zero) than addresses. That way
1181 they accumulate the total stack space each region
1182 requires. */
1183 gparam = 0;
1184 refparam = 0;
1185 }
1186 else
1187 {
1188 /* Decrement the stack pointer making space for the Altivec
1189 and general on-stack parameters. Set refparam and gparam
1190 to their corresponding regions. */
1191 refparam = align_down (sp - refparam_size, 16);
1192 gparam = align_down (refparam - gparam_size, 16);
1193 /* Add in space for the TOC, link editor double word,
1194 compiler double word, LR save area, CR save area. */
1195 sp = align_down (gparam - 48, 16);
1196 }
1197
1198 /* If the function is returning a `struct', then there is an
1199 extra hidden parameter (which will be passed in r3)
1200 containing the address of that struct.. In that case we
1201 should advance one word and start from r4 register to copy
1202 parameters. This also consumes one on-stack parameter slot. */
1203 if (struct_return)
1204 {
1205 if (write_pass)
1206 regcache_cooked_write_signed (regcache,
1207 tdep->ppc_gp0_regnum + greg,
1208 struct_addr);
1209 greg++;
1210 gparam = align_up (gparam + tdep->wordsize, tdep->wordsize);
1211 }
1212
1213 for (argno = 0; argno < nargs; argno++)
1214 {
1215 struct value *arg = args[argno];
1216 struct type *type = check_typedef (value_type (arg));
1217 const bfd_byte *val = value_contents (arg);
1218
1219 if (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) <= 8)
1220 {
1221 /* Floats and Doubles go in f1 .. f13. They also
1222 consume a left aligned GREG,, and can end up in
1223 memory. */
1224 if (write_pass)
1225 {
1226 gdb_byte regval[MAX_REGISTER_SIZE];
1227 const gdb_byte *p;
1228
1229 /* Version 1.7 of the 64-bit PowerPC ELF ABI says:
1230
1231 "Single precision floating point values are mapped to
1232 the first word in a single doubleword."
1233
1234 And version 1.9 says:
1235
1236 "Single precision floating point values are mapped to
1237 the second word in a single doubleword."
1238
1239 GDB then writes single precision floating point values
1240 at both words in a doubleword, to support both ABIs. */
1241 if (TYPE_LENGTH (type) == 4)
1242 {
1243 memcpy (regval, val, 4);
1244 memcpy (regval + 4, val, 4);
1245 p = regval;
1246 }
1247 else
1248 p = val;
1249
1250 /* Write value in the stack's parameter save area. */
1251 write_memory (gparam, p, 8);
1252
1253 if (freg <= 13)
1254 {
1255 struct type *regtype
1256 = register_type (gdbarch, tdep->ppc_fp0_regnum);
1257
1258 convert_typed_floating (val, type, regval, regtype);
1259 regcache_cooked_write (regcache,
1260 tdep->ppc_fp0_regnum + freg,
1261 regval);
1262 }
1263 if (greg <= 10)
1264 regcache_cooked_write (regcache,
1265 tdep->ppc_gp0_regnum + greg,
1266 regval);
1267 }
1268
1269 freg++;
1270 greg++;
1271 /* Always consume parameter stack space. */
1272 gparam = align_up (gparam + 8, tdep->wordsize);
1273 }
1274 else if (TYPE_CODE (type) == TYPE_CODE_FLT
1275 && TYPE_LENGTH (type) == 16
1276 && (gdbarch_long_double_format (gdbarch)
1277 == floatformats_ibm_long_double))
1278 {
1279 /* IBM long double stored in two doublewords of the
1280 parameter save area and corresponding registers. */
1281 if (write_pass)
1282 {
1283 if (!tdep->soft_float && freg <= 13)
1284 {
1285 regcache_cooked_write (regcache,
1286 tdep->ppc_fp0_regnum + freg,
1287 val);
1288 if (freg <= 12)
1289 regcache_cooked_write (regcache,
1290 tdep->ppc_fp0_regnum + freg + 1,
1291 val + 8);
1292 }
1293 if (greg <= 10)
1294 {
1295 regcache_cooked_write (regcache,
1296 tdep->ppc_gp0_regnum + greg,
1297 val);
1298 if (greg <= 9)
1299 regcache_cooked_write (regcache,
1300 tdep->ppc_gp0_regnum + greg + 1,
1301 val + 8);
1302 }
1303 write_memory (gparam, val, TYPE_LENGTH (type));
1304 }
1305 freg += 2;
1306 greg += 2;
1307 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1308 }
1309 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT
1310 && TYPE_LENGTH (type) <= 8)
1311 {
1312 /* 32-bit and 64-bit decimal floats go in f1 .. f13. They can
1313 end up in memory. */
1314 if (write_pass)
1315 {
1316 gdb_byte regval[MAX_REGISTER_SIZE];
1317 const gdb_byte *p;
1318
1319 /* 32-bit decimal floats are right aligned in the
1320 doubleword. */
1321 if (TYPE_LENGTH (type) == 4)
1322 {
1323 memcpy (regval + 4, val, 4);
1324 p = regval;
1325 }
1326 else
1327 p = val;
1328
1329 /* Write value in the stack's parameter save area. */
1330 write_memory (gparam, p, 8);
1331
1332 if (freg <= 13)
1333 regcache_cooked_write (regcache,
1334 tdep->ppc_fp0_regnum + freg, p);
1335 }
1336
1337 freg++;
1338 greg++;
1339 /* Always consume parameter stack space. */
1340 gparam = align_up (gparam + 8, tdep->wordsize);
1341 }
1342 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT &&
1343 TYPE_LENGTH (type) == 16)
1344 {
1345 /* 128-bit decimal floats go in f2 .. f12, always in even/odd
1346 pairs. They can end up in memory, using two doublewords. */
1347 if (write_pass)
1348 {
1349 if (freg <= 12)
1350 {
1351 /* Make sure freg is even. */
1352 freg += freg & 1;
1353 regcache_cooked_write (regcache,
1354 tdep->ppc_fp0_regnum + freg, val);
1355 regcache_cooked_write (regcache,
1356 tdep->ppc_fp0_regnum + freg + 1, val + 8);
1357 }
1358
1359 write_memory (gparam, val, TYPE_LENGTH (type));
1360 }
1361
1362 freg += 2;
1363 greg += 2;
1364 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1365 }
1366 else if (TYPE_LENGTH (type) < 16
1367 && TYPE_CODE (type) == TYPE_CODE_ARRAY
1368 && TYPE_VECTOR (type)
1369 && opencl_abi)
1370 {
1371 /* OpenCL vectors shorter than 16 bytes are passed as if
1372 a series of independent scalars. */
1373 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1374 int i, nelt = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
1375
1376 for (i = 0; i < nelt; i++)
1377 {
1378 const gdb_byte *elval = val + i * TYPE_LENGTH (eltype);
1379
1380 if (TYPE_CODE (eltype) == TYPE_CODE_FLT)
1381 {
1382 if (write_pass)
1383 {
1384 gdb_byte regval[MAX_REGISTER_SIZE];
1385 const gdb_byte *p;
1386
1387 if (TYPE_LENGTH (eltype) == 4)
1388 {
1389 memcpy (regval, elval, 4);
1390 memcpy (regval + 4, elval, 4);
1391 p = regval;
1392 }
1393 else
1394 p = elval;
1395
1396 write_memory (gparam, p, 8);
1397
1398 if (freg <= 13)
1399 {
1400 int regnum = tdep->ppc_fp0_regnum + freg;
1401 struct type *regtype
1402 = register_type (gdbarch, regnum);
1403
1404 convert_typed_floating (elval, eltype,
1405 regval, regtype);
1406 regcache_cooked_write (regcache, regnum, regval);
1407 }
1408
1409 if (greg <= 10)
1410 regcache_cooked_write (regcache,
1411 tdep->ppc_gp0_regnum + greg,
1412 regval);
1413 }
1414
1415 freg++;
1416 greg++;
1417 gparam = align_up (gparam + 8, tdep->wordsize);
1418 }
1419 else
1420 {
1421 if (write_pass)
1422 {
1423 ULONGEST word = unpack_long (eltype, elval);
1424 if (greg <= 10)
1425 regcache_cooked_write_unsigned
1426 (regcache, tdep->ppc_gp0_regnum + greg, word);
1427
1428 write_memory_unsigned_integer
1429 (gparam, tdep->wordsize, byte_order, word);
1430 }
1431
1432 greg++;
1433 gparam = align_up (gparam + TYPE_LENGTH (eltype),
1434 tdep->wordsize);
1435 }
1436 }
1437 }
1438 else if (TYPE_LENGTH (type) >= 16
1439 && TYPE_CODE (type) == TYPE_CODE_ARRAY
1440 && TYPE_VECTOR (type)
1441 && opencl_abi)
1442 {
1443 /* OpenCL vectors 16 bytes or longer are passed as if
1444 a series of AltiVec vectors. */
1445 int i;
1446
1447 for (i = 0; i < TYPE_LENGTH (type) / 16; i++)
1448 {
1449 const gdb_byte *elval = val + i * 16;
1450
1451 gparam = align_up (gparam, 16);
1452 greg += greg & 1;
1453
1454 if (write_pass)
1455 {
1456 if (vreg <= 13)
1457 regcache_cooked_write (regcache,
1458 tdep->ppc_vr0_regnum + vreg,
1459 elval);
1460
1461 write_memory (gparam, elval, 16);
1462 }
1463
1464 greg += 2;
1465 vreg++;
1466 gparam += 16;
1467 }
1468 }
1469 else if (TYPE_LENGTH (type) == 16 && TYPE_VECTOR (type)
1470 && TYPE_CODE (type) == TYPE_CODE_ARRAY
1471 && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
1472 {
1473 /* In the Altivec ABI, vectors go in the vector registers
1474 v2 .. v13, as well as the parameter area -- always at
1475 16-byte aligned addresses. */
1476
1477 gparam = align_up (gparam, 16);
1478 greg += greg & 1;
1479
1480 if (write_pass)
1481 {
1482 if (vreg <= 13)
1483 regcache_cooked_write (regcache,
1484 tdep->ppc_vr0_regnum + vreg, val);
1485
1486 write_memory (gparam, val, TYPE_LENGTH (type));
1487 }
1488
1489 greg += 2;
1490 vreg++;
1491 gparam += 16;
1492 }
1493 else if (TYPE_LENGTH (type) >= 16 && TYPE_VECTOR (type)
1494 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
1495 {
1496 /* Non-Altivec vectors are passed by reference. */
1497
1498 /* Copy value onto the stack ... */
1499 refparam = align_up (refparam, 16);
1500 if (write_pass)
1501 write_memory (refparam, val, TYPE_LENGTH (type));
1502
1503 /* ... and pass a pointer to the copy as parameter. */
1504 if (write_pass)
1505 {
1506 if (greg <= 10)
1507 regcache_cooked_write_unsigned (regcache,
1508 tdep->ppc_gp0_regnum +
1509 greg, refparam);
1510 write_memory_unsigned_integer (gparam, tdep->wordsize,
1511 byte_order, refparam);
1512 }
1513 greg++;
1514 gparam = align_up (gparam + tdep->wordsize, tdep->wordsize);
1515 refparam = align_up (refparam + TYPE_LENGTH (type), tdep->wordsize);
1516 }
1517 else if ((TYPE_CODE (type) == TYPE_CODE_INT
1518 || TYPE_CODE (type) == TYPE_CODE_ENUM
1519 || TYPE_CODE (type) == TYPE_CODE_BOOL
1520 || TYPE_CODE (type) == TYPE_CODE_CHAR
1521 || TYPE_CODE (type) == TYPE_CODE_PTR
1522 || TYPE_CODE (type) == TYPE_CODE_REF)
1523 && TYPE_LENGTH (type) <= 8)
1524 {
1525 /* Scalars and Pointers get sign[un]extended and go in
1526 gpr3 .. gpr10. They can also end up in memory. */
1527 if (write_pass)
1528 {
1529 /* Sign extend the value, then store it unsigned. */
1530 ULONGEST word = unpack_long (type, val);
1531 /* Convert any function code addresses into
1532 descriptors. */
1533 if (TYPE_CODE (type) == TYPE_CODE_PTR
1534 || TYPE_CODE (type) == TYPE_CODE_REF)
1535 {
1536 struct type *target_type;
1537 target_type = check_typedef (TYPE_TARGET_TYPE (type));
1538
1539 if (TYPE_CODE (target_type) == TYPE_CODE_FUNC
1540 || TYPE_CODE (target_type) == TYPE_CODE_METHOD)
1541 {
1542 CORE_ADDR desc = word;
1543 convert_code_addr_to_desc_addr (word, &desc);
1544 word = desc;
1545 }
1546 }
1547 if (greg <= 10)
1548 regcache_cooked_write_unsigned (regcache,
1549 tdep->ppc_gp0_regnum +
1550 greg, word);
1551 write_memory_unsigned_integer (gparam, tdep->wordsize,
1552 byte_order, word);
1553 }
1554 greg++;
1555 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1556 }
1557 else
1558 {
1559 int byte;
1560 for (byte = 0; byte < TYPE_LENGTH (type);
1561 byte += tdep->wordsize)
1562 {
1563 if (write_pass && greg <= 10)
1564 {
1565 gdb_byte regval[MAX_REGISTER_SIZE];
1566 int len = TYPE_LENGTH (type) - byte;
1567 if (len > tdep->wordsize)
1568 len = tdep->wordsize;
1569 memset (regval, 0, sizeof regval);
1570 /* The ABI (version 1.9) specifies that values
1571 smaller than one doubleword are right-aligned
1572 and those larger are left-aligned. GCC
1573 versions before 3.4 implemented this
1574 incorrectly; see
1575 <http://gcc.gnu.org/gcc-3.4/powerpc-abi.html>. */
1576 if (byte == 0)
1577 memcpy (regval + tdep->wordsize - len,
1578 val + byte, len);
1579 else
1580 memcpy (regval, val + byte, len);
1581 regcache_cooked_write (regcache, greg, regval);
1582 }
1583 greg++;
1584 }
1585 if (write_pass)
1586 {
1587 /* WARNING: cagney/2003-09-21: Strictly speaking, this
1588 isn't necessary, unfortunately, GCC appears to get
1589 "struct convention" parameter passing wrong putting
1590 odd sized structures in memory instead of in a
1591 register. Work around this by always writing the
1592 value to memory. Fortunately, doing this
1593 simplifies the code. */
1594 int len = TYPE_LENGTH (type);
1595 if (len < tdep->wordsize)
1596 write_memory (gparam + tdep->wordsize - len, val, len);
1597 else
1598 write_memory (gparam, val, len);
1599 }
1600 if (freg <= 13
1601 && TYPE_CODE (type) == TYPE_CODE_STRUCT
1602 && TYPE_NFIELDS (type) == 1
1603 && TYPE_LENGTH (type) <= 16)
1604 {
1605 /* The ABI (version 1.9) specifies that structs
1606 containing a single floating-point value, at any
1607 level of nesting of single-member structs, are
1608 passed in floating-point registers. */
1609 while (TYPE_CODE (type) == TYPE_CODE_STRUCT
1610 && TYPE_NFIELDS (type) == 1)
1611 type = check_typedef (TYPE_FIELD_TYPE (type, 0));
1612 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1613 {
1614 if (TYPE_LENGTH (type) <= 8)
1615 {
1616 if (write_pass)
1617 {
1618 gdb_byte regval[MAX_REGISTER_SIZE];
1619 struct type *regtype
1620 = register_type (gdbarch,
1621 tdep->ppc_fp0_regnum);
1622 convert_typed_floating (val, type, regval,
1623 regtype);
1624 regcache_cooked_write (regcache,
1625 (tdep->ppc_fp0_regnum
1626 + freg),
1627 regval);
1628 }
1629 freg++;
1630 }
1631 else if (TYPE_LENGTH (type) == 16
1632 && (gdbarch_long_double_format (gdbarch)
1633 == floatformats_ibm_long_double))
1634 {
1635 if (write_pass)
1636 {
1637 regcache_cooked_write (regcache,
1638 (tdep->ppc_fp0_regnum
1639 + freg),
1640 val);
1641 if (freg <= 12)
1642 regcache_cooked_write (regcache,
1643 (tdep->ppc_fp0_regnum
1644 + freg + 1),
1645 val + 8);
1646 }
1647 freg += 2;
1648 }
1649 }
1650 }
1651 /* Always consume parameter stack space. */
1652 gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
1653 }
1654 }
1655
1656 if (!write_pass)
1657 {
1658 /* Save the true region sizes ready for the second pass. */
1659 refparam_size = refparam;
1660 /* Make certain that the general parameter save area is at
1661 least the minimum 8 registers (or doublewords) in size. */
1662 if (greg < 8)
1663 gparam_size = 8 * tdep->wordsize;
1664 else
1665 gparam_size = gparam;
1666 }
1667 }
1668
1669 /* Update %sp. */
1670 regcache_cooked_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
1671
1672 /* Write the backchain (it occupies WORDSIZED bytes). */
1673 write_memory_signed_integer (sp, tdep->wordsize, byte_order, back_chain);
1674
1675 /* Point the inferior function call's return address at the dummy's
1676 breakpoint. */
1677 regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
1678
1679 /* Use the func_addr to find the descriptor, and use that to find
1680 the TOC. If we're calling via a function pointer, the pointer
1681 itself identifies the descriptor. */
1682 {
1683 struct type *ftype = check_typedef (value_type (function));
1684 CORE_ADDR desc_addr = value_as_address (function);
1685
1686 if (TYPE_CODE (ftype) == TYPE_CODE_PTR
1687 || convert_code_addr_to_desc_addr (func_addr, &desc_addr))
1688 {
1689 /* The TOC is the second double word in the descriptor. */
1690 CORE_ADDR toc =
1691 read_memory_unsigned_integer (desc_addr + tdep->wordsize,
1692 tdep->wordsize, byte_order);
1693 regcache_cooked_write_unsigned (regcache,
1694 tdep->ppc_gp0_regnum + 2, toc);
1695 }
1696 }
1697
1698 return sp;
1699 }
1700
1701
1702 /* The 64 bit ABI return value convention.
1703
1704 Return non-zero if the return-value is stored in a register, return
1705 0 if the return-value is instead stored on the stack (a.k.a.,
1706 struct return convention).
1707
1708 For a return-value stored in a register: when WRITEBUF is non-NULL,
1709 copy the buffer to the corresponding register return-value location
1710 location; when READBUF is non-NULL, fill the buffer from the
1711 corresponding register return-value location. */
1712 enum return_value_convention
1713 ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
1714 struct type *valtype, struct regcache *regcache,
1715 gdb_byte *readbuf, const gdb_byte *writebuf)
1716 {
1717 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1718 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1719 struct type *func_type = function ? value_type (function) : NULL;
1720 int opencl_abi = func_type? ppc_sysv_use_opencl_abi (func_type) : 0;
1721
1722 /* This function exists to support a calling convention that
1723 requires floating-point registers. It shouldn't be used on
1724 processors that lack them. */
1725 gdb_assert (ppc_floating_point_unit_p (gdbarch));
1726
1727 /* Floats and doubles in F1. */
1728 if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
1729 {
1730 gdb_byte regval[MAX_REGISTER_SIZE];
1731 struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
1732 if (writebuf != NULL)
1733 {
1734 convert_typed_floating (writebuf, valtype, regval, regtype);
1735 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
1736 }
1737 if (readbuf != NULL)
1738 {
1739 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
1740 convert_typed_floating (regval, regtype, readbuf, valtype);
1741 }
1742 return RETURN_VALUE_REGISTER_CONVENTION;
1743 }
1744 if (TYPE_CODE (valtype) == TYPE_CODE_DECFLOAT)
1745 return get_decimal_float_return_value (gdbarch, valtype, regcache, readbuf,
1746 writebuf);
1747 /* Integers in r3. */
1748 if ((TYPE_CODE (valtype) == TYPE_CODE_INT
1749 || TYPE_CODE (valtype) == TYPE_CODE_ENUM
1750 || TYPE_CODE (valtype) == TYPE_CODE_CHAR
1751 || TYPE_CODE (valtype) == TYPE_CODE_BOOL)
1752 && TYPE_LENGTH (valtype) <= 8)
1753 {
1754 if (writebuf != NULL)
1755 {
1756 /* Be careful to sign extend the value. */
1757 regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
1758 unpack_long (valtype, writebuf));
1759 }
1760 if (readbuf != NULL)
1761 {
1762 /* Extract the integer from r3. Since this is truncating the
1763 value, there isn't a sign extension problem. */
1764 ULONGEST regval;
1765 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
1766 &regval);
1767 store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
1768 regval);
1769 }
1770 return RETURN_VALUE_REGISTER_CONVENTION;
1771 }
1772 /* All pointers live in r3. */
1773 if (TYPE_CODE (valtype) == TYPE_CODE_PTR
1774 || TYPE_CODE (valtype) == TYPE_CODE_REF)
1775 {
1776 /* All pointers live in r3. */
1777 if (writebuf != NULL)
1778 regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
1779 if (readbuf != NULL)
1780 regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, readbuf);
1781 return RETURN_VALUE_REGISTER_CONVENTION;
1782 }
1783 /* OpenCL vectors < 16 bytes are returned as distinct
1784 scalars in f1..f2 or r3..r10. */
1785 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
1786 && TYPE_VECTOR (valtype)
1787 && TYPE_LENGTH (valtype) < 16
1788 && opencl_abi)
1789 {
1790 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (valtype));
1791 int i, nelt = TYPE_LENGTH (valtype) / TYPE_LENGTH (eltype);
1792
1793 for (i = 0; i < nelt; i++)
1794 {
1795 int offset = i * TYPE_LENGTH (eltype);
1796
1797 if (TYPE_CODE (eltype) == TYPE_CODE_FLT)
1798 {
1799 int regnum = tdep->ppc_fp0_regnum + 1 + i;
1800 gdb_byte regval[MAX_REGISTER_SIZE];
1801 struct type *regtype = register_type (gdbarch, regnum);
1802
1803 if (writebuf != NULL)
1804 {
1805 convert_typed_floating (writebuf + offset, eltype,
1806 regval, regtype);
1807 regcache_cooked_write (regcache, regnum, regval);
1808 }
1809 if (readbuf != NULL)
1810 {
1811 regcache_cooked_read (regcache, regnum, regval);
1812 convert_typed_floating (regval, regtype,
1813 readbuf + offset, eltype);
1814 }
1815 }
1816 else
1817 {
1818 int regnum = tdep->ppc_gp0_regnum + 3 + i;
1819 ULONGEST regval;
1820
1821 if (writebuf != NULL)
1822 {
1823 regval = unpack_long (eltype, writebuf + offset);
1824 regcache_cooked_write_unsigned (regcache, regnum, regval);
1825 }
1826 if (readbuf != NULL)
1827 {
1828 regcache_cooked_read_unsigned (regcache, regnum, &regval);
1829 store_unsigned_integer (readbuf + offset,
1830 TYPE_LENGTH (eltype), byte_order,
1831 regval);
1832 }
1833 }
1834 }
1835
1836 return RETURN_VALUE_REGISTER_CONVENTION;
1837 }
1838 /* OpenCL vectors >= 16 bytes are returned in v2..v9. */
1839 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
1840 && TYPE_VECTOR (valtype)
1841 && TYPE_LENGTH (valtype) >= 16
1842 && opencl_abi)
1843 {
1844 int n_regs = TYPE_LENGTH (valtype) / 16;
1845 int i;
1846
1847 for (i = 0; i < n_regs; i++)
1848 {
1849 int offset = i * 16;
1850 int regnum = tdep->ppc_vr0_regnum + 2 + i;
1851
1852 if (writebuf != NULL)
1853 regcache_cooked_write (regcache, regnum, writebuf + offset);
1854 if (readbuf != NULL)
1855 regcache_cooked_read (regcache, regnum, readbuf + offset);
1856 }
1857
1858 return RETURN_VALUE_REGISTER_CONVENTION;
1859 }
1860 /* Array type has more than one use. */
1861 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
1862 {
1863 /* Small character arrays are returned, right justified, in r3. */
1864 if (TYPE_LENGTH (valtype) <= 8
1865 && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
1866 && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
1867 {
1868 int offset = (register_size (gdbarch, tdep->ppc_gp0_regnum + 3)
1869 - TYPE_LENGTH (valtype));
1870 if (writebuf != NULL)
1871 regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
1872 offset, TYPE_LENGTH (valtype), writebuf);
1873 if (readbuf != NULL)
1874 regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
1875 offset, TYPE_LENGTH (valtype), readbuf);
1876 return RETURN_VALUE_REGISTER_CONVENTION;
1877 }
1878 /* A VMX vector is returned in v2. */
1879 if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
1880 && TYPE_VECTOR (valtype)
1881 && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
1882 {
1883 if (readbuf)
1884 regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
1885 if (writebuf)
1886 regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2,
1887 writebuf);
1888 return RETURN_VALUE_REGISTER_CONVENTION;
1889 }
1890 }
1891 /* Big floating point values get stored in adjacent floating
1892 point registers, starting with F1. */
1893 if (TYPE_CODE (valtype) == TYPE_CODE_FLT
1894 && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32))
1895 {
1896 if (writebuf || readbuf != NULL)
1897 {
1898 int i;
1899 for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
1900 {
1901 if (writebuf != NULL)
1902 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i,
1903 (const bfd_byte *) writebuf + i * 8);
1904 if (readbuf != NULL)
1905 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i,
1906 (bfd_byte *) readbuf + i * 8);
1907 }
1908 }
1909 return RETURN_VALUE_REGISTER_CONVENTION;
1910 }
1911 /* Complex values get returned in f1:f2, need to convert. */
1912 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX
1913 && (TYPE_LENGTH (valtype) == 8 || TYPE_LENGTH (valtype) == 16))
1914 {
1915 if (regcache != NULL)
1916 {
1917 int i;
1918 for (i = 0; i < 2; i++)
1919 {
1920 gdb_byte regval[MAX_REGISTER_SIZE];
1921 struct type *regtype =
1922 register_type (gdbarch, tdep->ppc_fp0_regnum);
1923 if (writebuf != NULL)
1924 {
1925 convert_typed_floating ((const bfd_byte *) writebuf +
1926 i * (TYPE_LENGTH (valtype) / 2),
1927 valtype, regval, regtype);
1928 regcache_cooked_write (regcache,
1929 tdep->ppc_fp0_regnum + 1 + i,
1930 regval);
1931 }
1932 if (readbuf != NULL)
1933 {
1934 regcache_cooked_read (regcache,
1935 tdep->ppc_fp0_regnum + 1 + i,
1936 regval);
1937 convert_typed_floating (regval, regtype,
1938 (bfd_byte *) readbuf +
1939 i * (TYPE_LENGTH (valtype) / 2),
1940 valtype);
1941 }
1942 }
1943 }
1944 return RETURN_VALUE_REGISTER_CONVENTION;
1945 }
1946 /* Big complex values get stored in f1:f4. */
1947 if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32)
1948 {
1949 if (regcache != NULL)
1950 {
1951 int i;
1952 for (i = 0; i < 4; i++)
1953 {
1954 if (writebuf != NULL)
1955 regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i,
1956 (const bfd_byte *) writebuf + i * 8);
1957 if (readbuf != NULL)
1958 regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i,
1959 (bfd_byte *) readbuf + i * 8);
1960 }
1961 }
1962 return RETURN_VALUE_REGISTER_CONVENTION;
1963 }
1964 return RETURN_VALUE_STRUCT_CONVENTION;
1965 }
1966
GDB Binutils - Deliverables
This page took 0.182862 seconds and 5 git commands to generate.