none/tests/s390x/comp-1.c

   1 /* Test signed integer comparison ops
   2    cr, cgr, cgfr, c, cg, cgf, cfi, cgfi
   3
   4    missing: cy, crl, cgrl, cgfrl
   5 */
   6
   7 #include <stdio.h>
   8 #include <stdint.h>
   9 #include <inttypes.h>
  10 #include <limits.h>
  11 #include "opcodes.h"
  12
  13 #undef RIL_RI
  14 #define RIL_RI(op1,r1,op2,i2)  \
  15             ".short 0x" #op1 #r1 #op2 "\n\t"  \
  16             ".long  " #i2 "\n\t"
  17
  18
  19 /* Perform a single signed comparison
  20    Both operands in register */
  21 #define SCOMP_REG_REG(insn, v1, v2)        \
  22 ({                                         \
  23    int cc;                                 \
  24    int64_t op1 = v1;                       \
  25    int64_t op2 = v2;                       \
  26    asm volatile(   #insn " %1, %2\n\t"     \
  27                    "ipm %0\n\t"            \
  28                    "srl %0,28\n\t"         \
  29                    : "=d" (cc)             \
  30                    : "d" (op1), "d" (op2)  \
  31                    : "cc");                \
  32    printf("%.6s (%"PRId64", %"PRId64") --> cc = %d\n", \
  33           #insn, op1, op2, cc);            \
  34 })
  35
  36 /* Perform a single signed comparison
  37    Left operand in register, right operand in memory */
  38 #define SCOMP_REG_MEM(insn, v1, v2, op2_t) \
  39 ({                                         \
  40    int cc;                                 \
  41    int64_t op1 = v1;                       \
  42    op2_t   op2 = v2;                       \
  43    asm volatile(   #insn " %1, %2\n\t"     \
  44                    "ipm %0\n\t"            \
  45                    "srl %0,28\n\t"         \
  46                    : "=d" (cc)             \
  47                    : "d" (op1), "Q" (op2)  \
  48                    : "cc");                \
  49    printf("%.6s (%"PRId64", %"PRId64") --> cc = %d\n", \
  50           #insn, op1, (int64_t)op2, cc);            \
  51 })
  52
  53 /* Perform a single signed comparison
  54    Left operand in register, right operand is an immediate constant */
  55 #define SCOMP_REG_IMM(insn, v1, v2)        \
  56 ({                                         \
  57    int cc;                                 \
  58    register int64_t op1 asm("8") = v1;     \
  59    asm volatile(   insn(8, v2)             \
  60                    "ipm %0\n\t"            \
  61                    "srl %0,28\n\t"         \
  62                    : "=d" (cc)             \
  63                    : "d" (op1)             \
  64                    : "cc");           \
  65    printf("%.6s (%"PRId64", %"PRId64") --> cc = %d\n", \
  66           #insn, op1, (int64_t)v2, cc);            \
  67 })
  68
  69 /* Run a sequence of signed comparisons for a given insn */
  70 #define run_scomp_reg_reg(insn) \
  71 ({                              \
  72    SCOMP_REG_REG(insn,  0,  0); \
  73    SCOMP_REG_REG(insn,  0,  1); \
  74    SCOMP_REG_REG(insn,  0, -1); \
  75    SCOMP_REG_REG(insn,  1,  0); \
  76    SCOMP_REG_REG(insn, -1,  0); \
  77    SCOMP_REG_REG(insn, -2, -1); \
  78    SCOMP_REG_REG(insn, -2, -2); \
  79    SCOMP_REG_REG(insn, -2, -3); \
  80    SCOMP_REG_REG(insn,  2,  1); \
  81    SCOMP_REG_REG(insn,  2,  2); \
  82    SCOMP_REG_REG(insn,  2,  3); \
  83    SCOMP_REG_REG(insn, -2,  1); \
  84    SCOMP_REG_REG(insn,  2, -1); \
  85    SCOMP_REG_REG(insn,  INT8_MIN,   INT8_MIN); \
  86    SCOMP_REG_REG(insn,  INT8_MIN,   INT8_MAX); \
  87    SCOMP_REG_REG(insn,  INT8_MAX,   INT8_MIN); \
  88    SCOMP_REG_REG(insn,  INT8_MAX,   INT8_MAX); \
  89    SCOMP_REG_REG(insn,  INT16_MIN,  INT16_MIN); \
  90    SCOMP_REG_REG(insn,  INT16_MIN,  INT16_MAX); \
  91    SCOMP_REG_REG(insn,  INT16_MAX,  INT16_MIN); \
  92    SCOMP_REG_REG(insn,  INT16_MAX,  INT16_MAX); \
  93    SCOMP_REG_REG(insn,  INT32_MIN,  INT32_MIN); \
  94    SCOMP_REG_REG(insn,  INT32_MIN,  INT32_MAX); \
  95    SCOMP_REG_REG(insn,  INT32_MAX,  INT32_MIN); \
  96    SCOMP_REG_REG(insn,  INT32_MAX,  INT32_MAX); \
  97 })
  98
  99 /* Run a sequence of signed comparisons for a given insn */
 100 #define run_scomp_reg_mem(insn, op2_t) \
 101 ({                              \
 102    SCOMP_REG_MEM(insn,  0,  0, op2_t); \
 103    SCOMP_REG_MEM(insn,  0,  1, op2_t); \
 104    SCOMP_REG_MEM(insn,  0, -1, op2_t); \
 105    SCOMP_REG_MEM(insn,  1,  0, op2_t); \
 106    SCOMP_REG_MEM(insn, -1,  0, op2_t); \
 107    SCOMP_REG_MEM(insn, -2, -1, op2_t); \
 108    SCOMP_REG_MEM(insn, -2, -2, op2_t); \
 109    SCOMP_REG_MEM(insn, -2, -3, op2_t); \
 110    SCOMP_REG_MEM(insn,  2,  1, op2_t); \
 111    SCOMP_REG_MEM(insn,  2,  2, op2_t); \
 112    SCOMP_REG_MEM(insn,  2,  3, op2_t); \
 113    SCOMP_REG_MEM(insn, -2,  1, op2_t); \
 114    SCOMP_REG_MEM(insn,  2, -1, op2_t); \
 115    SCOMP_REG_MEM(insn,  INT8_MIN,   INT8_MIN, op2_t); \
 116    SCOMP_REG_MEM(insn,  INT8_MIN,   INT8_MAX, op2_t); \
 117    SCOMP_REG_MEM(insn,  INT8_MAX,   INT8_MIN, op2_t); \
 118    SCOMP_REG_MEM(insn,  INT8_MAX,   INT8_MAX, op2_t); \
 119    SCOMP_REG_MEM(insn,  INT16_MIN,  INT16_MIN, op2_t); \
 120    SCOMP_REG_MEM(insn,  INT16_MIN,  INT16_MAX, op2_t); \
 121    SCOMP_REG_MEM(insn,  INT16_MAX,  INT16_MIN, op2_t); \
 122    SCOMP_REG_MEM(insn,  INT16_MAX,  INT16_MAX, op2_t); \
 123    SCOMP_REG_MEM(insn,  INT32_MIN,  INT32_MIN, op2_t); \
 124    SCOMP_REG_MEM(insn,  INT32_MIN,  INT32_MAX, op2_t); \
 125    SCOMP_REG_MEM(insn,  INT32_MAX,  INT32_MIN, op2_t); \
 126    SCOMP_REG_MEM(insn,  INT32_MAX,  INT32_MAX, op2_t); \
 127 })
 128
 129 /* Run a sequence of signed comparisons for a given insn */
 130 #define run_scomp_reg_imm(insn) \
 131 ({                              \
 132    SCOMP_REG_IMM(insn,  0,  0); \
 133    SCOMP_REG_IMM(insn,  0,  1); \
 134    SCOMP_REG_IMM(insn,  0, -1); \
 135    SCOMP_REG_IMM(insn,  1,  0); \
 136    SCOMP_REG_IMM(insn, -1,  0); \
 137    SCOMP_REG_IMM(insn, -2, -1); \
 138    SCOMP_REG_IMM(insn, -2, -2); \
 139    SCOMP_REG_IMM(insn, -2, -3); \
 140    SCOMP_REG_IMM(insn,  2,  1); \
 141    SCOMP_REG_IMM(insn,  2,  2); \
 142    SCOMP_REG_IMM(insn,  2,  3); \
 143    SCOMP_REG_IMM(insn, -2,  1); \
 144    SCOMP_REG_IMM(insn,  2, -1); \
 145    SCOMP_REG_IMM(insn,  INT8_MIN,   INT8_MIN); \
 146    SCOMP_REG_IMM(insn,  INT8_MIN,   INT8_MAX); \
 147    SCOMP_REG_IMM(insn,  INT8_MAX,   INT8_MIN); \
 148    SCOMP_REG_IMM(insn,  INT8_MAX,   INT8_MAX); \
 149    SCOMP_REG_IMM(insn,  INT16_MIN,  INT16_MIN); \
 150    SCOMP_REG_IMM(insn,  INT16_MIN,  INT16_MAX); \
 151    SCOMP_REG_IMM(insn,  INT16_MAX,  INT16_MIN); \
 152    SCOMP_REG_IMM(insn,  INT16_MAX,  INT16_MAX); \
 153    SCOMP_REG_IMM(insn,  INT32_MIN,  INT32_MIN); \
 154    SCOMP_REG_IMM(insn,  INT32_MIN,  INT32_MAX); \
 155    SCOMP_REG_IMM(insn,  INT32_MAX,  INT32_MIN); \
 156    SCOMP_REG_IMM(insn,  INT32_MAX,  INT32_MAX); \
 157 })
 158
 159 void
 160 signed_comparison_reg_reg(void)
 161 {
 162    run_scomp_reg_reg(cr);
 163
 164    run_scomp_reg_reg(cgr);
 165    /* Special cases for cgr */
 166    SCOMP_REG_REG(cgr, INT64_MIN, INT64_MIN);
 167    SCOMP_REG_REG(cgr, INT64_MIN, INT64_MAX);
 168    SCOMP_REG_REG(cgr, INT64_MAX, INT64_MIN);
 169    SCOMP_REG_REG(cgr, INT64_MAX, INT64_MAX);
 170
 171    run_scomp_reg_reg(cgfr);
 172    /* Special cases for cgfr */
 173    SCOMP_REG_REG(cgfr, INT64_MIN, INT32_MIN);
 174    SCOMP_REG_REG(cgfr, INT64_MIN, INT32_MAX);
 175    SCOMP_REG_REG(cgfr, INT64_MAX, INT32_MIN);
 176    SCOMP_REG_REG(cgfr, INT64_MAX, INT32_MAX);
 177 }
 178
 179 void
 180 signed_comparison_reg_mem(void)
 181 {
 182    run_scomp_reg_mem(c, int32_t);
 183
 184    run_scomp_reg_mem(cg, int64_t);
 185    /* Special cases for cg */
 186    SCOMP_REG_MEM(cg, INT64_MIN, INT64_MIN, int64_t);
 187    SCOMP_REG_MEM(cg, INT64_MIN, INT64_MAX, int64_t);
 188    SCOMP_REG_MEM(cg, INT64_MAX, INT64_MIN, int64_t);
 189    SCOMP_REG_MEM(cg, INT64_MAX, INT64_MAX, int64_t);
 190
 191    run_scomp_reg_mem(cgf, int32_t);
 192    /* Special cases for cgf */
 193    SCOMP_REG_MEM(cgf, INT64_MIN, INT32_MIN, int32_t);
 194    SCOMP_REG_MEM(cgf, INT64_MIN, INT32_MAX, int32_t);
 195    SCOMP_REG_MEM(cgf, INT64_MAX, INT32_MIN, int32_t);
 196    SCOMP_REG_MEM(cgf, INT64_MAX, INT32_MAX, int32_t);
 197 }
 198
 199 void
 200 signed_comparison_reg_imm(void)
 201 {
 202    run_scomp_reg_imm(CFI);
 203
 204    run_scomp_reg_imm(CGFI);
 205    /* Special cases for cgfi */
 206    SCOMP_REG_IMM(CGFI, INT64_MIN, INT32_MIN);
 207    SCOMP_REG_IMM(CGFI, INT64_MIN, INT32_MAX);
 208    SCOMP_REG_IMM(CGFI, INT64_MAX, INT32_MIN);
 209    SCOMP_REG_IMM(CGFI, INT64_MAX, INT32_MAX);
 210 }
 211
 212
 213 int main(void)
 214 {
 215    signed_comparison_reg_reg();
 216    signed_comparison_reg_mem();
 217    signed_comparison_reg_imm();
 218
 219    return 0;
 220 }