1#include <stdio.h>
2#include "const.h"
3#include "macro_int.h"
4
5typedef enum {
6   AND=0,  ANDI,   LUI,    NOR,
7   OR,     ORI,    XOR,    XORI
8} logical_op;
9
10int main()
11{
12   logical_op op;
13   int i;
14   init_reg_val2();
15   for (op = AND; op <= XORI; op++) {
16      for (i = 0; i < N; i++) {
17         switch (op) {
18            case AND:
19               /* No Integer Overflow exception occurs under any
20                  circumstances. */
21               TEST1("and $t0, $t1, $t2", reg_val1[i], reg_val1[N-i-1],
22                                          t0, t1, t2);
23               TEST1("and $s0, $s1, $s2", reg_val2[i], reg_val2[N-i-1],
24                                          s0, s1, s2);
25               break;
26
27            case ANDI:
28               /* No Integer Overflow exception occurs under any
29                  circumstances. */
30               TEST2("andi $t0, $t1, 0xff",   reg_val1[i], 0xff,   t0, t1);
31               TEST2("andi $t2, $t3, 0xffff", reg_val1[i], 0xffff, t2, t3);
32               TEST2("andi $a0, $a1, 0x0",    reg_val1[i], 0x0,    a0, a1);
33               TEST2("andi $s0, $s1, 0x23",   reg_val1[i], 0x23,   s0, s1);
34               TEST2("andi $t0, $t1, 0xff",   reg_val2[i], 0xff,   t0, t1);
35               TEST2("andi $t2, $t3, 0xffff", reg_val2[i], 0xffff, t2, t3);
36               TEST2("andi $a0, $a1, 0x0",    reg_val2[i], 0x0,    a0, a1);
37               TEST2("andi $s0, $s1, 0x23",   reg_val2[i], 0x23,   s0, s1);
38               break;
39
40            case LUI:
41               /* No Integer Overflow exception occurs under any
42                  circumstances. */
43               if (i == 0) {
44                  TEST6("lui $t0, 0xffff", 0xffff, t0);
45                  TEST6("lui $a0, 0x0",    0x0,    a0);
46                  TEST6("lui $t9, 0xff",   0xff,   t9);
47                  TEST6("lui $v0, 0xfff",  0xfff,  v0);
48                  TEST6("lui $s0, 0x2",    0x2,    s0);
49               }
50               break;
51
52            case NOR:
53               /* No arithmetic exception occurs under any circumstances. */
54               TEST1("nor $t0, $t1, $t2", reg_val1[i], reg_val1[N-i-1],
55                                          t0, t1, t2);
56               TEST1("nor $s0, $s1, $s2", reg_val2[i], reg_val2[N-i-1],
57                                          s0, s1, s2);
58               break;
59
60            case OR:
61               /* No arithmetic exception occurs under any circumstances. */
62               TEST1("or $t0, $t1, $t2", reg_val1[i], reg_val1[N-i-1],
63                                         t0, t1, t2);
64               TEST1("or $s0, $s1, $s2", reg_val2[i], reg_val2[N-i-1],
65                                         s0, s1, s2);
66               break;
67
68            case ORI:
69               /* No arithmetic exception occurs under any circumstances. */
70               TEST2("ori $t0, $t1, 0xff",   reg_val1[i], 0xff,   t0, t1);
71               TEST2("ori $t2, $t3, 0xffff", reg_val1[i], 0xffff, t2, t3);
72               TEST2("ori $a0, $a1, 0x0",    reg_val1[i], 0x0,    a0, a1);
73               TEST2("ori $s0, $s1, 0x23",   reg_val1[i], 0x23,   s0, s1);
74               TEST2("ori $t0, $t1, 0xff",   reg_val2[i], 0xff,   t0, t1);
75               TEST2("ori $t2, $t3, 0xffff", reg_val2[i], 0xffff, t2, t3);
76               TEST2("ori $a0, $a1, 0x0",    reg_val2[i], 0x0,    a0, a1);
77               TEST2("ori $s0, $s1, 0x23",   reg_val2[i], 0x23,   s0, s1);
78               break;
79
80            case XOR:
81               /* No arithmetic exception occurs under any circumstances. */
82               TEST1("xor $t0, $t1, $t2", reg_val1[i], reg_val1[N-i-1],
83                                          t0, t1, t2);
84               TEST1("xor $s0, $s1, $s2", reg_val2[i], reg_val2[N-i-1],
85                                          s0, s1, s2);
86               break;
87
88            case XORI:
89               /* No arithmetic exception occurs under any circumstances. */
90               TEST2("xori $t0, $t1, 0xff",   reg_val1[i], 0xff,   t0, t1);
91               TEST2("xori $t2, $t3, 0xffff", reg_val1[i], 0xffff, t2, t3);
92               TEST2("xori $a0, $a1, 0x0",    reg_val1[i], 0x0,    a0, a1);
93               TEST2("xori $s0, $s1, 0x23",   reg_val1[i], 0x23,   s0, s1);
94               TEST2("xori $t0, $t1, 0xff",   reg_val2[i], 0xff,   t0, t1);
95               TEST2("xori $t2, $t3, 0xffff", reg_val2[i], 0xffff, t2, t3);
96               TEST2("xori $a0, $a1, 0x0",    reg_val2[i], 0x0,    a0, a1);
97               TEST2("xori $s0, $s1, 0x23",   reg_val2[i], 0x23,   s0, s1);
98               break;
99         }
100      }
101   }
102   return 0;
103}
104