1#include "const.h"
2
3#define TEST1(instruction, offset, mem)        \
4{                                              \
5   unsigned long out = 0;                      \
6   __asm__ __volatile__(                       \
7      "move        $t0, %1"        "\n\t"      \
8      "move        $t1, %2"        "\n\t"      \
9      "daddu       $t0, $t0, $t1"  "\n\t"      \
10      "move        $t1, $zero"     "\n\t"      \
11      instruction" $t1, 0($t0)"    "\n\t"      \
12      "move        %0,  $t1"       "\n\t"      \
13      : "=r" (out)                             \
14      : "r" (mem), "r" (offset)                \
15      : "t0", "t1"                             \
16   );                                          \
17   printf("%s :: offset: 0x%x, out: 0x%lx\n",  \
18          instruction, offset, out);           \
19}
20
21#define TEST2(instruction, offset)                           \
22{                                                            \
23   unsigned long out = 0;                                    \
24   unsigned long outHI = 0;                                  \
25   __asm__ __volatile__(                                     \
26      "move        $t0, %2"          "\n\t"                  \
27      "move        $t1, %4"          "\n\t"                  \
28      "daddu       $t0, $t0, $t1"    "\n\t"                  \
29      "ld          $t3, 0($t0)"      "\n\t"                  \
30      "move        $t1, %3"          "\n\t"                  \
31      "move        $t2, %4"          "\n\t"                  \
32      "daddu       $t1, $t1, $t2"    "\n\t"                  \
33      instruction" $t3, 0($t1)"      "\n\t"                  \
34      "li          $t2, 7"           "\n\t"                  \
35      "nor         $t2, $t2, $zero"  "\n\t"                  \
36      "and         $t1, $t1, $t2"    "\n\t"                  \
37      "ld          %0,  0($t1)"      "\n\t"                  \
38      "ld          %1,  8($t1)"      "\n\t"                  \
39      : "=r" (out), "=r" (outHI)                             \
40      : "r" (reg_val2) , "r" (reg_val_zero), "r" (offset)    \
41      : "t0", "t1", "t2", "t3"                               \
42   );                                                        \
43   printf("%s :: offset: 0x%x, out: 0x%lx, outHI: 0x%lx\n",  \
44          instruction, offset, out, outHI);                  \
45}
46
47#define TEST3(instruction, offset, mem)         \
48{                                               \
49   unsigned long long out = 0;                  \
50   __asm__ __volatile__(                        \
51      "move        $t0,   %1"        "\n\t"     \
52      "move        $t1,   %2"        "\n\t"     \
53      "daddu       $t0,   $t0, $t1"  "\n\t"     \
54      "dmtc1       $zero, $f0"       "\n\t"     \
55      instruction" $f0,  0($t0)"     "\n\t"     \
56      "dmfc1       %0,    $f0"       "\n\t"     \
57      : "=r" (out)                              \
58      : "r" (mem) , "r" (offset)                \
59      : "t0", "t1", "$f0"                       \
60   );                                           \
61   printf("%s :: offset: 0x%x, out: 0x%llx\n",  \
62          instruction, offset, out);            \
63}
64
65#define TEST3w(instruction, offset, mem)      \
66{                                             \
67   unsigned int out = 0;                      \
68   __asm__ __volatile__(                      \
69      "move        $t0,   %1"        "\n\t"   \
70      "move        $t1,   %2"        "\n\t"   \
71      "daddu       $t0,   $t0, $t1"  "\n\t"   \
72      "dmtc1       $zero, $f0"       "\n\t"   \
73      instruction" $f0,  0($t0)"     "\n\t"   \
74      "mfc1        %0,    $f0"       "\n\t"   \
75      : "=r" (out)                            \
76      : "r" (mem) , "r" (offset)              \
77      : "t0", "t1", "$f0"                     \
78   );                                         \
79   printf("%s :: offset: 0x%x, out: 0x%x\n",  \
80          instruction, offset, out);          \
81}
82
83#define TEST4(instruction, offset)                         \
84{                                                          \
85   unsigned long long out = 0;                             \
86   __asm__ __volatile__(                                   \
87      "move        $t0, %1"        "\n\t"                  \
88      "move        $t1, %3"        "\n\t"                  \
89      "daddu       $t0, $t0, $t1"  "\n\t"                  \
90      "ld          $t2, 0($t0)"    "\n\t"                  \
91      "move        $t0, %2"        "\n\t"                  \
92      "daddu       $t0, $t0, $t1"  "\n\t"                  \
93      "dmtc1       $t2, $f0"       "\n\t"                  \
94      instruction" $f0, 0($t0)"    "\n\t"                  \
95      "ld          %0,  0($t0)"    "\n\t"                  \
96      : "=r" (out)                                         \
97      : "r" (reg_val1) , "r" (reg_val_zero), "r" (offset)  \
98      : "t0", "t1", "t2", "$f0"                            \
99   );                                                      \
100   printf("%s :: offset: 0x%x, out: 0x%llx\n",             \
101          instruction, offset, out);                       \
102}
103
104#define TEST5(instruction, offset, mem)         \
105{                                               \
106   unsigned long long out = 0;                  \
107   __asm__ __volatile__(                        \
108      "move        $t0,   %1"        "\n\t"     \
109      "move        $t1,   %2"        "\n\t"     \
110      "dmtc1       $zero, $f0"       "\n\t"     \
111      instruction" $f0,   $t1($t0)"  "\n\t"     \
112      "dmfc1       %0,    $f0"       "\n\t"     \
113      : "=r" (out)                              \
114      : "r" (mem) , "r" (offset)                \
115      : "t0", "t1", "$f0"                       \
116   );                                           \
117   printf("%s :: offset: 0x%x, out: 0x%llx\n",  \
118          instruction, offset, out);            \
119}
120
121#define TEST5w(instruction, offset, mem)      \
122{                                             \
123   unsigned int out = 0;                      \
124   __asm__ __volatile__(                      \
125      "move        $t0,   %1"        "\n\t"   \
126      "move        $t1,   %2"        "\n\t"   \
127      "dmtc1       $zero, $f0"       "\n\t"   \
128      instruction" $f0,   $t1($t0)"  "\n\t"   \
129      "mfc1        %0,    $f0"       "\n\t"   \
130      : "=r" (out)                            \
131      : "r" (mem) , "r" (offset)              \
132      : "t0", "t1", "$f0"                     \
133   );                                         \
134   printf("%s :: offset: 0x%x, out: 0x%x\n",  \
135          instruction, offset, out);          \
136}
137
138#define TEST6(instruction, offset)                         \
139{                                                          \
140   unsigned long long out = 0;                             \
141   __asm__ __volatile__(                                   \
142      "move        $t0, %1"        "\n\t"                  \
143      "move        $t1, %3"        "\n\t"                  \
144      "daddu       $t0, $t0, $t1"  "\n\t"                  \
145      "ld          $t3, 0($t0)"    "\n\t"                  \
146      "move        $t1, %2"        "\n\t"                  \
147      "move        $t2, %3"        "\n\t"                  \
148      "daddu       $t1, $t1, $t2"  "\n\t"                  \
149      "dmtc1       $t3, $f3"       "\n\t"                  \
150      "move        $t0, %3"        "\n\t"                  \
151      instruction" $f3, $t0($t1)"  "\n\t"                  \
152      "ld          %0,  0($t1)"    "\n\t"                  \
153      : "=r" (out)                                         \
154      : "r" (reg_val2) , "r" (reg_val_zero), "r" (offset)  \
155      : "t0", "t1", "t2", "t3"                             \
156   );                                                      \
157   printf("%s :: offset: 0x%x, out: 0x%llx\n",             \
158          instruction, offset, out);                       \
159}
160