Home | History | Annotate | Download | only in amd64
      1 
      2 #define exec_op glue(exec_, OP)
      3 #define exec_opq glue(glue(exec_, OP), q)
      4 #define exec_opl glue(glue(exec_, OP), l)
      5 #define exec_opw glue(glue(exec_, OP), w)
      6 #define exec_opb glue(glue(exec_, OP), b)
      7 
      8 #define EXECOP2(size, mod, res, s1, flags)          \
      9     asm ("pushq %4\n\t"\
     10          "popfq\n\t"\
     11          stringify(OP) size " %" mod "2, %" mod "0\n\t" \
     12          "pushfq\n\t"\
     13          "popq %1\n\t"\
     14          : "=q" (res), "=g" (flags)\
     15          : "q" (s1), "0" (res), "1" (flags));
     16 
     17 #define EXECOP1(size, mod, res, flags)              \
     18     asm ("pushq %3\n\t"\
     19          "popfq\n\t"\
     20          stringify(OP) size " %" mod "0\n\t" \
     21          "pushfq\n\t"\
     22          "popq %1\n\t"\
     23          : "=q" (res), "=g" (flags)\
     24          : "0" (res), "1" (flags));
     25 
     26 #ifdef OP1
     27 static inline void exec_opq(int64 s0, int64 s1, int64 iflags)
     28 {
     29     int64 res, flags;
     30     res = s0;
     31     flags = iflags;
     32     EXECOP1("q", "q", res, flags);
     33     xxprintf("%-6s A=%016llx R=%016llx CCIN=%04llx CC=%04llx\n",
     34            stringify(OP) "q", s0, res, iflags, flags & CC_MASK);
     35 }
     36 static inline void exec_opl(int64 s0, int64 s1, int64 iflags)
     37 {
     38     int64 res, flags;
     39     res = s0;
     40     flags = iflags;
     41     EXECOP1("l", "k", res, flags);
     42     xxprintf("%-6s A=%016llx R=%016llx CCIN=%04llx CC=%04llx\n",
     43            stringify(OP) "l", s0, res, iflags, flags & CC_MASK);
     44 }
     45 static inline void exec_opw(int64 s0, int64 s1, int64 iflags)
     46 {
     47     int64 res, flags;
     48     res = s0;
     49     flags = iflags;
     50     EXECOP1("w", "w", res, flags);
     51     xxprintf("%-6s A=%016llx R=%016llx CCIN=%04llx CC=%04llx\n",
     52            stringify(OP) "w", s0, res, iflags, flags & CC_MASK);
     53 }
     54 static inline void exec_opb(int64 s0, int64 s1, int64 iflags)
     55 {
     56     int64 res, flags;
     57     res = s0;
     58     flags = iflags;
     59     EXECOP1("b", "b", res, flags);
     60     xxprintf("%-6s A=%016llx R=%016llx CCIN=%04llx CC=%04llx\n",
     61            stringify(OP) "b", s0, res, iflags, flags & CC_MASK);
     62 }
     63 #else
     64 static inline void exec_opq(int64 s0, int64 s1, int64 iflags)
     65 {
     66     int64 res, flags;
     67     res = s0;
     68     flags = iflags;
     69     EXECOP2("q", "q", res, s1, flags);
     70     xxprintf("%-6s A=%016llx B=%016llx R=%016llx CCIN=%04llx CC=%04llx\n",
     71            stringify(OP) "q", s0, s1, res, iflags, flags & CC_MASK);
     72 }
     73 
     74 static inline void exec_opl(int64 s0, int64 s1, int64 iflags)
     75 {
     76     int64 res, flags;
     77     res = s0;
     78     flags = iflags;
     79     EXECOP2("l", "k", res, s1, flags);
     80     xxprintf("%-6s A=%016llx B=%016llx R=%016llx CCIN=%04llx CC=%04llx\n",
     81            stringify(OP) "l", s0, s1, res, iflags, flags & CC_MASK);
     82 }
     83 #ifndef NSH
     84 static inline void exec_opw(int64 s0, int64 s1, int64 iflags)
     85 {
     86     int64 res, flags;
     87     res = s0;
     88     flags = iflags;
     89     EXECOP2("w", "w", res, s1, flags);
     90     xxprintf("%-6s A=%016llx B=%016llx R=%016llx CCIN=%04llx CC=%04llx\n",
     91            stringify(OP) "w", s0, s1, res, iflags, flags & CC_MASK);
     92 }
     93 
     94 static inline void exec_opb(int64 s0, int64 s1, int64 iflags)
     95 {
     96     int64 res, flags;
     97     res = s0;
     98     flags = iflags;
     99     EXECOP2("b", "b", res, s1, flags);
    100     xxprintf("%-6s A=%016llx B=%016llx R=%016llx CCIN=%04llx CC=%04llx\n",
    101            stringify(OP) "b", s0, s1, res, iflags, flags & CC_MASK);
    102 }
    103 #endif
    104 #endif
    105 
    106 void exec_op(int64 s0, int64 s1)
    107 {
    108 #if 1
    109   int64 o,s,z,a,c,p,flags_in;
    110   for (o = 0; o < 2; o++) {
    111   for (s = 0; s < 2; s++) {
    112   for (z = 0; z < 2; z++) {
    113   for (a = 0; a < 2; a++) {
    114   for (c = 0; c < 2; c++) {
    115   for (p = 0; p < 2; p++) {
    116 
    117     flags_in = (o ? CC_O : 0)
    118              | (s ? CC_S : 0)
    119              | (z ? CC_Z : 0)
    120              | (a ? CC_A : 0)
    121              | (c ? CC_C : 0)
    122              | (p ? CC_P : 0);
    123     exec_opq(s0, s1, flags_in);
    124     exec_opl(s0, s1, flags_in);
    125 #ifndef NSH
    126     exec_opw(s0, s1, flags_in);
    127     exec_opb(s0, s1, flags_in);
    128 #endif
    129   }}}}}}
    130 #else
    131     exec_opq(s0, s1, 0);
    132     exec_opl(s0, s1, 0);
    133     exec_opw(s0, s1, 0);
    134     exec_opb(s0, s1, 0);
    135     exec_opq(s0, s1, CC_C);
    136     exec_opl(s0, s1, CC_C);
    137     exec_opw(s0, s1, CC_C);
    138     exec_opb(s0, s1, CC_C);
    139 #endif
    140 }
    141 
    142 void glue(test_, OP)(void)
    143 {
    144 #define NVALS 57
    145    int64 i, j;
    146    static unsigned int val[NVALS]
    147     = { 0x00, 0x01, 0x02, 0x03,
    148         0x3F, 0x40, 0x41,
    149         0x7E, 0x7F, 0x80, 0x81, 0x82,
    150         0xBF, 0xC0, 0xC1,
    151         0xFC, 0xFD, 0xFE, 0xFF,
    152 
    153         0xFF00, 0xFF01, 0xFF02, 0xFF03,
    154         0xFF3F, 0xFF40, 0xFF41,
    155         0xFF7E, 0xFF7F, 0xFF80, 0xFF81, 0xFF82,
    156         0xFFBF, 0xFFC0, 0xFFC1,
    157         0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF,
    158 
    159         0xFFFFFF00, 0xFFFFFF01, 0xFFFFFF02, 0xFFFFFF03,
    160         0xFFFFFF3F, 0xFFFFFF40, 0xFFFFFF41,
    161         0xFFFFFF7E, 0xFFFFFF7F, 0xFFFFFF80, 0xFFFFFF81, 0xFFFFFF82,
    162         0xFFFFFFBF, 0xFFFFFFC0, 0xFFFFFFC1,
    163         0xFFFFFFFC, 0xFFFFFFFD, 0xFFFFFFFE, 0xFFFFFFFF
    164       };
    165 
    166     exec_op(0xabcd12345678, 0x4321812FADA);
    167     exec_op(0x12345678, 0x812FADA);
    168     exec_op(0xabcd00012341, 0xabcd00012341);
    169     exec_op(0x12341, 0x12341);
    170     exec_op(0x12341, -0x12341);
    171     exec_op(0xffffffff, 0);
    172     exec_op(0xffffffff, -1);
    173     exec_op(0xffffffff, 1);
    174     exec_op(0xffffffff, 2);
    175     exec_op(0x7fffffff, 0);
    176     exec_op(0x7fffffff, 1);
    177     exec_op(0x7fffffff, -1);
    178     exec_op(0x80000000, -1);
    179     exec_op(0x80000000, 1);
    180     exec_op(0x80000000, -2);
    181     exec_op(0x12347fff, 0);
    182     exec_op(0x12347fff, 1);
    183     exec_op(0x12347fff, -1);
    184     exec_op(0x12348000, -1);
    185     exec_op(0x12348000, 1);
    186     exec_op(0x12348000, -2);
    187     exec_op(0x12347f7f, 0);
    188     exec_op(0x12347f7f, 1);
    189     exec_op(0x12347f7f, -1);
    190     exec_op(0x12348080, -1);
    191     exec_op(0x12348080, 1);
    192     exec_op(0x12348080, -2);
    193 
    194     exec_op(0xFFFFFFFFffffffff, 0);
    195     exec_op(0xFFFFFFFFffffffff, -1);
    196     exec_op(0xFFFFFFFFffffffff, 1);
    197     exec_op(0xFFFFFFFFffffffff, 2);
    198     exec_op(0x7fffffffFFFFFFFF, 0);
    199     exec_op(0x7fffffffFFFFFFFF, 1);
    200     exec_op(0x7fffffffFFFFFFFF, -1);
    201     exec_op(0x8000000000000000, -1);
    202     exec_op(0x8000000000000000, 1);
    203     exec_op(0x8000000000000000, -2);
    204     exec_op(0x123443217FFFFFFF, 0);
    205     exec_op(0x123443217FFFFFFF, 1);
    206     exec_op(0x123443217FFFFFFF, -1);
    207     exec_op(0x1234432180000000, -1);
    208     exec_op(0x1234432180000000, 1);
    209     exec_op(0x1234432180000000, -2);
    210     exec_op(0x123443217F7F7f7f, 0);
    211     exec_op(0x123443217F7F7f7f, 1);
    212     exec_op(0x123443217F7F7f7f, -1);
    213     exec_op(0x1234432180808080, -1);
    214     exec_op(0x1234432180808080, 1);
    215     exec_op(0x1234432180808080, -2);
    216 
    217 #if TEST_INTEGER_VERBOSE
    218     if (1)
    219     for (i = 0; i < NVALS; i++)
    220       for (j = 0; j < NVALS; j++)
    221 	exec_op(val[i], val[j]);
    222 #endif
    223 
    224 #undef NVALS
    225 }
    226 
    227 #undef OP
    228 #undef OP_CC
    229 #undef NSH
    230