gdb/ppc-sysv-tdep.c

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