gdb/rs6000-lynx178-tdep.c

   1 /* Copyright (C) 2012-2019 Free Software Foundation, Inc.
   2
   3    This file is part of GDB.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include "defs.h"
  19 #include "osabi.h"
  20 #include "regcache.h"
  21 #include "gdbcore.h"
  22 #include "gdbtypes.h"
  23 #include "infcall.h"
  24 #include "ppc-tdep.h"
  25 #include "target-float.h"
  26 #include "value.h"
  27 #include "xcoffread.h"
  28
  29 /* Implement the "push_dummy_call" gdbarch method.  */
  30
  31 static CORE_ADDR
  32 rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
  33                                 struct value *function,
  34                                 struct regcache *regcache, CORE_ADDR bp_addr,
  35                                 int nargs, struct value **args, CORE_ADDR sp,
  36                                 function_call_return_method return_method,
  37                                 CORE_ADDR struct_addr)
  38 {
  39   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  40   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  41   int ii;
  42   int len = 0;
  43   int argno;                    /* current argument number */
  44   int argbytes;                 /* current argument byte */
  45   gdb_byte tmp_buffer[50];
  46   int f_argno = 0;              /* current floating point argno */
  47   int wordsize = gdbarch_tdep (gdbarch)->wordsize;
  48
  49   struct value *arg = 0;
  50   struct type *type;
  51
  52   ULONGEST saved_sp;
  53
  54   /* The calling convention this function implements assumes the
  55      processor has floating-point registers.  We shouldn't be using it
  56      on PPC variants that lack them.  */
  57   gdb_assert (ppc_floating_point_unit_p (gdbarch));
  58
  59   /* The first eight words of ther arguments are passed in registers.
  60      Copy them appropriately.  */
  61   ii = 0;
  62
  63   /* If the function is returning a `struct', then the first word
  64      (which will be passed in r3) is used for struct return address.
  65      In that case we should advance one word and start from r4
  66      register to copy parameters.  */
  67   if (return_method == return_method_struct)
  68     {
  69       regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
  70                                    struct_addr);
  71       ii++;
  72     }
  73
  74   /* Effectively indirect call... gcc does...
  75
  76      return_val example( float, int);
  77
  78      eabi:
  79      float in fp0, int in r3
  80      offset of stack on overflow 8/16
  81      for varargs, must go by type.
  82      power open:
  83      float in r3&r4, int in r5
  84      offset of stack on overflow different
  85      both:
  86      return in r3 or f0.  If no float, must study how gcc emulates floats;
  87      pay attention to arg promotion.
  88      User may have to cast\args to handle promotion correctly
  89      since gdb won't know if prototype supplied or not.  */
  90
  91   for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
  92     {
  93       int reg_size = register_size (gdbarch, ii + 3);
  94
  95       arg = args[argno];
  96       type = check_typedef (value_type (arg));
  97       len = TYPE_LENGTH (type);
  98
  99       if (TYPE_CODE (type) == TYPE_CODE_FLT)
 100         {
 101
 102           /* Floating point arguments are passed in fpr's, as well as gpr's.
 103              There are 13 fpr's reserved for passing parameters.  At this point
 104              there is no way we would run out of them.
 105
 106              Always store the floating point value using the register's
 107              floating-point format.  */
 108           const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno;
 109           gdb_byte reg_val[PPC_MAX_REGISTER_SIZE];
 110           struct type *reg_type = register_type (gdbarch, fp_regnum);
 111
 112           gdb_assert (len <= 8);
 113
 114           target_float_convert (value_contents (arg), type, reg_val, reg_type);
 115           regcache->cooked_write (fp_regnum, reg_val);
 116           ++f_argno;
 117         }
 118
 119       if (len > reg_size)
 120         {
 121
 122           /* Argument takes more than one register.  */
 123           while (argbytes < len)
 124             {
 125               gdb_byte word[PPC_MAX_REGISTER_SIZE];
 126               memset (word, 0, reg_size);
 127               memcpy (word,
 128                       ((char *) value_contents (arg)) + argbytes,
 129                       (len - argbytes) > reg_size
 130                         ? reg_size : len - argbytes);
 131               regcache->cooked_write (tdep->ppc_gp0_regnum + 3 + ii, word);
 132               ++ii, argbytes += reg_size;
 133
 134               if (ii >= 8)
 135                 goto ran_out_of_registers_for_arguments;
 136             }
 137           argbytes = 0;
 138           --ii;
 139         }
 140       else
 141         {
 142           /* Argument can fit in one register.  No problem.  */
 143           gdb_byte word[PPC_MAX_REGISTER_SIZE];
 144
 145           memset (word, 0, reg_size);
 146           memcpy (word, value_contents (arg), len);
 147           regcache->cooked_write (tdep->ppc_gp0_regnum + 3 +ii, word);
 148         }
 149       ++argno;
 150     }
 151
 152 ran_out_of_registers_for_arguments:
 153
 154   regcache_cooked_read_unsigned (regcache,
 155                                  gdbarch_sp_regnum (gdbarch),
 156                                  &saved_sp);
 157
 158   /* Location for 8 parameters are always reserved.  */
 159   sp -= wordsize * 8;
 160
 161   /* Another six words for back chain, TOC register, link register, etc.  */
 162   sp -= wordsize * 6;
 163
 164   /* Stack pointer must be quadword aligned.  */
 165   sp = align_down (sp, 16);
 166
 167   /* If there are more arguments, allocate space for them in
 168      the stack, then push them starting from the ninth one.  */
 169
 170   if ((argno < nargs) || argbytes)
 171     {
 172       int space = 0, jj;
 173
 174       if (argbytes)
 175         {
 176           space += align_up (len - argbytes, 4);
 177           jj = argno + 1;
 178         }
 179       else
 180         jj = argno;
 181
 182       for (; jj < nargs; ++jj)
 183         {
 184           struct value *val = args[jj];
 185
 186           space += align_up (TYPE_LENGTH (value_type (val)), 4);
 187         }
 188
 189       /* Add location required for the rest of the parameters.  */
 190       space = align_up (space, 16);
 191       sp -= space;
 192
 193       /* This is another instance we need to be concerned about
 194          securing our stack space.  If we write anything underneath %sp
 195          (r1), we might conflict with the kernel who thinks he is free
 196          to use this area.  So, update %sp first before doing anything
 197          else.  */
 198
 199       regcache_raw_write_signed (regcache,
 200                                  gdbarch_sp_regnum (gdbarch), sp);
 201
 202       /* If the last argument copied into the registers didn't fit there
 203          completely, push the rest of it into stack.  */
 204
 205       if (argbytes)
 206         {
 207           write_memory (sp + 24 + (ii * 4),
 208                         value_contents (arg) + argbytes,
 209                         len - argbytes);
 210           ++argno;
 211           ii += align_up (len - argbytes, 4) / 4;
 212         }
 213
 214       /* Push the rest of the arguments into stack.  */
 215       for (; argno < nargs; ++argno)
 216         {
 217
 218           arg = args[argno];
 219           type = check_typedef (value_type (arg));
 220           len = TYPE_LENGTH (type);
 221
 222
 223           /* Float types should be passed in fpr's, as well as in the
 224              stack.  */
 225           if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
 226             {
 227
 228               gdb_assert (len <= 8);
 229
 230               regcache->cooked_write (tdep->ppc_fp0_regnum + 1 + f_argno,
 231                                       value_contents (arg));
 232               ++f_argno;
 233             }
 234
 235           write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
 236           ii += align_up (len, 4) / 4;
 237         }
 238     }
 239
 240   /* Set the stack pointer.  According to the ABI, the SP is meant to
 241      be set _before_ the corresponding stack space is used.  On AIX,
 242      this even applies when the target has been completely stopped!
 243      Not doing this can lead to conflicts with the kernel which thinks
 244      that it still has control over this not-yet-allocated stack
 245      region.  */
 246   regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
 247
 248   /* Set back chain properly.  */
 249   store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
 250   write_memory (sp, tmp_buffer, wordsize);
 251
 252   /* Point the inferior function call's return address at the dummy's
 253      breakpoint.  */
 254   regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
 255
 256   target_store_registers (regcache, -1);
 257   return sp;
 258 }
 259
 260 /* Implement the "return_value" gdbarch method.  */
 261
 262 static enum return_value_convention
 263 rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function,
 264                              struct type *valtype, struct regcache *regcache,
 265                              gdb_byte *readbuf, const gdb_byte *writebuf)
 266 {
 267   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 268   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 269
 270   /* The calling convention this function implements assumes the
 271      processor has floating-point registers.  We shouldn't be using it
 272      on PowerPC variants that lack them.  */
 273   gdb_assert (ppc_floating_point_unit_p (gdbarch));
 274
 275   /* AltiVec extension: Functions that declare a vector data type as a
 276      return value place that return value in VR2.  */
 277   if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
 278       && TYPE_LENGTH (valtype) == 16)
 279     {
 280       if (readbuf)
 281         regcache->cooked_read (tdep->ppc_vr0_regnum + 2, readbuf);
 282       if (writebuf)
 283         regcache->cooked_write (tdep->ppc_vr0_regnum + 2, writebuf);
 284
 285       return RETURN_VALUE_REGISTER_CONVENTION;
 286     }
 287
 288   /* If the called subprogram returns an aggregate, there exists an
 289      implicit first argument, whose value is the address of a caller-
 290      allocated buffer into which the callee is assumed to store its
 291      return value.  All explicit parameters are appropriately
 292      relabeled.  */
 293   if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 294       || TYPE_CODE (valtype) == TYPE_CODE_UNION
 295       || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
 296     return RETURN_VALUE_STRUCT_CONVENTION;
 297
 298   /* Scalar floating-point values are returned in FPR1 for float or
 299      double, and in FPR1:FPR2 for quadword precision.  Fortran
 300      complex*8 and complex*16 are returned in FPR1:FPR2, and
 301      complex*32 is returned in FPR1:FPR4.  */
 302   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
 303       && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8))
 304     {
 305       struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
 306       gdb_byte regval[8];
 307
 308       /* FIXME: kettenis/2007-01-01: Add support for quadword
 309          precision and complex.  */
 310
 311       if (readbuf)
 312         {
 313           regcache->cooked_read (tdep->ppc_fp0_regnum + 1, regval);
 314           target_float_convert (regval, regtype, readbuf, valtype);
 315         }
 316       if (writebuf)
 317         {
 318           target_float_convert (writebuf, valtype, regval, regtype);
 319           regcache->cooked_write (tdep->ppc_fp0_regnum + 1, regval);
 320         }
 321
 322       return RETURN_VALUE_REGISTER_CONVENTION;
 323   }
 324
 325   /* Values of the types int, long, short, pointer, and char (length
 326      is less than or equal to four bytes), as well as bit values of
 327      lengths less than or equal to 32 bits, must be returned right
 328      justified in GPR3 with signed values sign extended and unsigned
 329      values zero extended, as necessary.  */
 330   if (TYPE_LENGTH (valtype) <= tdep->wordsize)
 331     {
 332       if (readbuf)
 333         {
 334           ULONGEST regval;
 335
 336           /* For reading we don't have to worry about sign extension.  */
 337           regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 338                                          &regval);
 339           store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
 340                                   regval);
 341         }
 342       if (writebuf)
 343         {
 344           /* For writing, use unpack_long since that should handle any
 345              required sign extension.  */
 346           regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
 347                                           unpack_long (valtype, writebuf));
 348         }
 349
 350       return RETURN_VALUE_REGISTER_CONVENTION;
 351     }
 352
 353   /* Eight-byte non-floating-point scalar values must be returned in
 354      GPR3:GPR4.  */
 355
 356   if (TYPE_LENGTH (valtype) == 8)
 357     {
 358       gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
 359       gdb_assert (tdep->wordsize == 4);
 360
 361       if (readbuf)
 362         {
 363           gdb_byte regval[8];
 364
 365           regcache->cooked_read (tdep->ppc_gp0_regnum + 3, regval);
 366           regcache->cooked_read (tdep->ppc_gp0_regnum + 4, regval + 4);
 367           memcpy (readbuf, regval, 8);
 368         }
 369       if (writebuf)
 370         {
 371           regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf);
 372           regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4);
 373         }
 374
 375       return RETURN_VALUE_REGISTER_CONVENTION;
 376     }
 377
 378   return RETURN_VALUE_STRUCT_CONVENTION;
 379 }
 380
 381 /* PowerPC Lynx178 OSABI sniffer.  */
 382
 383 static enum gdb_osabi
 384 rs6000_lynx178_osabi_sniffer (bfd *abfd)
 385 {
 386   if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
 387     return GDB_OSABI_UNKNOWN;
 388
 389   /* The only noticeable difference between Lynx178 XCOFF files and
 390      AIX XCOFF files comes from the fact that there are no shared
 391      libraries on Lynx178.  So if the number of import files is
 392      different from zero, it cannot be a Lynx178 binary.  */
 393   if (xcoff_get_n_import_files (abfd) != 0)
 394     return GDB_OSABI_UNKNOWN;
 395
 396   return GDB_OSABI_LYNXOS178;
 397 }
 398
 399 /* Callback for powerpc-lynx178 initialization.  */
 400
 401 static void
 402 rs6000_lynx178_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
 403 {
 404   set_gdbarch_push_dummy_call (gdbarch, rs6000_lynx178_push_dummy_call);
 405   set_gdbarch_return_value (gdbarch, rs6000_lynx178_return_value);
 406   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 407 }
 408
 409 void
 410 _initialize_rs6000_lynx178_tdep (void)
 411 {
 412   gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
 413                                   bfd_target_xcoff_flavour,
 414                                   rs6000_lynx178_osabi_sniffer);
 415   gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_LYNXOS178,
 416                           rs6000_lynx178_init_osabi);
 417 }
 418