gdb/ppc-sysv-tdep.c

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