VEX/priv/host_s390_defs.h

   1 /* -*- mode: C; c-basic-offset: 3; -*- */
   2
   3 /*---------------------------------------------------------------*/
   4 /*--- begin                                  host_s390_defs.h ---*/
   5 /*---------------------------------------------------------------*/
   6
   7 /*
   8    This file is part of Valgrind, a dynamic binary instrumentation
   9    framework.
  10
  11    Copyright IBM Corp. 2010-2017
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of the
  16    License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful, but
  19    WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  26    02110-1301, USA.
  27
  28    The GNU General Public License is contained in the file COPYING.
  29 */
  30
  31 /* Contributed by Florian Krohm */
  32
  33 #ifndef __VEX_HOST_S390_DEFS_H
  34 #define __VEX_HOST_S390_DEFS_H
  35
  36 #include "libvex_basictypes.h"            /* Bool */
  37 #include "libvex.h"                       /* VexArchInfo */
  38 #include "host_generic_regs.h"            /* HReg */
  39 #include "s390_defs.h"                    /* s390_cc_t */
  40
  41 /* --------- Registers --------- */
  42 const HChar *s390_hreg_as_string(HReg);
  43 HReg s390_hreg_gpr(UInt regno);
  44 HReg s390_hreg_fpr(UInt regno);
  45 HReg s390_hreg_vr(UInt regno);
  46
  47 /* Dedicated registers */
  48 HReg s390_hreg_guest_state_pointer(void);
  49 HReg s390_hreg_stack_pointer(void);
  50
  51
  52 /* Given the index of a function argument, return the number of the
  53    general purpose register in which it is being passed. Arguments are
  54    counted 0, 1, 2, ... and they are being passed in r2, r3, r4, ... */
  55 static __inline__ UInt
  56 s390_gprno_from_arg_index(UInt ix)
  57 {
  58    return ix + 2;
  59 }
  60
  61 /* --------- Memory address expressions (amodes). --------- */
  62
  63 /* These are the address modes:
  64    (1) b12:  base register + 12-bit unsigned offset   (e.g. RS)
  65    (2) b20:  base register + 20-bit signed offset     (e.g. RSY)
  66    (3) bx12: base register + index register + 12-bit unsigned offset (e.g. RX)
  67    (4) bx20: base register + index register + 20-bit signed offset   (e.g. RXY)
  68    fixs390: There is also pc-relative stuff.. e.g. LARL
  69 */
  70
  71 typedef enum {
  72    S390_AMODE_B12,
  73    S390_AMODE_B20,
  74    S390_AMODE_BX12,
  75    S390_AMODE_BX20
  76 } s390_amode_t;
  77
  78 typedef struct {
  79    s390_amode_t tag;
  80    HReg b;
  81    HReg x;       /* hregNumber(x) == 0  for S390_AMODE_B12/B20 kinds */
  82    Int  d;       /* 12 bit unsigned or 20 bit signed */
  83 } s390_amode;
  84
  85
  86 s390_amode *s390_amode_b12(Int d, HReg b);
  87 s390_amode *s390_amode_b20(Int d, HReg b);
  88 s390_amode *s390_amode_bx12(Int d, HReg b, HReg x);
  89 s390_amode *s390_amode_bx20(Int d, HReg b, HReg x);
  90 s390_amode *s390_amode_for_guest_state(Int d);
  91 s390_amode *s390_amode_for_stack_pointer(Int d);
  92 Bool        s390_amode_is_sane(const s390_amode *);
  93
  94 const HChar *s390_amode_as_string(const s390_amode *);
  95
  96 /* ------------- 2nd (right) operand of binary operation ---------------- */
  97
  98 typedef enum {
  99    S390_OPND_REG,
 100    S390_OPND_IMMEDIATE,
 101    S390_OPND_AMODE
 102 } s390_opnd_t;
 103
 104
 105 /* Naming convention for operand locations:
 106    R    - GPR
 107    I    - immediate value
 108    M    - memory (any Amode may be used)
 109 */
 110
 111 /* An operand that is either in a GPR or is addressable via a BX20 amode */
 112 typedef struct {
 113    s390_opnd_t tag;
 114    union {
 115       HReg        reg;
 116       s390_amode *am;
 117       ULong       imm;
 118    } variant;
 119 } s390_opnd_RMI;
 120
 121
 122 /* The kind of instructions */
 123 typedef enum {
 124    S390_INSN_LOAD,   /* load register from memory */
 125    S390_INSN_STORE,  /* store register to memory */
 126    S390_INSN_MOVE,   /* from register to register */
 127    S390_INSN_MEMCPY, /* from memory to memory */
 128    S390_INSN_COND_MOVE, /* conditonal "move" to register */
 129    S390_INSN_LOAD_IMMEDIATE,
 130    S390_INSN_ALU,
 131    S390_INSN_SMUL,   /*   signed multiply; n-bit operands; 2n-bit result */
 132    S390_INSN_UMUL,   /* unsigned multiply; n-bit operands; 2n-bit result */
 133    S390_INSN_SDIV,   /*   signed division; 2n-bit / n-bit -> n-bit quot/rem */
 134    S390_INSN_UDIV,   /* unsigned division; 2n-bit / n-bit -> n-bit quot/rem */
 135    S390_INSN_DIVS,   /* n-bit dividend; n-bit divisor; n-bit quot/rem */
 136    S390_INSN_CLZ,    /* count left-most zeroes */
 137    S390_INSN_UNOP,
 138    S390_INSN_TEST,   /* test operand and set cc */
 139    S390_INSN_CC2BOOL,/* convert condition code to 0/1 */
 140    S390_INSN_COMPARE,
 141    S390_INSN_HELPER_CALL,
 142    S390_INSN_CAS,    /* compare and swap */
 143    S390_INSN_CDAS,   /* compare double and swap */
 144    S390_INSN_BFP_BINOP, /* Binary floating point */
 145    S390_INSN_BFP_UNOP,
 146    S390_INSN_BFP_TRIOP,
 147    S390_INSN_BFP_COMPARE,
 148    S390_INSN_BFP_CONVERT,
 149    S390_INSN_DFP_BINOP, /* Decimal floating point */
 150    S390_INSN_DFP_UNOP,
 151    S390_INSN_DFP_INTOP,
 152    S390_INSN_DFP_COMPARE,
 153    S390_INSN_DFP_CONVERT,
 154    S390_INSN_DFP_REROUND,
 155    S390_INSN_FP_CONVERT,
 156    S390_INSN_MFENCE,
 157    S390_INSN_MIMM,    /* Assign an immediate constant to a memory location */
 158    S390_INSN_MADD,    /* Add a value to a memory location */
 159    S390_INSN_SET_FPC_BFPRM, /* Set the bfp rounding mode in the FPC */
 160    S390_INSN_SET_FPC_DFPRM, /* Set the dfp rounding mode in the FPC */
 161    /* The following 5 insns are mandated by translation chaining */
 162    S390_INSN_XDIRECT,     /* direct transfer to guest address */
 163    S390_INSN_XINDIR,      /* indirect transfer to guest address */
 164    S390_INSN_XASSISTED,   /* assisted transfer to guest address */
 165    S390_INSN_EVCHECK,     /* Event check */
 166    S390_INSN_PROFINC,     /* 64-bit profile counter increment */
 167    S390_INSN_VEC_AMODEOP,
 168    S390_INSN_VEC_AMODEINTOP,
 169    S390_INSN_VEC_UNOP,
 170    S390_INSN_VEC_BINOP,
 171    S390_INSN_VEC_TRIOP
 172 } s390_insn_tag;
 173
 174
 175 /* The kind of ALU instructions */
 176 typedef enum {
 177    S390_ALU_ADD,
 178    S390_ALU_SUB,
 179    S390_ALU_MUL,   /* n-bit operands; result is lower n-bit of product */
 180    S390_ALU_AND,
 181    S390_ALU_OR,
 182    S390_ALU_XOR,
 183    S390_ALU_LSH,
 184    S390_ALU_RSH,
 185    S390_ALU_RSHA   /* arithmetic */
 186 } s390_alu_t;
 187
 188
 189 /* The kind of unary integer operations */
 190 typedef enum {
 191    S390_ZERO_EXTEND_8,
 192    S390_ZERO_EXTEND_16,
 193    S390_ZERO_EXTEND_32,
 194    S390_SIGN_EXTEND_8,
 195    S390_SIGN_EXTEND_16,
 196    S390_SIGN_EXTEND_32,
 197    S390_NEGATE,
 198    S390_VEC_FILL,
 199    S390_VEC_DUPLICATE,
 200    S390_VEC_UNPACKLOWS,
 201    S390_VEC_UNPACKLOWU,
 202    S390_VEC_ABS,
 203    S390_VEC_COUNT_LEADING_ZEROES,
 204    S390_VEC_COUNT_TRAILING_ZEROES,
 205    S390_VEC_COUNT_ONES,
 206    S390_VEC_FLOAT_NEG,
 207    S390_VEC_FLOAT_ABS,
 208    S390_VEC_FLOAT_SQRT
 209 } s390_unop_t;
 210
 211 /* The kind of ternary BFP operations */
 212 typedef enum {
 213    S390_BFP_MADD,
 214    S390_BFP_MSUB,
 215 } s390_bfp_triop_t;
 216
 217 /* The kind of binary BFP operations */
 218 typedef enum {
 219    S390_BFP_ADD,
 220    S390_BFP_SUB,
 221    S390_BFP_MUL,
 222    S390_BFP_DIV
 223 } s390_bfp_binop_t;
 224
 225 /* The kind of unary BFP operations */
 226 typedef enum {
 227    S390_BFP_ABS,
 228    S390_BFP_NABS,
 229    S390_BFP_NEG,
 230    S390_BFP_SQRT
 231 } s390_bfp_unop_t;
 232
 233 /* Type conversion operations: to and/or from binary floating point */
 234 typedef enum {
 235    S390_BFP_I32_TO_F32,
 236    S390_BFP_I32_TO_F64,
 237    S390_BFP_I32_TO_F128,
 238    S390_BFP_I64_TO_F32,
 239    S390_BFP_I64_TO_F64,
 240    S390_BFP_I64_TO_F128,
 241    S390_BFP_U32_TO_F32,
 242    S390_BFP_U32_TO_F64,
 243    S390_BFP_U32_TO_F128,
 244    S390_BFP_U64_TO_F32,
 245    S390_BFP_U64_TO_F64,
 246    S390_BFP_U64_TO_F128,
 247    S390_BFP_F32_TO_I32,
 248    S390_BFP_F32_TO_I64,
 249    S390_BFP_F32_TO_U32,
 250    S390_BFP_F32_TO_U64,
 251    S390_BFP_F32_TO_F64,
 252    S390_BFP_F32_TO_F128,
 253    S390_BFP_F64_TO_I32,
 254    S390_BFP_F64_TO_I64,
 255    S390_BFP_F64_TO_U32,
 256    S390_BFP_F64_TO_U64,
 257    S390_BFP_F64_TO_F32,
 258    S390_BFP_F64_TO_F128,
 259    S390_BFP_F128_TO_I32,
 260    S390_BFP_F128_TO_I64,
 261    S390_BFP_F128_TO_U32,
 262    S390_BFP_F128_TO_U64,
 263    S390_BFP_F128_TO_F32,
 264    S390_BFP_F128_TO_F64,
 265    S390_BFP_F32_TO_F32I,
 266    S390_BFP_F64_TO_F64I,
 267    S390_BFP_F128_TO_F128I
 268 } s390_bfp_conv_t;
 269
 270 /* Type conversion operations: to and/or from decimal floating point */
 271 typedef enum {
 272    S390_DFP_D32_TO_D64,
 273    S390_DFP_D64_TO_D32,
 274    S390_DFP_D64_TO_D128,
 275    S390_DFP_D128_TO_D64,
 276    S390_DFP_I32_TO_D64,
 277    S390_DFP_I32_TO_D128,
 278    S390_DFP_I64_TO_D64,
 279    S390_DFP_I64_TO_D128,
 280    S390_DFP_U32_TO_D64,
 281    S390_DFP_U32_TO_D128,
 282    S390_DFP_U64_TO_D64,
 283    S390_DFP_U64_TO_D128,
 284    S390_DFP_D64_TO_I32,
 285    S390_DFP_D64_TO_I64,
 286    S390_DFP_D64_TO_U32,
 287    S390_DFP_D64_TO_U64,
 288    S390_DFP_D128_TO_I32,
 289    S390_DFP_D128_TO_I64,
 290    S390_DFP_D128_TO_U32,
 291    S390_DFP_D128_TO_U64
 292 } s390_dfp_conv_t;
 293
 294 typedef enum {
 295    S390_FP_F32_TO_D32,
 296    S390_FP_F32_TO_D64,
 297    S390_FP_F32_TO_D128,
 298    S390_FP_F64_TO_D32,
 299    S390_FP_F64_TO_D64,
 300    S390_FP_F64_TO_D128,
 301    S390_FP_F128_TO_D32,
 302    S390_FP_F128_TO_D64,
 303    S390_FP_F128_TO_D128,
 304    S390_FP_D32_TO_F32,
 305    S390_FP_D32_TO_F64,
 306    S390_FP_D32_TO_F128,
 307    S390_FP_D64_TO_F32,
 308    S390_FP_D64_TO_F64,
 309    S390_FP_D64_TO_F128,
 310    S390_FP_D128_TO_F32,
 311    S390_FP_D128_TO_F64,
 312    S390_FP_D128_TO_F128
 313 } s390_fp_conv_t;
 314
 315 /* The kind of binary DFP operations */
 316 typedef enum {
 317    S390_DFP_ADD,
 318    S390_DFP_SUB,
 319    S390_DFP_MUL,
 320    S390_DFP_DIV,
 321    S390_DFP_QUANTIZE
 322 } s390_dfp_binop_t;
 323
 324 /* The kind of unary DFP operations */
 325 typedef enum {
 326    S390_DFP_EXTRACT_EXP_D64,
 327    S390_DFP_EXTRACT_EXP_D128,
 328    S390_DFP_EXTRACT_SIG_D64,
 329    S390_DFP_EXTRACT_SIG_D128,
 330 } s390_dfp_unop_t;
 331
 332 /* The DFP operations with 2 operands one of them being integer */
 333 typedef enum {
 334    S390_DFP_SHIFT_LEFT,
 335    S390_DFP_SHIFT_RIGHT,
 336    S390_DFP_INSERT_EXP
 337 } s390_dfp_intop_t;
 338
 339 /* The kind of DFP compare operations */
 340 typedef enum {
 341    S390_DFP_COMPARE,
 342    S390_DFP_COMPARE_EXP,
 343 } s390_dfp_cmp_t;
 344
 345 /* The vector operations with 2 operands one of them being amode */
 346 typedef enum {
 347    S390_VEC_GET_ELEM,
 348    S390_VEC_ELEM_SHL_INT,
 349    S390_VEC_ELEM_SHRA_INT,
 350    S390_VEC_ELEM_SHRL_INT
 351 } s390_vec_amodeop_t;
 352
 353 /* The vector operations with three (vector, amode and integer) operands */
 354 typedef enum {
 355    S390_VEC_SET_ELEM
 356 } s390_vec_amodeintop_t;
 357
 358 /* The vector operations with two operands */
 359 typedef enum {
 360    S390_VEC_PACK,
 361    S390_VEC_PACK_SATURS,
 362    S390_VEC_PACK_SATURU,
 363    S390_VEC_COMPARE_EQUAL,
 364    S390_VEC_OR,
 365    S390_VEC_XOR,
 366    S390_VEC_AND,
 367    S390_VEC_MERGEL,
 368    S390_VEC_MERGEH,
 369    S390_VEC_NOR,
 370    S390_VEC_INT_ADD,
 371    S390_VEC_INT_SUB,
 372    S390_VEC_MAXU,
 373    S390_VEC_MAXS,
 374    S390_VEC_MINU,
 375    S390_VEC_MINS,
 376    S390_VEC_AVGU,
 377    S390_VEC_AVGS,
 378    S390_VEC_COMPARE_GREATERS,
 379    S390_VEC_COMPARE_GREATERU,
 380    S390_VEC_INT_MUL_HIGHS,
 381    S390_VEC_INT_MUL_HIGHU,
 382    S390_VEC_INT_MUL_LOW,
 383    S390_VEC_INT_MUL_EVENS,
 384    S390_VEC_INT_MUL_EVENU,
 385    S390_VEC_ELEM_SHL_V,
 386    S390_VEC_ELEM_SHRA_V,
 387    S390_VEC_ELEM_SHRL_V,
 388    S390_VEC_ELEM_ROLL_V,
 389
 390    /* host_s390_isel depends on this order. */
 391    S390_VEC_SHL_BITS, S390_VEC_SHL_BYTES,
 392    S390_VEC_SHRL_BITS, S390_VEC_SHRL_BYTES,
 393    S390_VEC_SHRA_BITS, S390_VEC_SHRA_BYTES,
 394
 395    S390_VEC_PWSUM_W,
 396    S390_VEC_PWSUM_DW,
 397    S390_VEC_PWSUM_QW,
 398
 399    S390_VEC_INIT_FROM_GPRS,
 400    S390_VEC_FLOAT_ADD,
 401    S390_VEC_FLOAT_SUB,
 402    S390_VEC_FLOAT_MUL,
 403    S390_VEC_FLOAT_DIV,
 404    S390_VEC_FLOAT_COMPARE_EQUAL,
 405    S390_VEC_FLOAT_COMPARE_LESS_OR_EQUAL,
 406    S390_VEC_FLOAT_COMPARE_LESS
 407 } s390_vec_binop_t;
 408
 409 /* The vector operations with three operands */
 410 typedef enum {
 411    S390_VEC_PERM,
 412    S390_VEC_FLOAT_MADD,
 413    S390_VEC_FLOAT_MSUB
 414 } s390_vec_triop_t;
 415
 416 /* The details of a CDAS insn. Carved out to keep the size of
 417    s390_insn low */
 418 typedef struct {
 419    HReg        op1_high;
 420    HReg        op1_low;
 421    s390_amode *op2;
 422    HReg        op3_high;
 423    HReg        op3_low;
 424    HReg        old_mem_high;
 425    HReg        old_mem_low;
 426    HReg        scratch;
 427 } s390_cdas;
 428
 429 /* The details of a binary DFP insn. Carved out to keep the size of
 430    s390_insn low */
 431 typedef struct {
 432    s390_dfp_binop_t tag;
 433    s390_dfp_round_t rounding_mode;
 434    HReg         dst_hi; /* 128-bit result high part; 64-bit result */
 435    HReg         dst_lo; /* 128-bit result low part */
 436    HReg         op2_hi; /* 128-bit operand high part; 64-bit opnd 1 */
 437    HReg         op2_lo; /* 128-bit operand low part */
 438    HReg         op3_hi; /* 128-bit operand high part; 64-bit opnd 2 */
 439    HReg         op3_lo; /* 128-bit operand low part */
 440 } s390_dfp_binop;
 441
 442 typedef struct {
 443    s390_fp_conv_t  tag;
 444    s390_dfp_round_t rounding_mode;
 445    HReg         dst_hi; /* 128-bit result high part; 32/64-bit result */
 446    HReg         dst_lo; /* 128-bit result low part */
 447    HReg         op_hi;  /* 128-bit operand high part; 32/64-bit opnd */
 448    HReg         op_lo;  /* 128-bit operand low part */
 449    HReg         r1;     /* clobbered register GPR #1 */
 450 } s390_fp_convert;
 451
 452 /* Pseudo-insn for representing a helper call.
 453    TARGET is the absolute address of the helper function
 454    NUM_ARGS says how many arguments are being passed.
 455    All arguments have integer type and are being passed according to ABI,
 456    i.e. in registers r2, r3, r4, r5, and r6, with argument #0 being
 457    passed in r2 and so forth. */
 458 typedef struct {
 459    s390_cc_t    cond     : 16;
 460    UInt         num_args : 16;
 461    RetLoc       rloc;     /* where the return value will be */
 462    Addr64       target;
 463    const HChar *name;      /* callee's name (for debugging) */
 464 } s390_helper_call;
 465
 466 typedef struct {
 467    s390_insn_tag tag;
 468    /* Usually, this is the size of the result of an operation.
 469       Exceptions are:
 470       - for comparisons it is the size of the operand
 471    */
 472    UChar size;
 473    union {
 474       struct {
 475          HReg        dst;
 476          s390_amode *src;
 477       } load;
 478       struct {
 479          s390_amode *dst;
 480          HReg        src;
 481       } store;
 482       struct {
 483          HReg        dst;
 484          HReg        src;
 485       } move;
 486       struct {
 487          s390_amode *dst;
 488          s390_amode *src;
 489       } memcpy;
 490       struct {
 491          s390_cc_t     cond;
 492          HReg          dst;
 493          s390_opnd_RMI src;
 494       } cond_move;
 495       struct {
 496          HReg        dst;
 497          ULong       value;  /* not sign extended */
 498       } load_immediate;
 499       /* add, and, or, xor */
 500       struct {
 501          s390_alu_t    tag;
 502          HReg          dst; /* op1 */
 503          s390_opnd_RMI op2;
 504       } alu;
 505       struct {
 506          HReg          dst_hi;  /*           r10 */
 507          HReg          dst_lo;  /* also op1  r11 */
 508          s390_opnd_RMI op2;
 509       } mul;
 510       struct {
 511          HReg          op1_hi;  /* also remainder   r10 */
 512          HReg          op1_lo;  /* also quotient    r11 */
 513          s390_opnd_RMI op2;
 514       } div;
 515       struct {
 516          HReg          rem; /* remainder      r10 */
 517          HReg          op1; /* also quotient  r11 */
 518          s390_opnd_RMI op2;
 519       } divs;
 520       struct {
 521          HReg          num_bits; /* number of leftmost '0' bits  r10 */
 522          HReg          clobber;  /* unspecified                  r11 */
 523          s390_opnd_RMI src;
 524       } clz;
 525       struct {
 526          s390_unop_t   tag;
 527          HReg          dst;
 528          s390_opnd_RMI src;
 529       } unop;
 530       struct {
 531          Bool          signed_comparison;
 532          HReg          src1;
 533          s390_opnd_RMI src2;
 534       } compare;
 535       struct {
 536          s390_opnd_RMI src;
 537       } test;
 538       /* Convert the condition code to a boolean value. */
 539       struct {
 540          s390_cc_t cond;
 541          HReg      dst;
 542       } cc2bool;
 543       struct {
 544          HReg        op1;
 545          s390_amode *op2;
 546          HReg        op3;
 547          HReg        old_mem;
 548       } cas;
 549       struct {
 550          s390_cdas *details;
 551       } cdas;
 552       struct {
 553          s390_helper_call *details;
 554       } helper_call;
 555
 556       /* Floating point instructions (including conversion to/from floating
 557          point
 558
 559          128-bit floating point requires register pairs. As the registers
 560          in a register pair cannot be chosen independently it would suffice
 561          to store only one register of the pair in order to represent it.
 562          We chose not to do that as being explicit about all registers
 563          helps with debugging and does not require special handling in
 564          e.g. s390_insn_get_reg_usage, It'd be all too easy to forget about
 565          the "other" register in a pair if it is implicit.
 566
 567          The convention for all fp s390_insn is that the _hi register will
 568          be used to store the result / operand of a 32/64-bit operation.
 569          The _hi register holds the  8 bytes of HIgher significance of a
 570          128-bit value (hence the suffix). However, it is the lower numbered
 571          register of a register pair. POP says that the lower numbered
 572          register is used to identify the pair in an insn encoding. So,
 573          when an insn is emitted, only the _hi registers need to be looked
 574          at. Nothing special is needed for 128-bit BFP which is nice.
 575       */
 576
 577       /* There are currently no ternary 128-bit BFP operations. */
 578       struct {
 579          s390_bfp_triop_t tag;
 580          HReg         dst;
 581          HReg         op2;
 582          HReg         op3;
 583       } bfp_triop;
 584       struct {
 585          s390_bfp_binop_t tag;
 586          HReg         dst_hi; /* 128-bit result high part; 32/64-bit result */
 587          HReg         dst_lo; /* 128-bit result low part */
 588          HReg         op2_hi; /* 128-bit operand high part; 32/64-bit opnd */
 589          HReg         op2_lo; /* 128-bit operand low part */
 590       } bfp_binop;
 591       struct {
 592          s390_bfp_unop_t  tag;
 593          HReg         dst_hi; /* 128-bit result high part; 32/64-bit result */
 594          HReg         dst_lo; /* 128-bit result low part */
 595          HReg         op_hi;  /* 128-bit operand high part; 32/64-bit opnd */
 596          HReg         op_lo;  /* 128-bit operand low part */
 597       } bfp_unop;
 598       struct {
 599          s390_bfp_conv_t  tag;
 600          s390_bfp_round_t rounding_mode;
 601          HReg         dst_hi; /* 128-bit result high part; 32/64-bit result */
 602          HReg         dst_lo; /* 128-bit result low part */
 603          HReg         op_hi;  /* 128-bit operand high part; 32/64-bit opnd */
 604          HReg         op_lo;  /* 128-bit operand low part */
 605       } bfp_convert;
 606       struct {
 607          HReg         dst;     /* condition code in s390 encoding */
 608          HReg         op1_hi;  /* 128-bit operand high part; 32/64-bit opnd */
 609          HReg         op1_lo;  /* 128-bit operand low part */
 610          HReg         op2_hi;  /* 128-bit operand high part; 32/64-bit opnd */
 611          HReg         op2_lo;  /* 128-bit operand low part */
 612       } bfp_compare;
 613       struct {
 614          s390_dfp_binop *details;
 615       } dfp_binop;
 616       struct {
 617          s390_dfp_unop_t tag;
 618          HReg         dst_hi; /* 128-bit result high part; 64-bit result */
 619          HReg         dst_lo; /* 128-bit result low part */
 620          HReg         op_hi;  /* 128-bit operand high part; 64-bit opnd */
 621          HReg         op_lo;  /* 128-bit operand low part */
 622       } dfp_unop;
 623       struct {
 624          s390_dfp_intop_t tag;
 625          HReg         dst_hi; /* 128-bit result high part; 64-bit result */
 626          HReg         dst_lo; /* 128-bit result low part */
 627          HReg         op2;    /* integer operand */
 628          HReg         op3_hi; /* 128-bit operand high part; 64-bit opnd */
 629          HReg         op3_lo; /* 128-bit operand low part */
 630       } dfp_intop;
 631       struct {
 632          s390_dfp_conv_t  tag;
 633          s390_dfp_round_t rounding_mode;
 634          HReg         dst_hi; /* 128-bit result high part; 64-bit result */
 635          HReg         dst_lo; /* 128-bit result low part */
 636          HReg         op_hi;  /* 128-bit operand high part; 64-bit opnd */
 637          HReg         op_lo;  /* 128-bit operand low part */
 638       } dfp_convert;
 639       struct {
 640          s390_fp_convert *details;
 641       } fp_convert;
 642       struct {
 643          s390_dfp_cmp_t tag;
 644          HReg         dst;     /* condition code in s390 encoding */
 645          HReg         op1_hi;  /* 128-bit operand high part; 64-bit opnd 1 */
 646          HReg         op1_lo;  /* 128-bit operand low part */
 647          HReg         op2_hi;  /* 128-bit operand high part; 64-bit opnd 2 */
 648          HReg         op2_lo;  /* 128-bit operand low part */
 649       } dfp_compare;
 650       struct {
 651          s390_dfp_round_t rounding_mode;
 652          HReg         dst_hi; /* 128-bit result high part; 64-bit result */
 653          HReg         dst_lo; /* 128-bit result low part */
 654          HReg         op2;    /* integer operand */
 655          HReg         op3_hi; /* 128-bit operand high part; 64-bit opnd */
 656          HReg         op3_lo; /* 128-bit operand low part */
 657       } dfp_reround;
 658
 659       /* Miscellaneous */
 660       struct {
 661          s390_amode      *dst;
 662          ULong            value;  /* sign extended */
 663       } mimm;
 664       struct {
 665          s390_amode      *dst;
 666          UChar            delta;
 667          ULong            value;  /* for debugging only */
 668       } madd;
 669       struct {
 670          HReg             mode;
 671       } set_fpc_bfprm;
 672       struct {
 673          HReg             mode;
 674       } set_fpc_dfprm;
 675
 676       /* The next 5 entries are generic to support translation chaining */
 677
 678       /* Update the guest IA value, then exit requesting to chain
 679          to it.  May be conditional. */
 680       struct {
 681          s390_cc_t     cond;
 682          Bool          to_fast_entry;  /* chain to the what entry point? */
 683          Addr64        dst;            /* next guest address */
 684          s390_amode   *guest_IA;
 685       } xdirect;
 686       /* Boring transfer to a guest address not known at JIT time.
 687          Not chainable.  May be conditional. */
 688       struct {
 689          s390_cc_t     cond;
 690          HReg          dst;
 691          s390_amode   *guest_IA;
 692       } xindir;
 693       /* Assisted transfer to a guest address, most general case.
 694          Not chainable.  May be conditional. */
 695       struct {
 696          s390_cc_t     cond;
 697          IRJumpKind    kind;
 698          HReg          dst;
 699          s390_amode   *guest_IA;
 700       } xassisted;
 701       struct {
 702          /* fixs390: I don't think these are really needed
 703             as the gsp and the offset are fixed  no ? */
 704          s390_amode   *counter;    /* dispatch counter */
 705          s390_amode   *fail_addr;
 706       } evcheck;
 707       struct {
 708          /* No fields.  The address of the counter to increment is
 709             installed later, post-translation, by patching it in,
 710             as it is not known at translation time. */
 711       } profinc;
 712       struct {
 713          s390_vec_amodeop_t tag;
 714          HReg          dst;    /* 64-bit result */
 715          HReg          op1;    /* 128-bit operand */
 716          s390_amode   *op2;    /* amode operand */
 717       } vec_amodeop;
 718       struct {
 719          s390_vec_amodeintop_t tag;
 720          HReg          dst;    /* 128-bit result */
 721          s390_amode   *op2;    /* amode operand */
 722          HReg          op3;    /* integer operand */
 723       } vec_amodeintop;
 724       struct {
 725          s390_vec_binop_t tag;
 726          HReg          dst;    /* 128-bit result */
 727          HReg          op1;    /* 128-bit first operand */
 728          HReg          op2;    /* 128-bit second operand */
 729       } vec_binop;
 730       struct {
 731          s390_vec_triop_t tag;
 732          HReg          dst;    /* 128-bit result */
 733          HReg          op1;    /* 128-bit first operand */
 734          HReg          op2;    /* 128-bit second operand */
 735          HReg          op3;    /* 128-bit third operand */
 736       } vec_triop;
 737    } variant;
 738 } s390_insn;
 739
 740 s390_insn *s390_insn_load(UChar size, HReg dst, s390_amode *src);
 741 s390_insn *s390_insn_store(UChar size, s390_amode *dst, HReg src);
 742 s390_insn *s390_insn_move(UChar size, HReg dst, HReg src);
 743 s390_insn *s390_insn_memcpy(UChar size, s390_amode *dst, s390_amode *src);
 744 s390_insn *s390_insn_cond_move(UChar size, s390_cc_t cond, HReg dst,
 745                                s390_opnd_RMI src);
 746 s390_insn *s390_insn_load_immediate(UChar size, HReg dst, ULong val);
 747 s390_insn *s390_insn_alu(UChar size, s390_alu_t, HReg dst,
 748                          s390_opnd_RMI op2);
 749 s390_insn *s390_insn_mul(UChar size, HReg dst_hi, HReg dst_lo,
 750                          s390_opnd_RMI op2, Bool signed_multiply);
 751 s390_insn *s390_insn_div(UChar size, HReg op1_hi, HReg op1_lo,
 752                          s390_opnd_RMI op2, Bool signed_divide);
 753 s390_insn *s390_insn_divs(UChar size, HReg rem, HReg op1, s390_opnd_RMI op2);
 754 s390_insn *s390_insn_clz(UChar size, HReg num_bits, HReg clobber,
 755                          s390_opnd_RMI op);
 756 s390_insn *s390_insn_cas(UChar size, HReg op1, s390_amode *op2, HReg op3,
 757                          HReg old);
 758 s390_insn *s390_insn_cdas(UChar size, HReg op1_high, HReg op1_low,
 759                           s390_amode *op2, HReg op3_high, HReg op3_low,
 760                           HReg old_high, HReg old_low, HReg scratch);
 761 s390_insn *s390_insn_unop(UChar size, s390_unop_t tag, HReg dst,
 762                           s390_opnd_RMI opnd);
 763 s390_insn *s390_insn_cc2bool(HReg dst, s390_cc_t src);
 764 s390_insn *s390_insn_test(UChar size, s390_opnd_RMI src);
 765 s390_insn *s390_insn_compare(UChar size, HReg dst, s390_opnd_RMI opnd,
 766                              Bool signed_comparison);
 767 s390_insn *s390_insn_helper_call(s390_cc_t cond, Addr64 target, UInt num_args,
 768                                  const HChar *name, RetLoc rloc);
 769 s390_insn *s390_insn_bfp_triop(UChar size, s390_bfp_triop_t, HReg dst,
 770                                HReg op2, HReg op3);
 771 s390_insn *s390_insn_bfp_binop(UChar size, s390_bfp_binop_t, HReg dst,
 772                                HReg op2);
 773 s390_insn *s390_insn_bfp_unop(UChar size, s390_bfp_unop_t tag, HReg dst,
 774                               HReg op);
 775 s390_insn *s390_insn_bfp_compare(UChar size, HReg dst, HReg op1, HReg op2);
 776 s390_insn *s390_insn_bfp_convert(UChar size, s390_bfp_conv_t tag, HReg dst,
 777                                  HReg op, s390_bfp_round_t);
 778 s390_insn *s390_insn_bfp128_convert(UChar size, s390_bfp_conv_t tag, HReg dst_hi,
 779                                     HReg dst_lo, HReg op_hi, HReg op_lo,
 780                                     s390_bfp_round_t rounding_mode);
 781 s390_insn *s390_insn_bfp128_binop(UChar size, s390_bfp_binop_t, HReg dst_hi,
 782                                   HReg dst_lo, HReg op2_hi, HReg op2_lo);
 783 s390_insn *s390_insn_bfp128_unop(UChar size, s390_bfp_unop_t, HReg dst_hi,
 784                                  HReg dst_lo, HReg op_hi, HReg op_lo);
 785 s390_insn *s390_insn_bfp128_compare(UChar size, HReg dst, HReg op1_hi,
 786                                     HReg op1_lo, HReg op2_hi, HReg op2_lo);
 787 s390_insn *s390_insn_bfp128_convert_to(UChar size, s390_bfp_conv_t,
 788                                        HReg dst_hi, HReg dst_lo, HReg op);
 789 s390_insn *s390_insn_bfp128_convert_from(UChar size, s390_bfp_conv_t,
 790                                          HReg dst_hi, HReg dst_lo, HReg op_hi,
 791                                          HReg op_lo, s390_bfp_round_t);
 792 s390_insn *s390_insn_dfp_binop(UChar size, s390_dfp_binop_t, HReg dst,
 793                                HReg op2, HReg op3,
 794                                s390_dfp_round_t rounding_mode);
 795 s390_insn *s390_insn_dfp_unop(UChar size, s390_dfp_unop_t, HReg dst, HReg op);
 796 s390_insn *s390_insn_dfp_intop(UChar size, s390_dfp_intop_t, HReg dst,
 797                                HReg op2, HReg op3);
 798 s390_insn *s390_insn_dfp_compare(UChar size, s390_dfp_cmp_t, HReg dst,
 799                                  HReg op1, HReg op2);
 800 s390_insn *s390_insn_dfp_convert(UChar size, s390_dfp_conv_t tag, HReg dst,
 801                                  HReg op, s390_dfp_round_t);
 802 s390_insn *s390_insn_dfp_reround(UChar size, HReg dst, HReg op2, HReg op3,
 803                                  s390_dfp_round_t);
 804 s390_insn *s390_insn_fp_convert(UChar size, s390_fp_conv_t tag,
 805                                 HReg dst, HReg op, HReg r1, s390_dfp_round_t);
 806 s390_insn *s390_insn_fp128_convert(UChar size, s390_fp_conv_t tag,
 807                                    HReg dst_hi, HReg dst_lo, HReg op_hi,
 808                                    HReg op_lo, HReg r1, s390_dfp_round_t);
 809 s390_insn *s390_insn_dfp128_binop(UChar size, s390_dfp_binop_t, HReg dst_hi,
 810                                   HReg dst_lo, HReg op2_hi, HReg op2_lo,
 811                                   HReg op3_hi, HReg op3_lo,
 812                                   s390_dfp_round_t rounding_mode);
 813 s390_insn *s390_insn_dfp128_unop(UChar size, s390_dfp_unop_t, HReg dst,
 814                                  HReg op_hi, HReg op_lo);
 815 s390_insn *s390_insn_dfp128_intop(UChar size, s390_dfp_intop_t, HReg dst_hi,
 816                                   HReg dst_lo, HReg op2,
 817                                   HReg op3_hi, HReg op3_lo);
 818 s390_insn *s390_insn_dfp128_compare(UChar size, s390_dfp_cmp_t, HReg dst,
 819                                     HReg op1_hi, HReg op1_lo, HReg op2_hi,
 820                                     HReg op2_lo);
 821 s390_insn *s390_insn_dfp128_convert_to(UChar size, s390_dfp_conv_t,
 822                                        HReg dst_hi, HReg dst_lo, HReg op);
 823 s390_insn *s390_insn_dfp128_convert_from(UChar size, s390_dfp_conv_t,
 824                                          HReg dst_hi, HReg dst_lo, HReg op_hi,
 825                                          HReg op_lo, s390_dfp_round_t);
 826 s390_insn *s390_insn_dfp128_reround(UChar size, HReg dst_hi, HReg dst_lo,
 827                                     HReg op2, HReg op3_hi, HReg op3_lo,
 828                                     s390_dfp_round_t);
 829 s390_insn *s390_insn_mfence(void);
 830 s390_insn *s390_insn_mimm(UChar size, s390_amode *dst, ULong value);
 831 s390_insn *s390_insn_madd(UChar size, s390_amode *dst, UChar delta,
 832                           ULong value);
 833 s390_insn *s390_insn_set_fpc_bfprm(UChar size, HReg mode);
 834 s390_insn *s390_insn_set_fpc_dfprm(UChar size, HReg mode);
 835
 836 /* Five for translation chaining */
 837 s390_insn *s390_insn_xdirect(s390_cc_t cond, Addr64 dst, s390_amode *guest_IA,
 838                              Bool to_fast_entry);
 839 s390_insn *s390_insn_xindir(s390_cc_t cond, HReg dst, s390_amode *guest_IA);
 840 s390_insn *s390_insn_xassisted(s390_cc_t cond, HReg dst, s390_amode *guest_IA,
 841                                IRJumpKind kind);
 842 s390_insn *s390_insn_evcheck(s390_amode *counter, s390_amode *fail_addr);
 843 s390_insn *s390_insn_profinc(void);
 844 s390_insn *s390_insn_vec_amodeop(UChar size, s390_vec_amodeop_t, HReg dst,
 845                                  HReg op1, s390_amode* op2);
 846 s390_insn *s390_insn_vec_amodeintop(UChar size, s390_vec_amodeintop_t, HReg dst,
 847                                     s390_amode* op2, HReg op3);
 848 s390_insn *s390_insn_vec_binop(UChar size, s390_vec_binop_t, HReg dst, HReg op1,
 849                                HReg op2);
 850 s390_insn *s390_insn_vec_triop(UChar size, s390_vec_triop_t, HReg dst, HReg op1,
 851                                HReg op2, HReg op3);
 852
 853 const HChar *s390_insn_as_string(const s390_insn *);
 854
 855 /*--------------------------------------------------------*/
 856 /* --- Interface exposed to VEX                       --- */
 857 /*--------------------------------------------------------*/
 858
 859 void ppS390AMode(const s390_amode *);
 860 void ppS390Instr(const s390_insn *, Bool mode64);
 861 UInt ppHRegS390(HReg);
 862
 863 /* Some functions that insulate the register allocator from details
 864    of the underlying instruction set. */
 865 void  getRegUsage_S390Instr( HRegUsage *, const s390_insn *, Bool );
 866 void  mapRegs_S390Instr    ( HRegRemap *, s390_insn *, Bool );
 867 Int   emit_S390Instr       ( Bool *, UChar *, Int, const s390_insn *, Bool,
 868                              VexEndness, const void *, const void *,
 869                              const void *, const void *);
 870 const RRegUniverse *getRRegUniverse_S390( void );
 871 void  genSpill_S390        ( HInstr **, HInstr **, HReg , Int , Bool );
 872 void  genReload_S390       ( HInstr **, HInstr **, HReg , Int , Bool );
 873 extern s390_insn* genMove_S390(HReg from, HReg to, Bool mode64);
 874 HInstrArray *iselSB_S390   ( const IRSB *, VexArch, const VexArchInfo *,
 875                              const VexAbiInfo *, Int, Int, Bool, Bool, Addr);
 876
 877 /* Return the number of bytes of code needed for an event check */
 878 Int evCheckSzB_S390(void);
 879
 880 /* Perform a chaining and unchaining of an XDirect jump. */
 881 VexInvalRange chainXDirect_S390(VexEndness endness_host,
 882                                 void *place_to_chain,
 883                                 const void *disp_cp_chain_me_EXPECTED,
 884                                 const void *place_to_jump_to);
 885
 886 VexInvalRange unchainXDirect_S390(VexEndness endness_host,
 887                                   void *place_to_unchain,
 888                                   const void *place_to_jump_to_EXPECTED,
 889                                   const void *disp_cp_chain_me);
 890
 891 /* Patch the counter location into an existing ProfInc point. */
 892 VexInvalRange patchProfInc_S390(VexEndness endness_host,
 893                                 void  *code_to_patch,
 894                                 const ULong *location_of_counter);
 895
 896 /* KLUDGE: See detailled comment in host_s390_defs.c. */
 897 extern UInt s390_host_hwcaps;
 898
 899 /* Convenience macros to test installed facilities */
 900 #define s390_host_has_ldisp \
 901                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_LDISP))
 902 #define s390_host_has_eimm \
 903                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_EIMM))
 904 #define s390_host_has_gie \
 905                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_GIE))
 906 #define s390_host_has_dfp \
 907                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_DFP))
 908 #define s390_host_has_fgx \
 909                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_FGX))
 910 #define s390_host_has_etf2 \
 911                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_ETF2))
 912 #define s390_host_has_stfle \
 913                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_STFLE))
 914 #define s390_host_has_etf3 \
 915                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_ETF3))
 916 #define s390_host_has_stckf \
 917                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_STCKF))
 918 #define s390_host_has_fpext \
 919                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_FPEXT))
 920 #define s390_host_has_lsc \
 921                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_LSC))
 922 #define s390_host_has_pfpo \
 923                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_PFPO))
 924 #define s390_host_has_vx \
 925                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_VX))
 926 #define s390_host_has_msa5 \
 927                       (s390_host_hwcaps & (VEX_HWCAPS_S390X_MSA5))
 928 #endif /* ndef __VEX_HOST_S390_DEFS_H */
 929
 930 /*---------------------------------------------------------------*/
 931 /*--- end                                    host_s390_defs.h ---*/
 932 /*---------------------------------------------------------------*/