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