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
  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 /* Structures 8 bytes or less long are returned in the r3 & r4
 309    registers, according to the SYSV ABI. */
 310 int
 311 ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
 312 {
 313   if ((TYPE_LENGTH (value_type) == 16 || TYPE_LENGTH (value_type) == 8)
 314       && TYPE_VECTOR (value_type))
 315     return 0;
 316
 317   return (TYPE_LENGTH (value_type) > 8);
 318 }
 319
 320
 321 /* The 64 bit ABI retun value convention.
 322
 323    Return non-zero if the return-value is stored in a register, return
 324    0 if the return-value is instead stored on the stack (a.k.a.,
 325    struct return convention).
 326
 327    For a return-value stored in a register: when INVAL is non-NULL,
 328    copy the buffer to the corresponding register return-value location
 329    location; when OUTVAL is non-NULL, fill the buffer from the
 330    corresponding register return-value location.  */
 331
 332 /* Potential ways that a function can return a value of a given type.  */
 333 enum return_value_convention
 334 {
 335   /* Where the return value has been squeezed into one or more
 336      registers.  */
 337   RETURN_VALUE_REGISTER_CONVENTION,
 338   /* Commonly known as the "struct return convention".  The caller
 339      passes an additional hidden first parameter to the caller.  That
 340      parameter contains the address at which the value being returned
 341      should be stored.  While typically, and historically, used for
 342      large structs, this is convention is applied to values of many
 343      different types.  */
 344   RETURN_VALUE_STRUCT_CONVENTION
 345 };
 346
 347 static enum return_value_convention
 348 ppc64_sysv_abi_return_value (struct type *valtype, struct regcache *regcache,
 349                              const void *inval, void *outval)
 350 {
 351   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 352   /* Floats and doubles in F1.  */
 353   if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
 354     {
 355       char regval[MAX_REGISTER_SIZE];
 356       struct type *regtype = register_type (current_gdbarch, FP0_REGNUM);
 357       if (inval != NULL)
 358         {
 359           convert_typed_floating (inval, valtype, regval, regtype);
 360           regcache_cooked_write (regcache, FP0_REGNUM + 1, regval);
 361         }
 362       if (outval != NULL)
 363         {
 364           regcache_cooked_read (regcache, FP0_REGNUM + 1, regval);
 365           convert_typed_floating (regval, regtype, outval, valtype);
 366         }
 367       return RETURN_VALUE_REGISTER_CONVENTION;
 368     }
 369   if (TYPE_CODE (valtype) == TYPE_CODE_INT && TYPE_LENGTH (valtype) <= 8)
 370     {
 371       /* Integers in r3.  */
 372       if (inval != NULL)
 373         {
 374           /* Be careful to sign extend the value.  */
 375           regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 376                                           unpack_long (valtype, inval));
 377         }
 378       if (outval != NULL)
 379         {
 380           /* Extract the integer from r3.  Since this is truncating the
 381              value, there isn't a sign extension problem.  */
 382           ULONGEST regval;
 383           regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 384                                          &regval);
 385           store_unsigned_integer (outval, TYPE_LENGTH (valtype), regval);
 386         }
 387       return RETURN_VALUE_REGISTER_CONVENTION;
 388     }
 389   /* All pointers live in r3.  */
 390   if (TYPE_CODE (valtype) == TYPE_CODE_PTR)
 391     {
 392       /* All pointers live in r3.  */
 393       if (inval != NULL)
 394         regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, inval);
 395       if (outval != NULL)
 396         regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, outval);
 397       return RETURN_VALUE_REGISTER_CONVENTION;
 398     }
 399   if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
 400       && TYPE_LENGTH (valtype) <= 8
 401       && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
 402       && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
 403     {
 404       /* Small character arrays are returned, right justified, in r3.  */
 405       int offset = (register_size (current_gdbarch, tdep->ppc_gp0_regnum + 3)
 406                     - TYPE_LENGTH (valtype));
 407       if (inval != NULL)
 408         regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
 409                                     offset, TYPE_LENGTH (valtype), inval);
 410       if (outval != NULL)
 411         regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
 412                                    offset, TYPE_LENGTH (valtype), outval);
 413       return RETURN_VALUE_REGISTER_CONVENTION;
 414     }
 415   /* Big floating point values get stored in adjacent floating
 416      point registers.  */
 417   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
 418       && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32))
 419     {
 420       if (inval || outval != NULL)
 421         {
 422           int i;
 423           for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
 424             {
 425               if (inval != NULL)
 426                 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
 427                                        (const bfd_byte *) inval + i * 8);
 428               if (outval != NULL)
 429                 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
 430                                       (bfd_byte *) outval + i * 8);
 431             }
 432         }
 433       return RETURN_VALUE_REGISTER_CONVENTION;
 434     }
 435   /* Complex values get returned in f1:f2, need to convert.  */
 436   if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX
 437       && (TYPE_LENGTH (valtype) == 8 || TYPE_LENGTH (valtype) == 16))
 438     {
 439       if (regcache != NULL)
 440         {
 441           int i;
 442           for (i = 0; i < 2; i++)
 443             {
 444               char regval[MAX_REGISTER_SIZE];
 445               struct type *regtype =
 446                 register_type (current_gdbarch, FP0_REGNUM);
 447               if (inval != NULL)
 448                 {
 449                   convert_typed_floating ((const bfd_byte *) inval +
 450                                           i * (TYPE_LENGTH (valtype) / 2),
 451                                           valtype, regval, regtype);
 452                   regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
 453                                          regval);
 454                 }
 455               if (outval != NULL)
 456                 {
 457                   regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regval);
 458                   convert_typed_floating (regval, regtype,
 459                                           (bfd_byte *) outval +
 460                                           i * (TYPE_LENGTH (valtype) / 2),
 461                                           valtype);
 462                 }
 463             }
 464         }
 465       return RETURN_VALUE_REGISTER_CONVENTION;
 466     }
 467   /* Big complex values get stored in f1:f4.  */
 468   if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX && TYPE_LENGTH (valtype) == 32)
 469     {
 470       if (regcache != NULL)
 471         {
 472           int i;
 473           for (i = 0; i < 4; i++)
 474             {
 475               if (inval != NULL)
 476                 regcache_cooked_write (regcache, FP0_REGNUM + 1 + i,
 477                                        (const bfd_byte *) inval + i * 8);
 478               if (outval != NULL)
 479                 regcache_cooked_read (regcache, FP0_REGNUM + 1 + i,
 480                                       (bfd_byte *) outval + i * 8);
 481             }
 482         }
 483       return RETURN_VALUE_REGISTER_CONVENTION;
 484     }
 485   return RETURN_VALUE_STRUCT_CONVENTION;
 486 }
 487
 488 int
 489 ppc64_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
 490 {
 491   return (ppc64_sysv_abi_return_value (value_type, NULL, NULL, NULL)
 492           == RETURN_VALUE_STRUCT_CONVENTION);
 493 }
 494
 495 void
 496 ppc64_sysv_abi_extract_return_value (struct type *valtype,
 497                                      struct regcache *regbuf, void *valbuf)
 498 {
 499   if (ppc64_sysv_abi_return_value (valtype, regbuf, NULL, valbuf)
 500       != RETURN_VALUE_REGISTER_CONVENTION)
 501     error ("Function return value unknown");
 502 }
 503
 504 void
 505 ppc64_sysv_abi_store_return_value (struct type *valtype,
 506                                    struct regcache *regbuf,
 507                                    const void *valbuf)
 508 {
 509   if (!ppc64_sysv_abi_return_value (valtype, regbuf, valbuf, NULL))
 510     error ("Function return value location unknown");
 511 }