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 2000, 2001, 2002 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 2 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, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "gdbcore.h"
  25 #include "inferior.h"
  26 #include "regcache.h"
  27 #include "value.h"
  28 #include "gdb_string.h"
  29 #include "gdb_assert.h"
  30 #include "ppc-tdep.h"
  31
  32 /* Pass the arguments in either registers, or in the stack. Using the
  33    ppc sysv ABI, the first eight words of the argument list (that might
  34    be less than eight parameters if some parameters occupy more than one
  35    word) are passed in r3..r10 registers.  float and double parameters are
  36    passed in fpr's, in addition to that. Rest of the parameters if any
  37    are passed in user stack.
  38
  39    If the function is returning a structure, then the return address is passed
  40    in r3, then the first 7 words of the parametes can be passed in registers,
  41    starting from r4. */
  42
  43 CORE_ADDR
  44 ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
  45                               struct regcache *regcache, CORE_ADDR bp_addr,
  46                               int nargs, struct value **args, CORE_ADDR sp,
  47                               int struct_return, CORE_ADDR struct_addr)
  48 {
  49   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
  50   const CORE_ADDR saved_sp = read_sp ();
  51   int argspace = 0;             /* 0 is an initial wrong guess.  */
  52   int write_pass;
  53
  54   /* Go through the argument list twice.
  55
  56      Pass 1: Figure out how much new stack space is required for
  57      arguments and pushed values.  Unlike the PowerOpen ABI, the SysV
  58      ABI doesn't reserve any extra space for parameters which are put
  59      in registers, but does always push structures and then pass their
  60      address.
  61
  62      Pass 2: Replay the same computation but this time also write the
  63      values out to the target.  */
  64
  65   for (write_pass = 0; write_pass < 2; write_pass++)
  66     {
  67       int argno;
  68       /* Next available floating point register for float and double
  69          arguments.  */
  70       int freg = 1;
  71       /* Next available general register for non-float, non-vector
  72          arguments.  */
  73       int greg = 3;
  74       /* Next available vector register for vector arguments.  */
  75       int vreg = 2;
  76       /* Arguments start above the "LR save word" and "Back chain".  */
  77       int argoffset = 2 * tdep->wordsize;
  78       /* Structures start after the arguments.  */
  79       int structoffset = argoffset + argspace;
  80
  81       /* If the function is returning a `struct', then the first word
  82          (which will be passed in r3) is used for struct return
  83          address.  In that case we should advance one word and start
  84          from r4 register to copy parameters.  */
  85       if (struct_return)
  86         {
  87           if (write_pass)
  88             regcache_cooked_write_signed (regcache,
  89                                           tdep->ppc_gp0_regnum + greg,
  90                                           struct_addr);
  91           greg++;
  92         }
  93
  94       for (argno = 0; argno < nargs; argno++)
  95         {
  96           struct value *arg = args[argno];
  97           struct type *type = check_typedef (VALUE_TYPE (arg));
  98           int len = TYPE_LENGTH (type);
  99           char *val = VALUE_CONTENTS (arg);
 100
 101           if (TYPE_CODE (type) == TYPE_CODE_FLT
 102               && ppc_floating_point_unit_p (current_gdbarch) && len <= 8)
 103             {
 104               /* Floating point value converted to "double" then
 105                  passed in an FP register, when the registers run out,
 106                  8 byte aligned stack is used.  */
 107               if (freg <= 8)
 108                 {
 109                   if (write_pass)
 110                     {
 111                       /* Always store the floating point value using
 112                          the register's floating-point format.  */
 113                       char regval[MAX_REGISTER_SIZE];
 114                       struct type *regtype
 115                         = register_type (gdbarch, FP0_REGNUM + freg);
 116                       convert_typed_floating (val, type, regval, regtype);
 117                       regcache_cooked_write (regcache, FP0_REGNUM + freg,
 118                                              regval);
 119                     }
 120                   freg++;
 121                 }
 122               else
 123                 {
 124                   /* SysV ABI converts floats to doubles before
 125                      writing them to an 8 byte aligned stack location.  */
 126                   argoffset = align_up (argoffset, 8);
 127                   if (write_pass)
 128                     {
 129                       char memval[8];
 130                       struct type *memtype;
 131                       switch (TARGET_BYTE_ORDER)
 132                         {
 133                         case BFD_ENDIAN_BIG:
 134                           memtype = builtin_type_ieee_double_big;
 135                           break;
 136                         case BFD_ENDIAN_LITTLE:
 137                           memtype = builtin_type_ieee_double_little;
 138                           break;
 139                         default:
 140                           internal_error (__FILE__, __LINE__, "bad switch");
 141                         }
 142                       convert_typed_floating (val, type, memval, memtype);
 143                       write_memory (sp + argoffset, val, len);
 144                     }
 145                   argoffset += 8;
 146                 }
 147             }
 148           else if (len == 8 && (TYPE_CODE (type) == TYPE_CODE_INT       /* long long */
 149                                 || (!ppc_floating_point_unit_p (current_gdbarch) && TYPE_CODE (type) == TYPE_CODE_FLT)))        /* double */
 150             {
 151               /* "long long" or "double" passed in an odd/even
 152                  register pair with the low addressed word in the odd
 153                  register and the high addressed word in the even
 154                  register, or when the registers run out an 8 byte
 155                  aligned stack location.  */
 156               if (greg > 9)
 157                 {
 158                   /* Just in case GREG was 10.  */
 159                   greg = 11;
 160                   argoffset = align_up (argoffset, 8);
 161                   if (write_pass)
 162                     write_memory (sp + argoffset, val, len);
 163                   argoffset += 8;
 164                 }
 165               else if (tdep->wordsize == 8)
 166                 {
 167                   if (write_pass)
 168                     regcache_cooked_write (regcache,
 169                                            tdep->ppc_gp0_regnum + greg, val);
 170                   greg += 1;
 171                 }
 172               else
 173                 {
 174                   /* Must start on an odd register - r3/r4 etc.  */
 175                   if ((greg & 1) == 0)
 176                     greg++;
 177                   if (write_pass)
 178                     {
 179                       regcache_cooked_write (regcache,
 180                                              tdep->ppc_gp0_regnum + greg + 0,
 181                                              val + 0);
 182                       regcache_cooked_write (regcache,
 183                                              tdep->ppc_gp0_regnum + greg + 1,
 184                                              val + 4);
 185                     }
 186                   greg += 2;
 187                 }
 188             }
 189           else if (len == 16
 190                    && TYPE_CODE (type) == TYPE_CODE_ARRAY
 191                    && TYPE_VECTOR (type) && tdep->ppc_vr0_regnum >= 0)
 192             {
 193               /* Vector parameter passed in an Altivec register, or
 194                  when that runs out, 16 byte aligned stack location.  */
 195               if (vreg <= 13)
 196                 {
 197                   if (write_pass)
 198                     regcache_cooked_write (current_regcache,
 199                                            tdep->ppc_vr0_regnum + vreg, val);
 200                   vreg++;
 201                 }
 202               else
 203                 {
 204                   argoffset = align_up (argoffset, 16);
 205                   if (write_pass)
 206                     write_memory (sp + argoffset, val, 16);
 207                   argoffset += 16;
 208                 }
 209             }
 210           else if (len == 8
 211                    && TYPE_CODE (type) == TYPE_CODE_ARRAY
 212                    && TYPE_VECTOR (type) && tdep->ppc_ev0_regnum >= 0)
 213             {
 214               /* Vector parameter passed in an e500 register, or when
 215                  that runs out, 8 byte aligned stack location.  Note
 216                  that since e500 vector and general purpose registers
 217                  both map onto the same underlying register set, a
 218                  "greg" and not a "vreg" is consumed here.  A cooked
 219                  write stores the value in the correct locations
 220                  within the raw register cache.  */
 221               if (greg <= 10)
 222                 {
 223                   if (write_pass)
 224                     regcache_cooked_write (current_regcache,
 225                                            tdep->ppc_ev0_regnum + greg, val);
 226                   greg++;
 227                 }
 228               else
 229                 {
 230                   argoffset = align_up (argoffset, 8);
 231                   if (write_pass)
 232                     write_memory (sp + argoffset, val, 8);
 233                   argoffset += 8;
 234                 }
 235             }
 236           else
 237             {
 238               /* Reduce the parameter down to something that fits in a
 239                  "word".  */
 240               char word[MAX_REGISTER_SIZE];
 241               memset (word, 0, MAX_REGISTER_SIZE);
 242               if (len > tdep->wordsize
 243                   || TYPE_CODE (type) == TYPE_CODE_STRUCT
 244                   || TYPE_CODE (type) == TYPE_CODE_UNION)
 245                 {
 246                   /* Structs and large values are put on an 8 byte
 247                      aligned stack ... */
 248                   structoffset = align_up (structoffset, 8);
 249                   if (write_pass)
 250                     write_memory (sp + structoffset, val, len);
 251                   /* ... and then a "word" pointing to that address is
 252                      passed as the parameter.  */
 253                   store_unsigned_integer (word, tdep->wordsize,
 254                                           sp + structoffset);
 255                   structoffset += len;
 256                 }
 257               else if (TYPE_CODE (type) == TYPE_CODE_INT)
 258                 /* Sign or zero extend the "int" into a "word".  */
 259                 store_unsigned_integer (word, tdep->wordsize,
 260                                         unpack_long (type, val));
 261               else
 262                 /* Always goes in the low address.  */
 263                 memcpy (word, val, len);
 264               /* Store that "word" in a register, or on the stack.
 265                  The words have "4" byte alignment.  */
 266               if (greg <= 10)
 267                 {
 268                   if (write_pass)
 269                     regcache_cooked_write (regcache,
 270                                            tdep->ppc_gp0_regnum + greg, word);
 271                   greg++;
 272                 }
 273               else
 274                 {
 275                   argoffset = align_up (argoffset, tdep->wordsize);
 276                   if (write_pass)
 277                     write_memory (sp + argoffset, word, tdep->wordsize);
 278                   argoffset += tdep->wordsize;
 279                 }
 280             }
 281         }
 282
 283       /* Compute the actual stack space requirements.  */
 284       if (!write_pass)
 285         {
 286           /* Remember the amount of space needed by the arguments.  */
 287           argspace = argoffset;
 288           /* Allocate space for both the arguments and the structures.  */
 289           sp -= (argoffset + structoffset);
 290           /* Ensure that the stack is still 16 byte aligned.  */
 291           sp = align_down (sp, 16);
 292         }
 293     }
 294
 295   /* Update %sp.   */
 296   regcache_cooked_write_signed (regcache, SP_REGNUM, sp);
 297
 298   /* Write the backchain (it occupies WORDSIZED bytes).  */
 299   write_memory_signed_integer (sp, tdep->wordsize, saved_sp);
 300
 301   /* Point the inferior function call's return address at the dummy's
 302      breakpoint.  */
 303   regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
 304
 305   return sp;
 306 }
 307
 308 /* Handle the return-value conventions specified by the SysV 32-bit
 309    PowerPC ABI (including all the supplements):
 310
 311    no floating-point: floating-point values returned using 32-bit
 312    general-purpose registers.
 313
 314    Altivec: 128-bit vectors returned using vector registers.
 315
 316    e500: 64-bit vectors returned using the full full 64 bit EV
 317    register, floating-point values returned using 32-bit
 318    general-purpose registers.
 319
 320    GCC (broken): Small struct values right (instead of left) aligned
 321    when returned in general-purpose registers.  */
 322
 323 static enum return_value_convention
 324 do_ppc_sysv_return_value (struct type *type, struct regcache *regcache,
 325                           const void *inval, void *outval, int broken_gcc)
 326 {
 327   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 328   gdb_assert (tdep->wordsize == 4);
 329   if (TYPE_CODE (type) == TYPE_CODE_FLT
 330       && TYPE_LENGTH (type) <= 8
 331       && ppc_floating_point_unit_p (current_gdbarch))
 332     {
 333       if (outval)
 334         {
 335           /* Floats and doubles stored in "f1".  Convert the value to
 336              the required type.  */
 337           char regval[MAX_REGISTER_SIZE];
 338           struct type *regtype = register_type (current_gdbarch,
 339                                                 FP0_REGNUM + 1);
 340           regcache_cooked_read (regcache, FP0_REGNUM + 1, regval);
 341           convert_typed_floating (regval, regtype, outval, type);
 342         }
 343       if (inval)
 344         {
 345           /* Floats and doubles stored in "f1".  Convert the value to
 346              the register's "double" type.  */
 347           char regval[MAX_REGISTER_SIZE];
 348           struct type *regtype = register_type (current_gdbarch, FP0_REGNUM);
 349           convert_typed_floating (inval, type, regval, regtype);
 350           regcache_cooked_write (regcache, FP0_REGNUM + 1, regval);
 351         }
 352       return RETURN_VALUE_REGISTER_CONVENTION;
 353     }
 354   if ((TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) == 8)
 355       || (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8))
 356     {
 357       if (outval)
 358         {
 359           /* A long long, or a double stored in the 32 bit r3/r4.  */
 360           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
 361                                 (bfd_byte *) outval + 0);
 362           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
 363                                 (bfd_byte *) outval + 4);
 364         }
 365       if (inval)
 366         {
 367           /* A long long, or a double stored in the 32 bit r3/r4.  */
 368           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
 369                                  (bfd_byte *) inval + 0);
 370           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
 371                                  (bfd_byte *) inval + 4);
 372         }
 373       return RETURN_VALUE_REGISTER_CONVENTION;
 374     }
 375   if (TYPE_CODE (type) == TYPE_CODE_INT
 376       && TYPE_LENGTH (type) <= tdep->wordsize)
 377     {
 378       if (outval)
 379         {
 380           /* Some sort of integer stored in r3.  Since TYPE isn't
 381              bigger than the register, sign extension isn't a problem
 382              - just do everything unsigned.  */
 383           ULONGEST regval;
 384           regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 385                                          &regval);
 386           store_unsigned_integer (outval, TYPE_LENGTH (type), regval);
 387         }
 388       if (inval)
 389         {
 390           /* Some sort of integer stored in r3.  Use unpack_long since
 391              that should handle any required sign extension.  */
 392           regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 393                                           unpack_long (type, inval));
 394         }
 395       return RETURN_VALUE_REGISTER_CONVENTION;
 396     }
 397   if (TYPE_LENGTH (type) == 16
 398       && TYPE_CODE (type) == TYPE_CODE_ARRAY
 399       && TYPE_VECTOR (type) && tdep->ppc_vr0_regnum >= 0)
 400     {
 401       if (outval)
 402         {
 403           /* Altivec places the return value in "v2".  */
 404           regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, outval);
 405         }
 406       if (inval)
 407         {
 408           /* Altivec places the return value in "v2".  */
 409           regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, inval);
 410         }
 411       return RETURN_VALUE_REGISTER_CONVENTION;
 412     }
 413   if (TYPE_LENGTH (type) == 8
 414       && TYPE_CODE (type) == TYPE_CODE_ARRAY
 415       && TYPE_VECTOR (type) && tdep->ppc_ev0_regnum >= 0)
 416     {
 417       /* The e500 ABI places return values for the 64-bit DSP types
 418          (__ev64_opaque__) in r3.  However, in GDB-speak, ev3
 419          corresponds to the entire r3 value for e500, whereas GDB's r3
 420          only corresponds to the least significant 32-bits.  So place
 421          the 64-bit DSP type's value in ev3.  */
 422       if (outval)
 423         regcache_cooked_read (regcache, tdep->ppc_ev0_regnum + 3, outval);
 424       if (inval)
 425         regcache_cooked_write (regcache, tdep->ppc_ev0_regnum + 3, inval);
 426       return RETURN_VALUE_REGISTER_CONVENTION;
 427     }
 428   if (broken_gcc && TYPE_LENGTH (type) <= 8)
 429     {
 430       if (outval)
 431         {
 432           /* GCC screwed up.  The last register isn't "left" aligned.
 433              Need to extract the least significant part of each
 434              register and then store that.  */
 435           /* Transfer any full words.  */
 436           int word = 0;
 437           while (1)
 438             {
 439               ULONGEST reg;
 440               int len = TYPE_LENGTH (type) - word * tdep->wordsize;
 441               if (len <= 0)
 442                 break;
 443               if (len > tdep->wordsize)
 444                 len = tdep->wordsize;
 445               regcache_cooked_read_unsigned (regcache,
 446                                              tdep->ppc_gp0_regnum + 3 + word,
 447                                              &reg);
 448               store_unsigned_integer (((bfd_byte *) outval
 449                                        + word * tdep->wordsize), len, reg);
 450               word++;
 451             }
 452         }
 453       if (inval)
 454         {
 455           /* GCC screwed up.  The last register isn't "left" aligned.
 456              Need to extract the least significant part of each
 457              register and then store that.  */
 458           /* Transfer any full words.  */
 459           int word = 0;
 460           while (1)
 461             {
 462               ULONGEST reg;
 463               int len = TYPE_LENGTH (type) - word * tdep->wordsize;
 464               if (len <= 0)
 465                 break;
 466               if (len > tdep->wordsize)
 467                 len = tdep->wordsize;
 468               reg = extract_unsigned_integer (((bfd_byte *) inval
 469                                                + word * tdep->wordsize), len);
 470               regcache_cooked_write_unsigned (regcache,
 471                                               tdep->ppc_gp0_regnum + 3 + word,
 472                                               reg);
 473               word++;
 474             }
 475         }
 476       return RETURN_VALUE_REGISTER_CONVENTION;
 477     }
 478   if (TYPE_LENGTH (type) <= 8)
 479     {
 480       if (outval)
 481         {
 482           /* This matches SVr4 PPC, it does not match GCC.  */
 483           /* The value is right-padded to 8 bytes and then loaded, as
 484              two "words", into r3/r4.  */
 485           char regvals[MAX_REGISTER_SIZE * 2];
 486           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
 487                                 regvals + 0 * tdep->wordsize);
 488           if (TYPE_LENGTH (type) > tdep->wordsize)
 489             regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
 490                                   regvals + 1 * tdep->wordsize);
 491           memcpy (outval, regvals, TYPE_LENGTH (type));
 492         }
 493       if (inval)
 494         {
 495           /* This matches SVr4 PPC, it does not match GCC.  */
 496           /* The value is padded out to 8 bytes and then loaded, as
 497              two "words" into r3/r4.  */
 498           char regvals[MAX_REGISTER_SIZE * 2];
 499           memset (regvals, 0, sizeof regvals);
 500           memcpy (regvals, inval, TYPE_LENGTH (type));
 501           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
 502                                  regvals + 0 * tdep->wordsize);
 503           if (TYPE_LENGTH (type) > tdep->wordsize)
 504             regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
 505                                    regvals + 1 * tdep->wordsize);
 506         }
 507       return RETURN_VALUE_REGISTER_CONVENTION;
 508     }
 509   return RETURN_VALUE_STRUCT_CONVENTION;
 510 }
 511
 512 void
 513 ppc_sysv_abi_extract_return_value (struct type *type,
 514                                    struct regcache *regcache, void *valbuf)
 515 {
 516   do_ppc_sysv_return_value (type, regcache, NULL, valbuf, 0);
 517 }
 518
 519 void
 520 ppc_sysv_abi_broken_extract_return_value (struct type *type,
 521                                           struct regcache *regcache,
 522                                           void *valbuf)
 523 {
 524   do_ppc_sysv_return_value (type, regcache, NULL, valbuf, 1);
 525 }
 526
 527 void
 528 ppc_sysv_abi_store_return_value (struct type *type, struct regcache *regcache,
 529                                  const void *valbuf)
 530 {
 531   do_ppc_sysv_return_value (type, regcache, valbuf, NULL, 0);
 532 }
 533
 534 void
 535 ppc_sysv_abi_broken_store_return_value (struct type *type,
 536                                         struct regcache *regcache,
 537                                         const void *valbuf)
 538 {
 539   do_ppc_sysv_return_value (type, regcache, valbuf, NULL, 1);
 540 }
 541
 542 /* Structures 8 bytes or less long are returned in the r3 & r4
 543    registers, according to the SYSV ABI. */
 544 int
 545 ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
 546 {
 547   return (do_ppc_sysv_return_value (value_type, NULL, NULL, NULL, 0)
 548           == RETURN_VALUE_STRUCT_CONVENTION);
 549 }
 550
 551 /* Pass the arguments in either registers, or in the stack. Using the
 552    ppc 64 bit SysV ABI.
 553
 554    This implements a dumbed down version of the ABI.  It always writes
 555    values to memory, GPR and FPR, even when not necessary.  Doing this
 556    greatly simplifies the logic. */
 557
 558 CORE_ADDR
 559 ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
 560                                 struct regcache *regcache, CORE_ADDR bp_addr,
 561                                 int nargs, struct value **args, CORE_ADDR sp,
 562                                 int struct_return, CORE_ADDR struct_addr)
 563 {
 564   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 565   /* By this stage in the proceedings, SP has been decremented by "red
 566      zone size" + "struct return size".  Fetch the stack-pointer from
 567      before this and use that as the BACK_CHAIN.  */
 568   const CORE_ADDR back_chain = read_sp ();
 569   /* See for-loop comment below.  */
 570   int write_pass;
 571   /* Size of the Altivec's vector parameter region, the final value is
 572      computed in the for-loop below.  */
 573   LONGEST vparam_size = 0;
 574   /* Size of the general parameter region, the final value is computed
 575      in the for-loop below.  */
 576   LONGEST gparam_size = 0;
 577   /* Kevin writes ... I don't mind seeing tdep->wordsize used in the
 578      calls to align_up(), align_down(), etc.  because this makes it
 579      easier to reuse this code (in a copy/paste sense) in the future,
 580      but it is a 64-bit ABI and asserting that the wordsize is 8 bytes
 581      at some point makes it easier to verify that this function is
 582      correct without having to do a non-local analysis to figure out
 583      the possible values of tdep->wordsize.  */
 584   gdb_assert (tdep->wordsize == 8);
 585
 586   /* Go through the argument list twice.
 587
 588      Pass 1: Compute the function call's stack space and register
 589      requirements.
 590
 591      Pass 2: Replay the same computation but this time also write the
 592      values out to the target.  */
 593
 594   for (write_pass = 0; write_pass < 2; write_pass++)
 595     {
 596       int argno;
 597       /* Next available floating point register for float and double
 598          arguments.  */
 599       int freg = 1;
 600       /* Next available general register for non-vector (but possibly
 601          float) arguments.  */
 602       int greg = 3;
 603       /* Next available vector register for vector arguments.  */
 604       int vreg = 2;
 605       /* The address, at which the next general purpose parameter
 606          (integer, struct, float, ...) should be saved.  */
 607       CORE_ADDR gparam;
 608       /* Address, at which the next Altivec vector parameter should be
 609          saved.  */
 610       CORE_ADDR vparam;
 611
 612       if (!write_pass)
 613         {
 614           /* During the first pass, GPARAM and VPARAM are more like
 615              offsets (start address zero) than addresses.  That way
 616              the accumulate the total stack space each region
 617              requires.  */
 618           gparam = 0;
 619           vparam = 0;
 620         }
 621       else
 622         {
 623           /* Decrement the stack pointer making space for the Altivec
 624              and general on-stack parameters.  Set vparam and gparam
 625              to their corresponding regions.  */
 626           vparam = align_down (sp - vparam_size, 16);
 627           gparam = align_down (vparam - gparam_size, 16);
 628           /* Add in space for the TOC, link editor double word,
 629              compiler double word, LR save area, CR save area.  */
 630           sp = align_down (gparam - 48, 16);
 631         }
 632
 633       /* If the function is returning a `struct', then there is an
 634          extra hidden parameter (which will be passed in r3)
 635          containing the address of that struct..  In that case we
 636          should advance one word and start from r4 register to copy
 637          parameters.  This also consumes one on-stack parameter slot.  */
 638       if (struct_return)
 639         {
 640           if (write_pass)
 641             regcache_cooked_write_signed (regcache,
 642                                           tdep->ppc_gp0_regnum + greg,
 643                                           struct_addr);
 644           greg++;
 645           gparam = align_up (gparam + tdep->wordsize, tdep->wordsize);
 646         }
 647
 648       for (argno = 0; argno < nargs; argno++)
 649         {
 650           struct value *arg = args[argno];
 651           struct type *type = check_typedef (VALUE_TYPE (arg));
 652           char *val = VALUE_CONTENTS (arg);
 653           if (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) <= 8)
 654             {
 655               /* Floats and Doubles go in f1 .. f13.  They also
 656                  consume a left aligned GREG,, and can end up in
 657                  memory.  */
 658               if (write_pass)
 659                 {
 660                   if (ppc_floating_point_unit_p (current_gdbarch)
 661                       && freg <= 13)
 662                     {
 663                       char regval[MAX_REGISTER_SIZE];
 664                       struct type *regtype = register_type (gdbarch,
 665                                                             FP0_REGNUM);
 666                       convert_typed_floating (val, type, regval, regtype);
 667                       regcache_cooked_write (regcache, FP0_REGNUM + freg,
 668                                              regval);
 669                     }
 670                   if (greg <= 10)
 671                     {
 672                       /* The ABI states "Single precision floating
 673                          point values are mapped to the first word in
 674                          a single doubleword" and "... floating point
 675                          values mapped to the first eight doublewords
 676                          of the parameter save area are also passed in
 677                          general registers").
 678
 679                          This code interprets that to mean: store it,
 680                          left aligned, in the general register.  */
 681                       char regval[MAX_REGISTER_SIZE];
 682                       memset (regval, 0, sizeof regval);
 683                       memcpy (regval, val, TYPE_LENGTH (type));
 684                       regcache_cooked_write (regcache,
 685                                              tdep->ppc_gp0_regnum + greg,
 686                                              regval);
 687                     }
 688                   write_memory (gparam, val, TYPE_LENGTH (type));
 689                 }
 690               /* Always consume parameter stack space.  */
 691               freg++;
 692               greg++;
 693               gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
 694             }
 695           else if (TYPE_LENGTH (type) == 16 && TYPE_VECTOR (type)
 696                    && TYPE_CODE (type) == TYPE_CODE_ARRAY
 697                    && tdep->ppc_vr0_regnum >= 0)
 698             {
 699               /* In the Altivec ABI, vectors go in the vector
 700                  registers v2 .. v13, or when that runs out, a vector
 701                  annex which goes above all the normal parameters.
 702                  NOTE: cagney/2003-09-21: This is a guess based on the
 703                  PowerOpen Altivec ABI.  */
 704               if (vreg <= 13)
 705                 {
 706                   if (write_pass)
 707                     regcache_cooked_write (regcache,
 708                                            tdep->ppc_vr0_regnum + vreg, val);
 709                   vreg++;
 710                 }
 711               else
 712                 {
 713                   if (write_pass)
 714                     write_memory (vparam, val, TYPE_LENGTH (type));
 715                   vparam = align_up (vparam + TYPE_LENGTH (type), 16);
 716                 }
 717             }
 718           else if ((TYPE_CODE (type) == TYPE_CODE_INT
 719                     || TYPE_CODE (type) == TYPE_CODE_ENUM)
 720                    && TYPE_LENGTH (type) <= 8)
 721             {
 722               /* Scalars get sign[un]extended and go in gpr3 .. gpr10.
 723                  They can also end up in memory.  */
 724               if (write_pass)
 725                 {
 726                   /* Sign extend the value, then store it unsigned.  */
 727                   ULONGEST word = unpack_long (type, val);
 728                   if (greg <= 10)
 729                     regcache_cooked_write_unsigned (regcache,
 730                                                     tdep->ppc_gp0_regnum +
 731                                                     greg, word);
 732                   write_memory_unsigned_integer (gparam, tdep->wordsize,
 733                                                  word);
 734                 }
 735               greg++;
 736               gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
 737             }
 738           else
 739             {
 740               int byte;
 741               for (byte = 0; byte < TYPE_LENGTH (type);
 742                    byte += tdep->wordsize)
 743                 {
 744                   if (write_pass && greg <= 10)
 745                     {
 746                       char regval[MAX_REGISTER_SIZE];
 747                       int len = TYPE_LENGTH (type) - byte;
 748                       if (len > tdep->wordsize)
 749                         len = tdep->wordsize;
 750                       memset (regval, 0, sizeof regval);
 751                       /* WARNING: cagney/2003-09-21: As best I can
 752                          tell, the ABI specifies that the value should
 753                          be left aligned.  Unfortunately, GCC doesn't
 754                          do this - it instead right aligns even sized
 755                          values and puts odd sized values on the
 756                          stack.  Work around that by putting both a
 757                          left and right aligned value into the
 758                          register (hopefully no one notices :-^).
 759                          Arrrgh!  */
 760                       /* Left aligned (8 byte values such as pointers
 761                          fill the buffer).  */
 762                       memcpy (regval, val + byte, len);
 763                       /* Right aligned (but only if even).  */
 764                       if (len == 1 || len == 2 || len == 4)
 765                         memcpy (regval + tdep->wordsize - len,
 766                                 val + byte, len);
 767                       regcache_cooked_write (regcache, greg, regval);
 768                     }
 769                   greg++;
 770                 }
 771               if (write_pass)
 772                 /* WARNING: cagney/2003-09-21: Strictly speaking, this
 773                    isn't necessary, unfortunately, GCC appears to get
 774                    "struct convention" parameter passing wrong putting
 775                    odd sized structures in memory instead of in a
 776                    register.  Work around this by always writing the
 777                    value to memory.  Fortunately, doing this
 778                    simplifies the code.  */
 779                 write_memory (gparam, val, TYPE_LENGTH (type));
 780               /* Always consume parameter stack space.  */
 781               gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize);
 782             }
 783         }
 784
 785       if (!write_pass)
 786         {
 787           /* Save the true region sizes ready for the second pass.  */
 788           vparam_size = vparam;
 789           /* Make certain that the general parameter save area is at
 790              least the minimum 8 registers (or doublewords) in size.  */
 791           if (greg < 8)
 792             gparam_size = 8 * tdep->wordsize;
 793           else
 794             gparam_size = gparam;
 795         }
 796     }
 797
 798   /* Update %sp.   */
 799   regcache_cooked_write_signed (regcache, SP_REGNUM, sp);
 800
 801   /* Write the backchain (it occupies WORDSIZED bytes).  */
 802   write_memory_signed_integer (sp, tdep->wordsize, back_chain);
 803
 804   /* Point the inferior function call's return address at the dummy's
 805      breakpoint.  */
 806   regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
 807
 808   /* Find a value for the TOC register.  Every symbol should have both
 809      ".FN" and "FN" in the minimal symbol table.  "FN" points at the
 810      FN's descriptor, while ".FN" points at the entry point (which
 811      matches FUNC_ADDR).  Need to reverse from FUNC_ADDR back to the
 812      FN's descriptor address.  */
 813   {
 814     /* Find the minimal symbol that corresponds to FUNC_ADDR (should
 815        have the name ".FN").  */
 816     struct minimal_symbol *dot_fn = lookup_minimal_symbol_by_pc (func_addr);
 817     if (dot_fn != NULL && SYMBOL_LINKAGE_NAME (dot_fn)[0] == '.')
 818       {
 819         /* Now find the corresponding "FN" (dropping ".") minimal
 820            symbol's address.  */
 821         struct minimal_symbol *fn =
 822           lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (dot_fn) + 1, NULL,
 823                                  NULL);
 824         if (fn != NULL)
 825           {
 826             /* Got the address of that descriptor.  The TOC is the
 827                second double word.  */
 828             CORE_ADDR toc =
 829               read_memory_unsigned_integer (SYMBOL_VALUE_ADDRESS (fn) +
 830                                             tdep->wordsize, tdep->wordsize);
 831             regcache_cooked_write_unsigned (regcache,
 832                                             tdep->ppc_gp0_regnum + 2, toc);
 833           }
 834       }
 835   }
 836
 837   return sp;
 838 }
 839
 840
 841 /* The 64 bit ABI retun value convention.
 842
 843    Return non-zero if the return-value is stored in a register, return
 844    0 if the return-value is instead stored on the stack (a.k.a.,
 845    struct return convention).
 846
 847    For a return-value stored in a register: when INVAL is non-NULL,
 848    copy the buffer to the corresponding register return-value location
 849    location; when OUTVAL is non-NULL, fill the buffer from the
 850    corresponding register return-value location.  */
 851 static enum return_value_convention
 852 ppc64_sysv_abi_return_value (struct type *valtype, struct regcache *regcache,
 853                              const void *inval, void *outval)
 854 {
 855   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 856   /* Floats and doubles in F1.  */
 857   if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
 858     {
 859       char regval[MAX_REGISTER_SIZE];
 860       struct type *regtype = register_type (current_gdbarch, FP0_REGNUM);
 861       if (inval != NULL)
 862         {
 863           convert_typed_floating (inval, valtype, regval, regtype);
 864           regcache_cooked_write (regcache, FP0_REGNUM + 1, regval);
 865         }
 866       if (outval != NULL)
 867         {
 868           regcache_cooked_read (regcache, FP0_REGNUM + 1, regval);
 869           convert_typed_floating (regval, regtype, outval, valtype);
 870         }
 871       return RETURN_VALUE_REGISTER_CONVENTION;
 872     }
 873   if (TYPE_CODE (valtype) == TYPE_CODE_INT && TYPE_LENGTH (valtype) <= 8)
 874     {
 875       /* Integers in r3.  */
 876       if (inval != NULL)
 877         {
 878           /* Be careful to sign extend the value.  */
 879           regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 880                                           unpack_long (valtype, inval));
 881         }
 882       if (outval != NULL)
 883         {
 884           /* Extract the integer from r3.  Since this is truncating the
 885              value, there isn't a sign extension problem.  */
 886           ULONGEST regval;
 887           regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 888                                          &regval);
 889           store_unsigned_integer (outval, TYPE_LENGTH (valtype), regval);
 890         }
 891       return RETURN_VALUE_REGISTER_CONVENTION;
 892     }
 893   /* All pointers live in r3.  */
 894   if (TYPE_CODE (valtype) == TYPE_CODE_PTR)
 895     {
 896       /* All pointers live in r3.  */
 897       if (inval != NULL)
 898         regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, inval);
 899       if (outval != NULL)
 900         regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, outval);
 901       return RETURN_VALUE_REGISTER_CONVENTION;
 902     }
 903   if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
 904       && TYPE_LENGTH (valtype) <= 8
 905       && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
 906       && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
 907     {
 908       /* Small character arrays are returned, right justified, in r3.  */
 909       int offset = (register_size (current_gdbarch, tdep->ppc_gp0_regnum + 3)
 910                     - TYPE_LENGTH (valtype));
 911       if (inval != NULL)
 912         regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
 913                                     offset, TYPE_LENGTH (valtype), inval);
 914       if (outval != NULL)
 915         regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
 916                                    offset, TYPE_LENGTH (valtype), outval);
 917       return RETURN_VALUE_REGISTER_CONVENTION;
 918     }
 919   /* Big floating point values get stored in adjacent floating
 920      point registers.  */
 921   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
 922       && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32))
 923     {
 924       if (inval || outval != NULL)
 925         {
 926           int i;
 927           for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
 928             {
 929               if (inval != NULL)
 930                 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
 931                                        (const bfd_byte *) inval + i * 8);
 932               if (outval != NULL)
 933                 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
 934                                       (bfd_byte *) outval + i * 8);
 935             }
 936         }
 937       return RETURN_VALUE_REGISTER_CONVENTION;
 938     }
 939   /* Complex values get returned in f1:f2, need to convert.  */
 940   if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX
 941       && (TYPE_LENGTH (valtype) == 8 || TYPE_LENGTH (valtype) == 16))
 942     {
 943       if (regcache != NULL)
 944         {
 945           int i;
 946           for (i = 0; i < 2; i++)
 947             {
 948               char regval[MAX_REGISTER_SIZE];
 949               struct type *regtype =
 950                 register_type (current_gdbarch, FP0_REGNUM);
 951               if (inval != NULL)
 952                 {
 953                   convert_typed_floating ((const bfd_byte *) inval +
 954                                           i * (TYPE_LENGTH (valtype) / 2),
 955                                           valtype, regval, regtype);
 956                   regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
 957                                          regval);
 958                 }
 959               if (outval != NULL)
 960                 {
 961                   regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regval);
 962                   convert_typed_floating (regval, regtype,
 963                                           (bfd_byte *) outval +
 964                                           i * (TYPE_LENGTH (valtype) / 2),
 965                                           valtype);
 966                 }
 967             }
 968         }
 969       return RETURN_VALUE_REGISTER_CONVENTION;
 970     }
 971   /* Big complex values get stored in f1:f4.  */
 972   if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32)
 973     {
 974       if (regcache != NULL)
 975         {
 976           int i;
 977           for (i = 0; i < 4; i++)
 978             {
 979               if (inval != NULL)
 980                 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
 981                                        (const bfd_byte *) inval + i * 8);
 982               if (outval != NULL)
 983                 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
 984                                       (bfd_byte *) outval + i * 8);
 985             }
 986         }
 987       return RETURN_VALUE_REGISTER_CONVENTION;
 988     }
 989   return RETURN_VALUE_STRUCT_CONVENTION;
 990 }
 991
 992 int
 993 ppc64_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
 994 {
 995   return (ppc64_sysv_abi_return_value (value_type, NULL, NULL, NULL)
 996           == RETURN_VALUE_STRUCT_CONVENTION);
 997 }
 998
 999 void
1000 ppc64_sysv_abi_extract_return_value (struct type *valtype,
1001                                      struct regcache *regbuf, void *valbuf)
1002 {
1003   if (ppc64_sysv_abi_return_value (valtype, regbuf, NULL, valbuf)
1004       != RETURN_VALUE_REGISTER_CONVENTION)
1005     error ("Function return value unknown");
1006 }
1007
1008 void
1009 ppc64_sysv_abi_store_return_value (struct type *valtype,
1010                                    struct regcache *regbuf,
1011                                    const void *valbuf)
1012 {
1013   if (!ppc64_sysv_abi_return_value (valtype, regbuf, valbuf, NULL))
1014     error ("Function return value location unknown");
1015 }