gdb/rs6000-lynx178-tdep.c - gdb

Functions defined

Source code

  1. /* Copyright (C) 2012-2015 Free Software Foundation, Inc.

  3.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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 "value.h"
  26. #include "xcoffread.h"

  28. /* Implement the "push_dummy_call" gdbarch method.  */

  30. static CORE_ADDR
  31. ‌rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
  32.                                 struct value *function,
  33.                                 struct regcache *regcache, CORE_ADDR bp_addr,
  34.                                 int nargs, struct value **args, CORE_ADDR sp,
  35.                                 int struct_return, CORE_ADDR struct_addr)
  36. {
  37.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  38.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  39.   int ii;
  40.   int len = 0;
  41.   int argno;                        /* current argument number */
  42.   int argbytes;                        /* current argument byte */
  43.   gdb_byte tmp_buffer[50];
  44.   int f_argno = 0;                /* current floating point argno */
  45.   int wordsize = gdbarch_tdep (gdbarch)->wordsize;
  46.   CORE_ADDR func_addr = find_function_addr (function, NULL);

  48.   struct value *arg = 0;
  49.   struct type *type;

  51.   ULONGEST saved_sp;

  53.   /* The calling convention this function implements assumes the
  54.      processor has floating-point registers.  We shouldn't be using it
  55.      on PPC variants that lack them.  */
  56.   gdb_assert (ppc_floating_point_unit_p (gdbarch));

  58.   /* The first eight words of ther arguments are passed in registers.
  59.      Copy them appropriately.  */
  60.   ii = 0;

  62.   /* If the function is returning a `struct', then the first word
  63.      (which will be passed in r3) is used for struct return address.
  64.      In that case we should advance one word and start from r4
  65.      register to copy parameters.  */
  66.   if (struct_return)
  67.     {
  68.       regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
  69.                                    struct_addr);
  70.       ii++;
  71.     }

  73.   /* Effectively indirect call... gcc does...

  75.      return_val example( float, int);

  77.      eabi:
  78.      float in fp0, int in r3
  79.      offset of stack on overflow 8/16
  80.      for varargs, must go by type.
  81.      power open:
  82.      float in r3&r4, int in r5
  83.      offset of stack on overflow different
  84.      both:
  85.      return in r3 or f0.  If no float, must study how gcc emulates floats;
  86.      pay attention to arg promotion.
  87.      User may have to cast\args to handle promotion correctly
  88.      since gdb won't know if prototype supplied or not.  */

  90.   for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
  91.     {
  92.       int reg_size = register_size (gdbarch, ii + 3);

  94.       arg = args[argno];
  95.       type = check_typedef (value_type (arg));
  96.       len = TYPE_LENGTH (type);

  98.       if (TYPE_CODE (type) == TYPE_CODE_FLT)
  99.         {

  101.           /* Floating point arguments are passed in fpr's, as well as gpr's.
  102.              There are 13 fpr's reserved for passing parameters.  At this point
  103.              there is no way we would run out of them.

  105.              Always store the floating point value using the register's
  106.              floating-point format.  */
  107.           const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno;
  108.           gdb_byte reg_val[MAX_REGISTER_SIZE];
  109.           struct type *reg_type = register_type (gdbarch, fp_regnum);

  111.           gdb_assert (len <= 8);

  113.           convert_typed_floating (value_contents (arg), type,
  114.                                   reg_val, reg_type);
  115.           regcache_cooked_write (regcache, fp_regnum, reg_val);
  116.           ++f_argno;
  117.         }

  119.       if (len > reg_size)
  120.         {

  122.           /* Argument takes more than one register.  */
  123.           while (argbytes < len)
  124.             {
  125.               gdb_byte word[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 (regcache,
  132.                                     tdep->ppc_gp0_regnum + 3 + ii,
  133.                                     word);
  134.               ++ii, argbytes += reg_size;

  136.               if (ii >= 8)
  137.                 goto ran_out_of_registers_for_arguments;
  138.             }
  139.           argbytes = 0;
  140.           --ii;
  141.         }
  142.       else
  143.         {
  144.           /* Argument can fit in one register.  No problem.  */
  145.           int adj = gdbarch_byte_order (gdbarch)
  146.                     == BFD_ENDIAN_BIG ? reg_size - len : 0;
  147.           gdb_byte word[MAX_REGISTER_SIZE];

  149.           memset (word, 0, reg_size);
  150.           memcpy (word, value_contents (arg), len);
  151.           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word);
  152.         }
  153.       ++argno;
  154.     }

  156. ran_out_of_registers_for_arguments:

  158.   regcache_cooked_read_unsigned (regcache,
  159.                                  gdbarch_sp_regnum (gdbarch),
  160.                                  &saved_sp);

  162.   /* Location for 8 parameters are always reserved.  */
  163.   sp -= wordsize * 8;

  165.   /* Another six words for back chain, TOC register, link register, etc.  */
  166.   sp -= wordsize * 6;

  168.   /* Stack pointer must be quadword aligned.  */
  169.   sp = align_down (sp, 16);

  171.   /* If there are more arguments, allocate space for them in
  172.      the stack, then push them starting from the ninth one.  */

  174.   if ((argno < nargs) || argbytes)
  175.     {
  176.       int space = 0, jj;

  178.       if (argbytes)
  179.         {
  180.           space += align_up (len - argbytes, 4);
  181.           jj = argno + 1;
  182.         }
  183.       else
  184.         jj = argno;

  186.       for (; jj < nargs; ++jj)
  187.         {
  188.           struct value *val = args[jj];

  190.           space += align_up (TYPE_LENGTH (value_type (val)), 4);
  191.         }

  193.       /* Add location required for the rest of the parameters.  */
  194.       space = align_up (space, 16);
  195.       sp -= space;

  197.       /* This is another instance we need to be concerned about
  198.          securing our stack space.  If we write anything underneath %sp
  199.          (r1), we might conflict with the kernel who thinks he is free
  200.          to use this area.  So, update %sp first before doing anything
  201.          else.  */

  203.       regcache_raw_write_signed (regcache,
  204.                                  gdbarch_sp_regnum (gdbarch), sp);

  206.       /* If the last argument copied into the registers didn't fit there
  207.          completely, push the rest of it into stack.  */

  209.       if (argbytes)
  210.         {
  211.           write_memory (sp + 24 + (ii * 4),
  212.                         value_contents (arg) + argbytes,
  213.                         len - argbytes);
  214.           ++argno;
  215.           ii += align_up (len - argbytes, 4) / 4;
  216.         }

  218.       /* Push the rest of the arguments into stack.  */
  219.       for (; argno < nargs; ++argno)
  220.         {

  222.           arg = args[argno];
  223.           type = check_typedef (value_type (arg));
  224.           len = TYPE_LENGTH (type);


  227.           /* Float types should be passed in fpr's, as well as in the
  228.              stack.  */
  229.           if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
  230.             {

  232.               gdb_assert (len <= 8);

  234.               regcache_cooked_write (regcache,
  235.                                      tdep->ppc_fp0_regnum + 1 + f_argno,
  236.                                      value_contents (arg));
  237.               ++f_argno;
  238.             }

  240.           write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
  241.           ii += align_up (len, 4) / 4;
  242.         }
  243.     }

  245.   /* Set the stack pointer.  According to the ABI, the SP is meant to
  246.      be set _before_ the corresponding stack space is used.  On AIX,
  247.      this even applies when the target has been completely stopped!
  248.      Not doing this can lead to conflicts with the kernel which thinks
  249.      that it still has control over this not-yet-allocated stack
  250.      region.  */
  251.   regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);

  253.   /* Set back chain properly.  */
  254.   store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
  255.   write_memory (sp, tmp_buffer, wordsize);

  257.   /* Point the inferior function call's return address at the dummy's
  258.      breakpoint.  */
  259.   regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);

  261.   target_store_registers (regcache, -1);
  262.   return sp;
  263. }

  265. /* Implement the "return_value" gdbarch method.  */

  267. static enum return_value_convention
  268. ‌rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function,
  269.                              struct type *valtype, struct regcache *regcache,
  270.                              gdb_byte *readbuf, const gdb_byte *writebuf)
  271. {
  272.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  273.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

  275.   /* The calling convention this function implements assumes the
  276.      processor has floating-point registers.  We shouldn't be using it
  277.      on PowerPC variants that lack them.  */
  278.   gdb_assert (ppc_floating_point_unit_p (gdbarch));

  280.   /* AltiVec extension: Functions that declare a vector data type as a
  281.      return value place that return value in VR2.  */
  282.   if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
  283.       && TYPE_LENGTH (valtype) == 16)
  284.     {
  285.       if (readbuf)
  286.         regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
  287.       if (writebuf)
  288.         regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);

  290.       return RETURN_VALUE_REGISTER_CONVENTION;
  291.     }

  293.   /* If the called subprogram returns an aggregate, there exists an
  294.      implicit first argument, whose value is the address of a caller-
  295.      allocated buffer into which the callee is assumed to store its
  296.      return value.  All explicit parameters are appropriately
  297.      relabeled.  */
  298.   if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
  299.       || TYPE_CODE (valtype) == TYPE_CODE_UNION
  300.       || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
  301.     return RETURN_VALUE_STRUCT_CONVENTION;

  303.   /* Scalar floating-point values are returned in FPR1 for float or
  304.      double, and in FPR1:FPR2 for quadword precision.  Fortran
  305.      complex*8 and complex*16 are returned in FPR1:FPR2, and
  306.      complex*32 is returned in FPR1:FPR4.  */
  307.   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
  308.       && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8))
  309.     {
  310.       struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
  311.       gdb_byte regval[8];

  313.       /* FIXME: kettenis/2007-01-01: Add support for quadword
  314.          precision and complex.  */

  316.       if (readbuf)
  317.         {
  318.           regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
  319.           convert_typed_floating (regval, regtype, readbuf, valtype);
  320.         }
  321.       if (writebuf)
  322.         {
  323.           convert_typed_floating (writebuf, valtype, regval, regtype);
  324.           regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
  325.         }

  327.       return RETURN_VALUE_REGISTER_CONVENTION;
  328.   }

  330.   /* Values of the types int, long, short, pointer, and char (length
  331.      is less than or equal to four bytes), as well as bit values of
  332.      lengths less than or equal to 32 bits, must be returned right
  333.      justified in GPR3 with signed values sign extended and unsigned
  334.      values zero extended, as necessary.  */
  335.   if (TYPE_LENGTH (valtype) <= tdep->wordsize)
  336.     {
  337.       if (readbuf)
  338.         {
  339.           ULONGEST regval;

  341.           /* For reading we don't have to worry about sign extension.  */
  342.           regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
  343.                                          &regval);
  344.           store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
  345.                                   regval);
  346.         }
  347.       if (writebuf)
  348.         {
  349.           /* For writing, use unpack_long since that should handle any
  350.              required sign extension.  */
  351.           regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
  352.                                           unpack_long (valtype, writebuf));
  353.         }

  355.       return RETURN_VALUE_REGISTER_CONVENTION;
  356.     }

  358.   /* Eight-byte non-floating-point scalar values must be returned in
  359.      GPR3:GPR4.  */

  361.   if (TYPE_LENGTH (valtype) == 8)
  362.     {
  363.       gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
  364.       gdb_assert (tdep->wordsize == 4);

  366.       if (readbuf)
  367.         {
  368.           gdb_byte regval[8];

  370.           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regval);
  371.           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
  372.                                 regval + 4);
  373.           memcpy (readbuf, regval, 8);
  374.         }
  375.       if (writebuf)
  376.         {
  377.           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
  378.           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
  379.                                  writebuf + 4);
  380.         }

  382.       return RETURN_VALUE_REGISTER_CONVENTION;
  383.     }

  385.   return RETURN_VALUE_STRUCT_CONVENTION;
  386. }

  388. /* PowerPC Lynx178 OSABI sniffer.  */

  390. static enum gdb_osabi
  391. ‌rs6000_lynx178_osabi_sniffer (bfd *abfd)
  392. {
  393.   if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
  394.     return GDB_OSABI_UNKNOWN;

  396.   /* The only noticeable difference between Lynx178 XCOFF files and
  397.      AIX XCOFF files comes from the fact that there are no shared
  398.      libraries on Lynx178.  So if the number of import files is
  399.      different from zero, it cannot be a Lynx178 binary.  */
  400.   if (xcoff_get_n_import_files (abfd) != 0)
  401.     return GDB_OSABI_UNKNOWN;

  403.   return GDB_OSABI_LYNXOS178;
  404. }

  406. /* Callback for powerpc-lynx178 initialization.  */

  408. static void
  409. ‌rs6000_lynx178_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
  410. {
  411.   set_gdbarch_push_dummy_call (gdbarch, rs6000_lynx178_push_dummy_call);
  412.   set_gdbarch_return_value (gdbarch, rs6000_lynx178_return_value);
  413.   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
  414. }

  416. /* -Wmissing-prototypes.  */
  417. extern initialize_file_ftype _initialize_rs6000_lynx178_tdep;

  419. void
  420. ‌_initialize_rs6000_lynx178_tdep (void)
  421. {
  422.   gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
  423.                                   bfd_target_xcoff_flavour,
  424.                                   rs6000_lynx178_osabi_sniffer);
  425.   gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_LYNXOS178,
  426.                           rs6000_lynx178_init_osabi);
  427. }