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 /* round2 rounds x up to the nearest multiple of s assuming that s is a
  33    power of 2 */
  34
  35 #undef round2
  36 #define round2(x,s) ((((long) (x) - 1) & ~(long)((s)-1)) + (s))
  37
  38 /* Pass the arguments in either registers, or in the stack. Using the
  39    ppc sysv ABI, the first eight words of the argument list (that might
  40    be less than eight parameters if some parameters occupy more than one
  41    word) are passed in r3..r10 registers.  float and double parameters are
  42    passed in fpr's, in addition to that. Rest of the parameters if any
  43    are passed in user stack.
  44
  45    If the function is returning a structure, then the return address is passed
  46    in r3, then the first 7 words of the parametes can be passed in registers,
  47    starting from r4. */
  48
  49 CORE_ADDR
  50 ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
  51                               struct regcache *regcache, CORE_ADDR bp_addr,
  52                               int nargs, struct value **args, CORE_ADDR sp,
  53                               int struct_return, CORE_ADDR struct_addr)
  54 {
  55   int argno;
  56   /* Next available general register for non-float, non-vector arguments. */
  57   int greg;
  58   /* Next available floating point register for float arguments. */
  59   int freg;
  60   /* Next available vector register for vector arguments. */
  61   int vreg;
  62   int argstkspace;
  63   int structstkspace;
  64   int argoffset;
  65   int structoffset;
  66   struct type *type;
  67   int len;
  68   char old_sp_buf[4];
  69   CORE_ADDR saved_sp;
  70   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
  71
  72   greg = struct_return ? 4 : 3;
  73   freg = 1;
  74   vreg = 2;
  75   argstkspace = 0;
  76   structstkspace = 0;
  77
  78   /* Figure out how much new stack space is required for arguments
  79      which don't fit in registers.  Unlike the PowerOpen ABI, the
  80      SysV ABI doesn't reserve any extra space for parameters which
  81      are put in registers. */
  82   for (argno = 0; argno < nargs; argno++)
  83     {
  84       struct value *arg = args[argno];
  85       type = check_typedef (VALUE_TYPE (arg));
  86       len = TYPE_LENGTH (type);
  87
  88       if (TYPE_CODE (type) == TYPE_CODE_FLT
  89           && ppc_floating_point_unit_p (current_gdbarch))
  90         {
  91           if (freg <= 8)
  92             freg++;
  93           else
  94             {
  95               /* SysV ABI converts floats to doubles when placed in
  96                  memory and requires 8 byte alignment */
  97               if (argstkspace & 0x4)
  98                 argstkspace += 4;
  99               argstkspace += 8;
 100             }
 101         }
 102       else if (len == 8
 103                && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
 104                    || (!ppc_floating_point_unit_p (current_gdbarch)
 105                        && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */
 106         {
 107           if (greg > 9)
 108             {
 109               greg = 11;
 110               if (argstkspace & 0x4)
 111                 argstkspace += 4;
 112               argstkspace += 8;
 113             }
 114           else
 115             {
 116               if ((greg & 1) == 0)
 117                 greg++;
 118               greg += 2;
 119             }
 120         }
 121       else if (!TYPE_VECTOR (type))
 122         {
 123           if (len > 4
 124               || TYPE_CODE (type) == TYPE_CODE_STRUCT
 125               || TYPE_CODE (type) == TYPE_CODE_UNION)
 126             {
 127               /* Rounding to the nearest multiple of 8 may not be necessary,
 128                  but it is safe.  Particularly since we don't know the
 129                  field types of the structure */
 130               structstkspace += round2 (len, 8);
 131             }
 132           if (greg <= 10)
 133             greg++;
 134           else
 135             argstkspace += 4;
 136         }
 137       else
 138         {
 139           if (len == 16
 140               && TYPE_CODE (type) == TYPE_CODE_ARRAY
 141               && TYPE_VECTOR (type))
 142             {
 143               if (vreg <= 13)
 144                 vreg++;
 145               else
 146                 {
 147                   /* Vector arguments must be aligned to 16 bytes on
 148                      the stack. */
 149                   argstkspace += round2 (argstkspace, 16);
 150                   argstkspace += 16;
 151                 }
 152             }
 153           else if (len == 8
 154                    && TYPE_CODE (type) == TYPE_CODE_ARRAY
 155                    && TYPE_VECTOR (type))
 156             {
 157               if (greg <= 10)
 158                 greg++;
 159               else
 160                 {
 161                   /* Vector arguments must be aligned to 8 bytes on
 162                      the stack. */
 163                   argstkspace += round2 (argstkspace, 8);
 164                   argstkspace += 8;
 165                 }
 166             }
 167         }
 168     }
 169
 170   /* Get current SP location */
 171   saved_sp = read_sp ();
 172
 173   sp -= argstkspace + structstkspace;
 174
 175   /* Allocate space for backchain and callee's saved lr */
 176   sp -= 8;
 177
 178   /* Make sure that we maintain 16 byte alignment */
 179   sp &= ~0x0f;
 180
 181   /* Update %sp before proceeding any further */
 182   write_register (SP_REGNUM, sp);
 183
 184   /* write the backchain */
 185   store_unsigned_integer (old_sp_buf, 4, saved_sp);
 186   write_memory (sp, old_sp_buf, 4);
 187
 188   argoffset = 8;
 189   structoffset = argoffset + argstkspace;
 190   freg = 1;
 191   greg = 3;
 192   vreg = 2;
 193
 194   /* Fill in r3 with the return structure, if any */
 195   if (struct_return)
 196     {
 197       write_register (tdep->ppc_gp0_regnum + greg, struct_addr);
 198       greg++;
 199     }
 200
 201   /* Now fill in the registers and stack... */
 202   for (argno = 0; argno < nargs; argno++)
 203     {
 204       struct value *arg = args[argno];
 205       char *val = VALUE_CONTENTS (arg);
 206       type = check_typedef (VALUE_TYPE (arg));
 207       len = TYPE_LENGTH (type);
 208
 209       if (TYPE_CODE (type) == TYPE_CODE_FLT
 210           && ppc_floating_point_unit_p (current_gdbarch))
 211         {
 212           if (freg <= 8)
 213             {
 214               ULONGEST regval;
 215               if (len > 8)
 216                 printf_unfiltered (
 217                                    "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 218               regval = extract_unsigned_integer (val, len);
 219               write_register (FP0_REGNUM + freg, regval);
 220               freg++;
 221             }
 222           else
 223             {
 224               /* SysV ABI converts floats to doubles when placed in
 225                  memory and requires 8 byte alignment */
 226               /* FIXME: Convert floats to doubles */
 227               if (argoffset & 0x4)
 228                 argoffset += 4;
 229               write_memory (sp + argoffset, val, len);
 230               argoffset += 8;
 231             }
 232         }
 233       else if (len == 8
 234                && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */
 235                    || (!ppc_floating_point_unit_p (current_gdbarch)
 236                         && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */
 237         {
 238           if (greg > 9)
 239             {
 240               greg = 11;
 241               if (argoffset & 0x4)
 242                 argoffset += 4;
 243               write_memory (sp + argoffset, val, len);
 244               argoffset += 8;
 245             }
 246           else
 247             {
 248               ULONGEST regval;
 249               if ((greg & 1) == 0)
 250                 greg++;
 251               regval = extract_unsigned_integer (val, 4);
 252               write_register (tdep->ppc_gp0_regnum + greg, regval);
 253               regval = extract_unsigned_integer (val + 4, 4);
 254               write_register (tdep->ppc_gp0_regnum + greg + 1, regval);
 255               greg += 2;
 256             }
 257         }
 258       else if (!TYPE_VECTOR (type))
 259         {
 260           char val_buf[4];
 261           if (len > 4
 262               || TYPE_CODE (type) == TYPE_CODE_STRUCT
 263               || TYPE_CODE (type) == TYPE_CODE_UNION)
 264             {
 265               write_memory (sp + structoffset, val, len);
 266               store_unsigned_integer (val_buf, 4, sp + structoffset);
 267               structoffset += round2 (len, 8);
 268             }
 269           else
 270             {
 271               memset (val_buf, 0, 4);
 272               memcpy (val_buf, val, len);
 273             }
 274           if (greg <= 10)
 275             {
 276               ULONGEST regval = extract_unsigned_integer (val_buf, 4);
 277               write_register (tdep->ppc_gp0_regnum + greg, regval);
 278               greg++;
 279             }
 280           else
 281             {
 282               write_memory (sp + argoffset, val_buf, 4);
 283               argoffset += 4;
 284             }
 285         }
 286       else
 287         {
 288           if (len == 16
 289               && TYPE_CODE (type) == TYPE_CODE_ARRAY
 290               && TYPE_VECTOR (type))
 291             {
 292               char *v_val_buf = alloca (16);
 293               memset (v_val_buf, 0, 16);
 294               memcpy (v_val_buf, val, len);
 295               if (vreg <= 13)
 296                 {
 297                   regcache_cooked_write (current_regcache,
 298                                          tdep->ppc_vr0_regnum + vreg,
 299                                          v_val_buf);
 300                   vreg++;
 301                 }
 302               else
 303                 {
 304                   write_memory (sp + argoffset, v_val_buf, 16);
 305                   argoffset += 16;
 306                 }
 307             }
 308           else if (len == 8
 309                    && TYPE_CODE (type) == TYPE_CODE_ARRAY
 310                    && TYPE_VECTOR (type))
 311             {
 312               char *v_val_buf = alloca (8);
 313               memset (v_val_buf, 0, 8);
 314               memcpy (v_val_buf, val, len);
 315               if (greg <= 10)
 316                 {
 317                   regcache_cooked_write (current_regcache,
 318                                          tdep->ppc_ev0_regnum + greg,
 319                                          v_val_buf);
 320                   greg++;
 321                 }
 322               else
 323                 {
 324                   write_memory (sp + argoffset, v_val_buf, 8);
 325                   argoffset += 8;
 326                 }
 327             }
 328         }
 329     }
 330
 331   target_store_registers (-1);
 332   return sp;
 333 }
 334
 335 /* Until November 2001, gcc was not complying to the SYSV ABI for
 336    returning structures less than or equal to 8 bytes in size.  It was
 337    returning everything in memory.  When this was corrected, it wasn't
 338    fixed for native platforms.  */
 339 int
 340 ppc_sysv_abi_broken_use_struct_convention (int gcc_p, struct type *value_type)
 341 {
 342   if ((TYPE_LENGTH (value_type) == 16 || TYPE_LENGTH (value_type) == 8)
 343       && TYPE_VECTOR (value_type))
 344     return 0;
 345
 346   return generic_use_struct_convention (gcc_p, value_type);
 347 }
 348
 349 /* Structures 8 bytes or less long are returned in the r3 & r4
 350    registers, according to the SYSV ABI. */
 351 int
 352 ppc_sysv_abi_use_struct_convention (int gcc_p, struct type *value_type)
 353 {
 354   if ((TYPE_LENGTH (value_type) == 16 || TYPE_LENGTH (value_type) == 8)
 355       && TYPE_VECTOR (value_type))
 356     return 0;
 357
 358   return (TYPE_LENGTH (value_type) > 8);
 359 }