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