/* -*- mode: C; c-basic-offset: 3; -*- */

/*---------------------------------------------------------------*/
/*--- begin                                  host_s390_defs.h ---*/
/*---------------------------------------------------------------*/

/*
   This file is part of Valgrind, a dynamic binary instrumentation
   framework.

   Copyright IBM Corp. 2010-2015

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301, USA.

   The GNU General Public License is contained in the file COPYING.
*/

/* Contributed by Florian Krohm */

#ifndef __VEX_HOST_S390_DEFS_H
#define __VEX_HOST_S390_DEFS_H

#include "libvex_basictypes.h"            /* Bool */
#include "libvex.h"                       /* VexArchInfo */
#include "host_generic_regs.h"            /* HReg */
#include "s390_defs.h"                    /* s390_cc_t */

/* --------- Registers --------- */
const HChar *s390_hreg_as_string(HReg);
HReg s390_hreg_gpr(UInt regno);
HReg s390_hreg_fpr(UInt regno);

/* Dedicated registers */
HReg s390_hreg_guest_state_pointer(void);


/* Given the index of a function argument, return the number of the
   general purpose register in which it is being passed. Arguments are
   counted 0, 1, 2, ... and they are being passed in r2, r3, r4, ... */
static __inline__ UInt
s390_gprno_from_arg_index(UInt ix)
{
   return ix + 2;
}

/* --------- Memory address expressions (amodes). --------- */

/* These are the address modes:
   (1) b12:  base register + 12-bit unsigned offset   (e.g. RS)
   (2) b20:  base register + 20-bit signed offset     (e.g. RSY)
   (3) bx12: base register + index register + 12-bit unsigned offset (e.g. RX)
   (4) bx20: base register + index register + 20-bit signed offset   (e.g. RXY)
   fixs390: There is also pc-relative stuff.. e.g. LARL
*/

typedef enum {
   S390_AMODE_B12,
   S390_AMODE_B20,
   S390_AMODE_BX12,
   S390_AMODE_BX20
} s390_amode_t;

typedef struct {
   s390_amode_t tag;
   HReg b;
   HReg x;       /* hregNumber(x) == 0  for S390_AMODE_B12/B20 kinds */
   Int  d;       /* 12 bit unsigned or 20 bit signed */
} s390_amode;


s390_amode *s390_amode_b12(Int d, HReg b);
s390_amode *s390_amode_b20(Int d, HReg b);
s390_amode *s390_amode_bx12(Int d, HReg b, HReg x);
s390_amode *s390_amode_bx20(Int d, HReg b, HReg x);
s390_amode *s390_amode_for_guest_state(Int d);
Bool        s390_amode_is_sane(const s390_amode *);

const HChar *s390_amode_as_string(const s390_amode *);

/* ------------- 2nd (right) operand of binary operation ---------------- */

typedef enum {
   S390_OPND_REG,
   S390_OPND_IMMEDIATE,
   S390_OPND_AMODE
} s390_opnd_t;


/* Naming convention for operand locations:
   R    - GPR
   I    - immediate value
   M    - memory (any Amode may be used)
*/

/* An operand that is either in a GPR or is addressable via a BX20 amode */
typedef struct {
   s390_opnd_t tag;
   union {
      HReg        reg;
      s390_amode *am;
      ULong       imm;
   } variant;
} s390_opnd_RMI;


/* The kind of instructions */
typedef enum {
   S390_INSN_LOAD,   /* load register from memory */
   S390_INSN_STORE,  /* store register to memory */
   S390_INSN_MOVE,   /* from register to register */
   S390_INSN_MEMCPY, /* from memory to memory */
   S390_INSN_COND_MOVE, /* conditonal "move" to register */
   S390_INSN_LOAD_IMMEDIATE,
   S390_INSN_ALU,
   S390_INSN_SMUL,   /*   signed multiply; n-bit operands; 2n-bit result */
   S390_INSN_UMUL,   /* unsigned multiply; n-bit operands; 2n-bit result */
   S390_INSN_SDIV,   /*   signed division; 2n-bit / n-bit -> n-bit quot/rem */
   S390_INSN_UDIV,   /* unsigned division; 2n-bit / n-bit -> n-bit quot/rem */
   S390_INSN_DIVS,   /* n-bit dividend; n-bit divisor; n-bit quot/rem */
   S390_INSN_CLZ,    /* count left-most zeroes */
   S390_INSN_UNOP,
   S390_INSN_TEST,   /* test operand and set cc */
   S390_INSN_CC2BOOL,/* convert condition code to 0/1 */
   S390_INSN_COMPARE,
   S390_INSN_HELPER_CALL,
   S390_INSN_CAS,    /* compare and swap */
   S390_INSN_CDAS,   /* compare double and swap */
   S390_INSN_BFP_BINOP, /* Binary floating point */
   S390_INSN_BFP_UNOP,
   S390_INSN_BFP_TRIOP,
   S390_INSN_BFP_COMPARE,
   S390_INSN_BFP_CONVERT,
   S390_INSN_DFP_BINOP, /* Decimal floating point */
   S390_INSN_DFP_UNOP,
   S390_INSN_DFP_INTOP,
   S390_INSN_DFP_COMPARE,
   S390_INSN_DFP_CONVERT,
   S390_INSN_DFP_REROUND,
   S390_INSN_FP_CONVERT,
   S390_INSN_MFENCE,
   S390_INSN_MIMM,    /* Assign an immediate constant to a memory location */
   S390_INSN_MADD,    /* Add a value to a memory location */
   S390_INSN_SET_FPC_BFPRM, /* Set the bfp rounding mode in the FPC */
   S390_INSN_SET_FPC_DFPRM, /* Set the dfp rounding mode in the FPC */
   /* The following 5 insns are mandated by translation chaining */
   S390_INSN_XDIRECT,     /* direct transfer to guest address */
   S390_INSN_XINDIR,      /* indirect transfer to guest address */
   S390_INSN_XASSISTED,   /* assisted transfer to guest address */
   S390_INSN_EVCHECK,     /* Event check */
   S390_INSN_PROFINC      /* 64-bit profile counter increment */
} s390_insn_tag;


/* The kind of ALU instructions */
typedef enum {
   S390_ALU_ADD,
   S390_ALU_SUB,
   S390_ALU_MUL,   /* n-bit operands; result is lower n-bit of product */
   S390_ALU_AND,
   S390_ALU_OR,
   S390_ALU_XOR,
   S390_ALU_LSH,
   S390_ALU_RSH,
   S390_ALU_RSHA   /* arithmetic */
} s390_alu_t;


/* The kind of unary integer operations */
typedef enum {
   S390_ZERO_EXTEND_8,
   S390_ZERO_EXTEND_16,
   S390_ZERO_EXTEND_32,
   S390_SIGN_EXTEND_8,
   S390_SIGN_EXTEND_16,
   S390_SIGN_EXTEND_32,
   S390_NEGATE
} s390_unop_t;

/* The kind of ternary BFP operations */
typedef enum {
   S390_BFP_MADD,
   S390_BFP_MSUB,
} s390_bfp_triop_t;

/* The kind of binary BFP operations */
typedef enum {
   S390_BFP_ADD,
   S390_BFP_SUB,
   S390_BFP_MUL,
   S390_BFP_DIV
} s390_bfp_binop_t;

/* The kind of unary BFP operations */
typedef enum {
   S390_BFP_ABS,
   S390_BFP_NABS,
   S390_BFP_NEG,
   S390_BFP_SQRT
} s390_bfp_unop_t;

/* Type conversion operations: to and/or from binary floating point */
typedef enum {
   S390_BFP_I32_TO_F32,
   S390_BFP_I32_TO_F64,
   S390_BFP_I32_TO_F128,
   S390_BFP_I64_TO_F32,
   S390_BFP_I64_TO_F64,
   S390_BFP_I64_TO_F128,
   S390_BFP_U32_TO_F32,
   S390_BFP_U32_TO_F64,
   S390_BFP_U32_TO_F128,
   S390_BFP_U64_TO_F32,
   S390_BFP_U64_TO_F64,
   S390_BFP_U64_TO_F128,
   S390_BFP_F32_TO_I32,
   S390_BFP_F32_TO_I64,
   S390_BFP_F32_TO_U32,
   S390_BFP_F32_TO_U64,
   S390_BFP_F32_TO_F64,
   S390_BFP_F32_TO_F128,
   S390_BFP_F64_TO_I32,
   S390_BFP_F64_TO_I64,
   S390_BFP_F64_TO_U32,
   S390_BFP_F64_TO_U64,
   S390_BFP_F64_TO_F32,
   S390_BFP_F64_TO_F128,
   S390_BFP_F128_TO_I32,
   S390_BFP_F128_TO_I64,
   S390_BFP_F128_TO_U32,
   S390_BFP_F128_TO_U64,
   S390_BFP_F128_TO_F32,
   S390_BFP_F128_TO_F64,
   S390_BFP_F32_TO_F32I,
   S390_BFP_F64_TO_F64I,
   S390_BFP_F128_TO_F128I
} s390_bfp_conv_t;

/* Type conversion operations: to and/or from decimal floating point */
typedef enum {
   S390_DFP_D32_TO_D64,
   S390_DFP_D64_TO_D32,
   S390_DFP_D64_TO_D128,
   S390_DFP_D128_TO_D64,
   S390_DFP_I32_TO_D64,
   S390_DFP_I32_TO_D128,
   S390_DFP_I64_TO_D64,
   S390_DFP_I64_TO_D128,
   S390_DFP_U32_TO_D64,
   S390_DFP_U32_TO_D128,
   S390_DFP_U64_TO_D64,
   S390_DFP_U64_TO_D128,
   S390_DFP_D64_TO_I32,
   S390_DFP_D64_TO_I64,
   S390_DFP_D64_TO_U32,
   S390_DFP_D64_TO_U64,
   S390_DFP_D128_TO_I32,
   S390_DFP_D128_TO_I64,
   S390_DFP_D128_TO_U32,
   S390_DFP_D128_TO_U64
} s390_dfp_conv_t;

typedef enum {
   S390_FP_F32_TO_D32,
   S390_FP_F32_TO_D64,
   S390_FP_F32_TO_D128,
   S390_FP_F64_TO_D32,
   S390_FP_F64_TO_D64,
   S390_FP_F64_TO_D128,
   S390_FP_F128_TO_D32,
   S390_FP_F128_TO_D64,
   S390_FP_F128_TO_D128,
   S390_FP_D32_TO_F32,
   S390_FP_D32_TO_F64,
   S390_FP_D32_TO_F128,
   S390_FP_D64_TO_F32,
   S390_FP_D64_TO_F64,
   S390_FP_D64_TO_F128,
   S390_FP_D128_TO_F32,
   S390_FP_D128_TO_F64,
   S390_FP_D128_TO_F128
} s390_fp_conv_t;

/* The kind of binary DFP operations */
typedef enum {
   S390_DFP_ADD,
   S390_DFP_SUB,
   S390_DFP_MUL,
   S390_DFP_DIV,
   S390_DFP_QUANTIZE
} s390_dfp_binop_t;

/* The kind of unary DFP operations */
typedef enum {
   S390_DFP_EXTRACT_EXP_D64,
   S390_DFP_EXTRACT_EXP_D128,
   S390_DFP_EXTRACT_SIG_D64,
   S390_DFP_EXTRACT_SIG_D128,
} s390_dfp_unop_t;

/* The DFP operations with 2 operands one of them being integer */
typedef enum {
   S390_DFP_SHIFT_LEFT,
   S390_DFP_SHIFT_RIGHT,
   S390_DFP_INSERT_EXP
} s390_dfp_intop_t;

/* The kind of DFP compare operations */
typedef enum {
   S390_DFP_COMPARE,
   S390_DFP_COMPARE_EXP,
} s390_dfp_cmp_t;

/* The details of a CDAS insn. Carved out to keep the size of
   s390_insn low */
typedef struct {
   HReg        op1_high;
   HReg        op1_low;
   s390_amode *op2;
   HReg        op3_high;
   HReg        op3_low;
   HReg        old_mem_high;
   HReg        old_mem_low;
   HReg        scratch;
} s390_cdas;

/* The details of a binary DFP insn. Carved out to keep the size of
   s390_insn low */
typedef struct {
   s390_dfp_binop_t tag;
   s390_dfp_round_t rounding_mode;
   HReg         dst_hi; /* 128-bit result high part; 64-bit result */
   HReg         dst_lo; /* 128-bit result low part */
   HReg         op2_hi; /* 128-bit operand high part; 64-bit opnd 1 */
   HReg         op2_lo; /* 128-bit operand low part */
   HReg         op3_hi; /* 128-bit operand high part; 64-bit opnd 2 */
   HReg         op3_lo; /* 128-bit operand low part */
} s390_dfp_binop;

typedef struct {
   s390_fp_conv_t  tag;
   s390_dfp_round_t rounding_mode;
   HReg         dst_hi; /* 128-bit result high part; 32/64-bit result */
   HReg         dst_lo; /* 128-bit result low part */
   HReg         op_hi;  /* 128-bit operand high part; 32/64-bit opnd */
   HReg         op_lo;  /* 128-bit operand low part */
   HReg         r1;     /* clobbered register GPR #1 */
} s390_fp_convert;

/* Pseudo-insn for representing a helper call.
   TARGET is the absolute address of the helper function
   NUM_ARGS says how many arguments are being passed.
   All arguments have integer type and are being passed according to ABI,
   i.e. in registers r2, r3, r4, r5, and r6, with argument #0 being
   passed in r2 and so forth. */
typedef struct {
   s390_cc_t    cond     : 16;
   UInt         num_args : 16;
   RetLoc       rloc;     /* where the return value will be */
   Addr64       target;
   const HChar *name;      /* callee's name (for debugging) */
} s390_helper_call;

typedef struct {
   s390_insn_tag tag;
   /* Usually, this is the size of the result of an operation.
      Exceptions are:
      - for comparisons it is the size of the operand
   */
   UChar size;
   union {
      struct {
         HReg        dst;
         s390_amode *src;
      } load;
      struct {
         s390_amode *dst;
         HReg        src;
      } store;
      struct {
         HReg        dst;
         HReg        src;
      } move;
      struct {
         s390_amode *dst;
         s390_amode *src;
      } memcpy;
      struct {
         s390_cc_t     cond;
         HReg          dst;
         s390_opnd_RMI src;
      } cond_move;
      struct {
         HReg        dst;
         ULong       value;  /* not sign extended */
      } load_immediate;
      /* add, and, or, xor */
      struct {
         s390_alu_t    tag;
         HReg          dst; /* op1 */
         s390_opnd_RMI op2;
      } alu;
      struct {
         HReg          dst_hi;  /*           r10 */
         HReg          dst_lo;  /* also op1  r11 */
         s390_opnd_RMI op2;
      } mul;
      struct {
         HReg          op1_hi;  /* also remainder   r10 */
         HReg          op1_lo;  /* also quotient    r11 */
         s390_opnd_RMI op2;
      } div;
      struct {
         HReg          rem; /* remainder      r10 */
         HReg          op1; /* also quotient  r11 */
         s390_opnd_RMI op2;
      } divs;
      struct {
         HReg          num_bits; /* number of leftmost '0' bits  r10 */
         HReg          clobber;  /* unspecified                  r11 */
         s390_opnd_RMI src;
      } clz;
      struct {
         s390_unop_t   tag;
         HReg          dst;
         s390_opnd_RMI src;
      } unop;
      struct {
         Bool          signed_comparison;
         HReg          src1;
         s390_opnd_RMI src2;
      } compare;
      struct {
         s390_opnd_RMI src;
      } test;
      /* Convert the condition code to a boolean value. */
      struct {
         s390_cc_t cond;
         HReg      dst;
      } cc2bool;
      struct {
         HReg        op1;
         s390_amode *op2;
         HReg        op3;
         HReg        old_mem;
      } cas;
      struct {
         s390_cdas *details;
      } cdas;
      struct {
         s390_helper_call *details;
      } helper_call;

      /* Floating point instructions (including conversion to/from floating
         point

         128-bit floating point requires register pairs. As the registers
         in a register pair cannot be chosen independently it would suffice
         to store only one register of the pair in order to represent it.
         We chose not to do that as being explicit about all registers
         helps with debugging and does not require special handling in 
         e.g. s390_insn_get_reg_usage, It'd be all too easy to forget about
         the "other" register in a pair if it is implicit.

         The convention for all fp s390_insn is that the _hi register will
         be used to store the result / operand of a 32/64-bit operation.
         The _hi register holds the  8 bytes of HIgher significance of a
         128-bit value (hence the suffix). However, it is the lower numbered
         register of a register pair. POP says that the lower numbered
         register is used to identify the pair in an insn encoding. So,
         when an insn is emitted, only the _hi registers need to be looked
         at. Nothing special is needed for 128-bit BFP which is nice.
      */

      /* There are currently no ternary 128-bit BFP operations. */
      struct {
         s390_bfp_triop_t tag;
         HReg         dst;
         HReg         op2;
         HReg         op3;
      } bfp_triop;
      struct {
         s390_bfp_binop_t tag;
         HReg         dst_hi; /* 128-bit result high part; 32/64-bit result */
         HReg         dst_lo; /* 128-bit result low part */
         HReg         op2_hi; /* 128-bit operand high part; 32/64-bit opnd */
         HReg         op2_lo; /* 128-bit operand low part */
      } bfp_binop;
      struct {
         s390_bfp_unop_t  tag;
         HReg         dst_hi; /* 128-bit result high part; 32/64-bit result */
         HReg         dst_lo; /* 128-bit result low part */
         HReg         op_hi;  /* 128-bit operand high part; 32/64-bit opnd */
         HReg         op_lo;  /* 128-bit operand low part */
      } bfp_unop;
      struct {
         s390_bfp_conv_t  tag;
         s390_bfp_round_t rounding_mode;
         HReg         dst_hi; /* 128-bit result high part; 32/64-bit result */
         HReg         dst_lo; /* 128-bit result low part */
         HReg         op_hi;  /* 128-bit operand high part; 32/64-bit opnd */
         HReg         op_lo;  /* 128-bit operand low part */
      } bfp_convert;
      struct {
         HReg         dst;     /* condition code in s390 encoding */
         HReg         op1_hi;  /* 128-bit operand high part; 32/64-bit opnd */
         HReg         op1_lo;  /* 128-bit operand low part */
         HReg         op2_hi;  /* 128-bit operand high part; 32/64-bit opnd */
         HReg         op2_lo;  /* 128-bit operand low part */
      } bfp_compare;
      struct {
         s390_dfp_binop *details;
      } dfp_binop;
      struct {
         s390_dfp_unop_t tag;
         HReg         dst_hi; /* 128-bit result high part; 64-bit result */
         HReg         dst_lo; /* 128-bit result low part */
         HReg         op_hi;  /* 128-bit operand high part; 64-bit opnd */
         HReg         op_lo;  /* 128-bit operand low part */
      } dfp_unop;
      struct {
         s390_dfp_intop_t tag;
         HReg         dst_hi; /* 128-bit result high part; 64-bit result */
         HReg         dst_lo; /* 128-bit result low part */
         HReg         op2;    /* integer operand */
         HReg         op3_hi; /* 128-bit operand high part; 64-bit opnd */
         HReg         op3_lo; /* 128-bit operand low part */
      } dfp_intop;
      struct {
         s390_dfp_conv_t  tag;
         s390_dfp_round_t rounding_mode;
         HReg         dst_hi; /* 128-bit result high part; 64-bit result */
         HReg         dst_lo; /* 128-bit result low part */
         HReg         op_hi;  /* 128-bit operand high part; 64-bit opnd */
         HReg         op_lo;  /* 128-bit operand low part */
      } dfp_convert;
      struct {
         s390_fp_convert *details;
      } fp_convert;
      struct {
         s390_dfp_cmp_t tag;
         HReg         dst;     /* condition code in s390 encoding */
         HReg         op1_hi;  /* 128-bit operand high part; 64-bit opnd 1 */
         HReg         op1_lo;  /* 128-bit operand low part */
         HReg         op2_hi;  /* 128-bit operand high part; 64-bit opnd 2 */
         HReg         op2_lo;  /* 128-bit operand low part */
      } dfp_compare;
      struct {
         s390_dfp_round_t rounding_mode;
         HReg         dst_hi; /* 128-bit result high part; 64-bit result */
         HReg         dst_lo; /* 128-bit result low part */
         HReg         op2;    /* integer operand */
         HReg         op3_hi; /* 128-bit operand high part; 64-bit opnd */
         HReg         op3_lo; /* 128-bit operand low part */
      } dfp_reround;

      /* Miscellaneous */
      struct {
         s390_amode      *dst;
         ULong            value;  /* sign extended */
      } mimm;
      struct {
         s390_amode      *dst;
         UChar            delta;
         ULong            value;  /* for debugging only */
      } madd;
      struct {
         HReg             mode;
      } set_fpc_bfprm;
      struct {
         HReg             mode;
      } set_fpc_dfprm;

      /* The next 5 entries are generic to support translation chaining */

      /* Update the guest IA value, then exit requesting to chain
         to it.  May be conditional. */
      struct {
         s390_cc_t     cond;
         Bool          to_fast_entry;  /* chain to the what entry point? */
         Addr64        dst;            /* next guest address */
         s390_amode   *guest_IA;
      } xdirect;
      /* Boring transfer to a guest address not known at JIT time.
         Not chainable.  May be conditional. */
      struct {
         s390_cc_t     cond;
         HReg          dst;
         s390_amode   *guest_IA;
      } xindir;
      /* Assisted transfer to a guest address, most general case.
         Not chainable.  May be conditional. */
      struct {
         s390_cc_t     cond;
         IRJumpKind    kind;
         HReg          dst;
         s390_amode   *guest_IA;
      } xassisted;
      struct {
         /* fixs390: I don't think these are really needed
            as the gsp and the offset are fixed  no ? */
         s390_amode   *counter;    /* dispatch counter */
         s390_amode   *fail_addr;
      } evcheck;
      struct {
         /* No fields.  The address of the counter to increment is
            installed later, post-translation, by patching it in,
            as it is not known at translation time. */
		Int nop;
      } profinc;

   } variant;
} s390_insn;

s390_insn *s390_insn_load(UChar size, HReg dst, s390_amode *src);
s390_insn *s390_insn_store(UChar size, s390_amode *dst, HReg src);
s390_insn *s390_insn_move(UChar size, HReg dst, HReg src);
s390_insn *s390_insn_memcpy(UChar size, s390_amode *dst, s390_amode *src);
s390_insn *s390_insn_cond_move(UChar size, s390_cc_t cond, HReg dst,
                               s390_opnd_RMI src);
s390_insn *s390_insn_load_immediate(UChar size, HReg dst, ULong val);
s390_insn *s390_insn_alu(UChar size, s390_alu_t, HReg dst,
                         s390_opnd_RMI op2);
s390_insn *s390_insn_mul(UChar size, HReg dst_hi, HReg dst_lo,
                         s390_opnd_RMI op2, Bool signed_multiply);
s390_insn *s390_insn_div(UChar size, HReg op1_hi, HReg op1_lo,
                         s390_opnd_RMI op2, Bool signed_divide);
s390_insn *s390_insn_divs(UChar size, HReg rem, HReg op1, s390_opnd_RMI op2);
s390_insn *s390_insn_clz(UChar size, HReg num_bits, HReg clobber,
                         s390_opnd_RMI op);
s390_insn *s390_insn_cas(UChar size, HReg op1, s390_amode *op2, HReg op3,
                         HReg old);
s390_insn *s390_insn_cdas(UChar size, HReg op1_high, HReg op1_low,
                          s390_amode *op2, HReg op3_high, HReg op3_low,
                          HReg old_high, HReg old_low, HReg scratch);
s390_insn *s390_insn_unop(UChar size, s390_unop_t tag, HReg dst,
                          s390_opnd_RMI opnd);
s390_insn *s390_insn_cc2bool(HReg dst, s390_cc_t src);
s390_insn *s390_insn_test(UChar size, s390_opnd_RMI src);
s390_insn *s390_insn_compare(UChar size, HReg dst, s390_opnd_RMI opnd,
                             Bool signed_comparison);
s390_insn *s390_insn_helper_call(s390_cc_t cond, Addr64 target, UInt num_args,
                                 const HChar *name, RetLoc rloc);
s390_insn *s390_insn_bfp_triop(UChar size, s390_bfp_triop_t, HReg dst,
                               HReg op2, HReg op3);
s390_insn *s390_insn_bfp_binop(UChar size, s390_bfp_binop_t, HReg dst,
                               HReg op2);
s390_insn *s390_insn_bfp_unop(UChar size, s390_bfp_unop_t tag, HReg dst,
                              HReg op);
s390_insn *s390_insn_bfp_compare(UChar size, HReg dst, HReg op1, HReg op2);
s390_insn *s390_insn_bfp_convert(UChar size, s390_bfp_conv_t tag, HReg dst,
                                 HReg op, s390_bfp_round_t);
s390_insn *s390_insn_bfp128_convert(UChar size, s390_bfp_conv_t tag, HReg dst_hi,
                                    HReg dst_lo, HReg op_hi, HReg op_lo,
                                    s390_bfp_round_t rounding_mode);
s390_insn *s390_insn_bfp128_binop(UChar size, s390_bfp_binop_t, HReg dst_hi,
                                  HReg dst_lo, HReg op2_hi, HReg op2_lo);
s390_insn *s390_insn_bfp128_unop(UChar size, s390_bfp_unop_t, HReg dst_hi,
                                 HReg dst_lo, HReg op_hi, HReg op_lo);
s390_insn *s390_insn_bfp128_compare(UChar size, HReg dst, HReg op1_hi,
                                    HReg op1_lo, HReg op2_hi, HReg op2_lo);
s390_insn *s390_insn_bfp128_convert_to(UChar size, s390_bfp_conv_t,
                                       HReg dst_hi, HReg dst_lo, HReg op);
s390_insn *s390_insn_bfp128_convert_from(UChar size, s390_bfp_conv_t,
                                         HReg dst_hi, HReg dst_lo, HReg op_hi,
                                         HReg op_lo, s390_bfp_round_t);
s390_insn *s390_insn_dfp_binop(UChar size, s390_dfp_binop_t, HReg dst,
                               HReg op2, HReg op3,
                               s390_dfp_round_t rounding_mode);
s390_insn *s390_insn_dfp_unop(UChar size, s390_dfp_unop_t, HReg dst, HReg op);
s390_insn *s390_insn_dfp_intop(UChar size, s390_dfp_intop_t, HReg dst,
                               HReg op2, HReg op3);
s390_insn *s390_insn_dfp_compare(UChar size, s390_dfp_cmp_t, HReg dst,
                                 HReg op1, HReg op2);
s390_insn *s390_insn_dfp_convert(UChar size, s390_dfp_conv_t tag, HReg dst,
                                 HReg op, s390_dfp_round_t);
s390_insn *s390_insn_dfp_reround(UChar size, HReg dst, HReg op2, HReg op3,
                                 s390_dfp_round_t);
s390_insn *s390_insn_fp_convert(UChar size, s390_fp_conv_t tag,
                                HReg dst, HReg op, HReg r1, s390_dfp_round_t);
s390_insn *s390_insn_fp128_convert(UChar size, s390_fp_conv_t tag,
                                   HReg dst_hi, HReg dst_lo, HReg op_hi,
                                   HReg op_lo, HReg r1, s390_dfp_round_t);
s390_insn *s390_insn_dfp128_binop(UChar size, s390_dfp_binop_t, HReg dst_hi,
                                  HReg dst_lo, HReg op2_hi, HReg op2_lo,
                                  HReg op3_hi, HReg op3_lo,
                                  s390_dfp_round_t rounding_mode);
s390_insn *s390_insn_dfp128_unop(UChar size, s390_dfp_unop_t, HReg dst,
                                 HReg op_hi, HReg op_lo);
s390_insn *s390_insn_dfp128_intop(UChar size, s390_dfp_intop_t, HReg dst_hi,
                                  HReg dst_lo, HReg op2,
                                  HReg op3_hi, HReg op3_lo);
s390_insn *s390_insn_dfp128_compare(UChar size, s390_dfp_cmp_t, HReg dst,
                                    HReg op1_hi, HReg op1_lo, HReg op2_hi,
                                    HReg op2_lo);
s390_insn *s390_insn_dfp128_convert_to(UChar size, s390_dfp_conv_t,
                                       HReg dst_hi, HReg dst_lo, HReg op);
s390_insn *s390_insn_dfp128_convert_from(UChar size, s390_dfp_conv_t,
                                         HReg dst_hi, HReg dst_lo, HReg op_hi,
                                         HReg op_lo, s390_dfp_round_t);
s390_insn *s390_insn_dfp128_reround(UChar size, HReg dst_hi, HReg dst_lo,
                                    HReg op2, HReg op3_hi, HReg op3_lo,
                                    s390_dfp_round_t);
s390_insn *s390_insn_mfence(void);
s390_insn *s390_insn_mimm(UChar size, s390_amode *dst, ULong value);
s390_insn *s390_insn_madd(UChar size, s390_amode *dst, UChar delta,
                          ULong value);
s390_insn *s390_insn_set_fpc_bfprm(UChar size, HReg mode);
s390_insn *s390_insn_set_fpc_dfprm(UChar size, HReg mode);

/* Five for translation chaining */
s390_insn *s390_insn_xdirect(s390_cc_t cond, Addr64 dst, s390_amode *guest_IA,
                             Bool to_fast_entry);
s390_insn *s390_insn_xindir(s390_cc_t cond, HReg dst, s390_amode *guest_IA);
s390_insn *s390_insn_xassisted(s390_cc_t cond, HReg dst, s390_amode *guest_IA,
                               IRJumpKind kind);
s390_insn *s390_insn_evcheck(s390_amode *counter, s390_amode *fail_addr);
s390_insn *s390_insn_profinc(void);

const HChar *s390_insn_as_string(const s390_insn *);

/*--------------------------------------------------------*/
/* --- Interface exposed to VEX                       --- */
/*--------------------------------------------------------*/

void ppS390AMode(const s390_amode *);
void ppS390Instr(const s390_insn *, Bool mode64);
void ppHRegS390(HReg);

/* Some functions that insulate the register allocator from details
   of the underlying instruction set. */
void  getRegUsage_S390Instr( HRegUsage *, const s390_insn *, Bool );
void  mapRegs_S390Instr    ( HRegRemap *, s390_insn *, Bool );
Bool  isMove_S390Instr     ( const s390_insn *, HReg *, HReg * );
Int   emit_S390Instr       ( Bool *, UChar *, Int, const s390_insn *, Bool,
                             VexEndness, const void *, const void *,
                             const void *, const void *);
const RRegUniverse *getRRegUniverse_S390( void );
void  genSpill_S390        ( HInstr **, HInstr **, HReg , Int , Bool );
void  genReload_S390       ( HInstr **, HInstr **, HReg , Int , Bool );
HInstrArray *iselSB_S390   ( const IRSB *, VexArch, const VexArchInfo *,
                             const VexAbiInfo *, Int, Int, Bool, Bool, Addr);

/* Return the number of bytes of code needed for an event check */
Int evCheckSzB_S390(void);

/* Perform a chaining and unchaining of an XDirect jump. */
VexInvalRange chainXDirect_S390(VexEndness endness_host,
                                void *place_to_chain,
                                const void *disp_cp_chain_me_EXPECTED,
                                const void *place_to_jump_to);

VexInvalRange unchainXDirect_S390(VexEndness endness_host,
                                  void *place_to_unchain,
                                  const void *place_to_jump_to_EXPECTED,
                                  const void *disp_cp_chain_me);

/* Patch the counter location into an existing ProfInc point. */
VexInvalRange patchProfInc_S390(VexEndness endness_host,
                                void  *code_to_patch,
                                const ULong *location_of_counter);

/* KLUDGE: See detailled comment in host_s390_defs.c. */
extern UInt s390_host_hwcaps;

/* Convenience macros to test installed facilities */
#define s390_host_has_ldisp \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_LDISP))
#define s390_host_has_eimm \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_EIMM))
#define s390_host_has_gie \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_GIE))
#define s390_host_has_dfp \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_DFP))
#define s390_host_has_fgx \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_FGX))
#define s390_host_has_etf2 \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_ETF2))
#define s390_host_has_stfle \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_STFLE))
#define s390_host_has_etf3 \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_ETF3))
#define s390_host_has_stckf \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_STCKF))
#define s390_host_has_fpext \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_FPEXT))
#define s390_host_has_lsc \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_LSC))
#define s390_host_has_pfpo \
                      (s390_host_hwcaps & (VEX_HWCAPS_S390X_PFPO))

#endif /* ndef __VEX_HOST_S390_DEFS_H */

/*---------------------------------------------------------------*/
/*--- end                                    host_s390_defs.h ---*/
/*---------------------------------------------------------------*/
